Fundamentos da cadeia de middleware HTTP
Encapsule http.Handler e encadeie-o com next
Fundamentos da cadeia de middleware HTTP é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.
Camadas intermediárias em net/http
Na biblioteca padrão do Go, uma camada intermediária é uma função que aceita um http.Handler e retorna um novo http.Handler com comportamento adicional envolvido ao redor do original.
type Middleware func(http.Handler) http.HandlerCamada intermediária básica
O HandlerFunc interno envolve o manipulador original com uma lógica anterior e posterior:
func Logger(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Printf("→ %s %s", r.Method, r.URL.Path)
next.ServeHTTP(w, r)
log.Printf("← %s %s done", r.Method, r.URL.Path)
})
}Aplicação de camadas intermediárias
Envolva os manipuladores antes de registrá-los no multiplexador:
mux := http.NewServeMux()
mux.Handle("/api/", Logger(Auth(apiHandler)))
http.ListenAndServe(":8080", mux)Auxiliar de cadeia de camadas intermediárias
Uma função de cadeia aplica várias camadas intermediárias em uma ordem legível, da esquerda para a direita:
func Chain(h http.Handler, ms ...func(http.Handler) http.Handler) http.Handler {
for i := len(ms)-1; i >= 0; i-- { h = ms[i](h) }
return h
}
// Usage: Chain(handler, Logger, Auth, RateLimit)Contexto em camadas intermediárias
Anexe valores específicos da requisição criando um contexto derivado e envolvendo a requisição:
func RequestID(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := uuid.New().String()
ctx := context.WithValue(r.Context(), reqIDKey, id)
w.Header().Set("X-Request-ID", id)
next.ServeHTTP(w, r.WithContext(ctx))
})
}Contêiner de ResponseWriter
Capture o código de status gravado por um manipulador envolvendo o ResponseWriter:
type captureWriter struct {
http.ResponseWriter
status int
}
func (cw *captureWriter) WriteHeader(code int) {
cw.status = code
cw.ResponseWriter.WriteHeader(code)
}Camada intermediária de recuperação de falhas graves
Recupere-se de falhas graves para impedir que o servidor seja encerrado:
func Recovery(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if rec := recover(); rec != nil {
http.Error(w, "Internal Server Error", 500)
}
}()
next.ServeHTTP(w, r)
})
}A ordem é importante
A camada intermediária é executada na ordem em que envolve o manipulador. Recovery deve ser a mais externa (envolvendo tudo). Auth deve vir antes da lógica de negócio. O registro em logs geralmente deve ser externo, depois de Recovery.
Compatibilidade com roteadores de terceiros
Como a camada intermediária segue a assinatura padrão func(http.Handler) http.Handler, ela é compatível com chi, gorilla/mux e qualquer roteador que aceite http.Handler.
Global em comparação com específico da rota
Aplique a camada intermediária globalmente a todo o multiplexador ou envolva manipuladores individuais para obter um comportamento específico por rota. Os subroteadores do chi tornam mais simples a aplicação de camadas intermediárias no nível do grupo.
Testando camadas intermediárias
Utilize httptest.NewRecorder e httptest.NewRequest para testar camadas intermediárias isoladamente, sem iniciar um servidor real.
w := httptest.NewRecorder()
r := httptest.NewRequest("GET", "/", nil)
Logger(http.HandlerFunc(noop)).ServeHTTP(w, r)Verificação rápida
Qual é a assinatura padrão de uma camada intermediária em net/http?
Recapitulação: cadeia de camadas intermediárias
Pontos principais:
- func(http.Handler) http.Handler é a assinatura padrão
- Utilize um auxiliar Chain para evitar aninhamentos profundos
- r.WithContext(ctx) para anexar valores; utilize um contêiner de captura para registrar o status
- Recovery na camada mais externa; Auth antes da lógica de negócio; registro em logs depois de Recovery
Perguntas Frequentes
A aula “Fundamentos da cadeia de middleware HTTP” é grátis?
Sim — o texto completo de “Fundamentos da cadeia de middleware HTTP” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.
O que vou aprender em “Fundamentos da cadeia de middleware HTTP”?
Encapsule http.Handler e encadeie-o com next Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Go Academy?
Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Fundamentos da cadeia de middleware HTTP”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Go Academy?
Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Fundamentos da cadeia de middleware HTTP
- Middleware de logging e ID de requisição
- Middleware de autenticação e limitação de taxa
- Middleware de CORS e recuperação de panic