HTTP e HTTPS

import { createServer, type ServerResponse } from "node:http";

const pedidos = new Map([["1", { id: "1", status: "enviado" }]]);

const servidor = createServer((req, res) => {
  const url = new URL(req.url ?? "/", "http://localhost");
  const rota = url.pathname.match(/^\/pedidos\/([^/]+)$/);

  if (!rota) {
    return enviar(res, 404, { erro: "rota não encontrada" });
  }
  if (req.method !== "GET") {
    res.setHeader("Allow", "GET");
    return enviar(res, 405, { erro: "método não permitido" });
  }

  const pedido = pedidos.get(rota[1]);
  if (!pedido) {
    return enviar(res, 404, { erro: "pedido não encontrado" });
  }
  enviar(res, 200, pedido);
});

function enviar(res: ServerResponse, status: number, corpo: unknown) {
  const json = JSON.stringify(corpo);
  res.writeHead(status, {
    "Content-Type": "application/json; charset=utf-8",
    "Content-Length": Buffer.byteLength(json),
  });
  res.end(json);
}

servidor.listen(3000);

import json
import re
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

PEDIDOS = {"1": {"id": "1", "status": "enviado"}}
ROTA = re.compile(r"^/pedidos/([^/]+)$")


class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        rota = ROTA.match(self.path.split("?")[0])
        if not rota:
            return self.enviar(404, {"erro": "rota não encontrada"})

        pedido = PEDIDOS.get(rota.group(1))
        if pedido is None:
            return self.enviar(404, {"erro": "pedido não encontrado"})
        self.enviar(200, pedido)

    def enviar(self, status, corpo):
        dados = json.dumps(corpo, ensure_ascii=False).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Content-Length", str(len(dados)))
        self.end_headers()
        self.wfile.write(dados)


ThreadingHTTPServer(("", 3000), Handler).serve_forever()

package main

import (
	"encoding/json"
	"log"
	"net/http"
)

type Pedido struct {
	ID     string `json:"id"`
	Status string `json:"status"`
}

var pedidos = map[string]Pedido{"1": {ID: "1", Status: "enviado"}}

func main() {
	mux := http.NewServeMux()

	mux.HandleFunc("GET /pedidos/{id}", func(w http.ResponseWriter, r *http.Request) {
		pedido, existe := pedidos[r.PathValue("id")]
		if !existe {
			enviar(w, http.StatusNotFound, map[string]string{"erro": "pedido não encontrado"})
			return
		}
		enviar(w, http.StatusOK, pedido)
	})

	log.Fatal(http.ListenAndServe(":3000", mux))
}

func enviar(w http.ResponseWriter, status int, corpo any) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(corpo)
}

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.Map;

public class Servidor {
    static final Map<String, String> PEDIDOS =
        Map.of("1", "{\"id\":\"1\",\"status\":\"enviado\"}");

    public static void main(String[] args) throws IOException {
        var servidor = HttpServer.create(new InetSocketAddress(3000), 0);

        servidor.createContext("/pedidos/", exchange -> {
            if (!exchange.getRequestMethod().equals("GET")) {
                exchange.getResponseHeaders().set("Allow", "GET");
                enviar(exchange, 405, "{\"erro\":\"método não permitido\"}");
                return;
            }

            var id = exchange.getRequestURI().getPath().substring("/pedidos/".length());
            var pedido = PEDIDOS.get(id);
            if (pedido == null) {
                enviar(exchange, 404, "{\"erro\":\"pedido não encontrado\"}");
                return;
            }
            enviar(exchange, 200, pedido);
        });

        servidor.start();
    }

    static void enviar(HttpExchange exchange, int status, String json) throws IOException {
        var dados = json.getBytes(StandardCharsets.UTF_8);
        exchange.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8");
        exchange.sendResponseHeaders(status, dados.length);
        try (var corpo = exchange.getResponseBody()) {
            corpo.write(dados);
        }
    }
}

var app = WebApplication.CreateBuilder(args).Build();

var pedidos = new Dictionary<string, Pedido>
{
    ["1"] = new Pedido("1", "enviado"),
};

app.MapGet("/pedidos/{id}", (string id) =>
    pedidos.TryGetValue(id, out var pedido)
        ? Results.Ok(pedido)
        : Results.NotFound(new { erro = "pedido não encontrado" }));

app.Run("http://localhost:3000");

record Pedido(string Id, string Status);

const resposta = await fetch("http://localhost:3000/pedidos/1", {
  signal: AbortSignal.timeout(3000),
});

if (!resposta.ok) {
  throw new Error(`falha ao buscar pedido: HTTP ${resposta.status}`);
}

const pedido = await resposta.json();

import json
import urllib.request

# urlopen lança HTTPError quando a resposta é 4xx ou 5xx
with urllib.request.urlopen("http://localhost:3000/pedidos/1", timeout=3) as resposta:
    pedido = json.load(resposta)

cliente := &http.Client{Timeout: 3 * time.Second}

resp, err := cliente.Get("http://localhost:3000/pedidos/1")
if err != nil {
	return err
}
defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {
	return fmt.Errorf("falha ao buscar pedido: HTTP %d", resp.StatusCode)
}

var pedido Pedido
if err := json.NewDecoder(resp.Body).Decode(&pedido); err != nil {
	return err
}

var cliente = HttpClient.newBuilder()
    .connectTimeout(Duration.ofSeconds(3))
    .build();

var requisicao = HttpRequest.newBuilder(URI.create("http://localhost:3000/pedidos/1"))
    .timeout(Duration.ofSeconds(3))
    .GET()
    .build();

var resposta = cliente.send(requisicao, HttpResponse.BodyHandlers.ofString());

if (resposta.statusCode() != 200) {
    throw new IOException("falha ao buscar pedido: HTTP " + resposta.statusCode());
}

String json = resposta.body();

using var cliente = new HttpClient { Timeout = TimeSpan.FromSeconds(3) };

var resposta = await cliente.GetAsync("http://localhost:3000/pedidos/1");
resposta.EnsureSuccessStatusCode();

var pedido = await resposta.Content.ReadFromJsonAsync<Pedido>();