Interfaz http.Handler

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 77 de 107.

La interfaz http.Handler es la base de la arquitectura del servidor web de Go. Define cómo se procesan las solicitudes HTTP, y cualquier tipo que la implemente puede atender solicitudes web.

La interfaz es notablemente simple:

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

Cualquier tipo con un método ServeHTTP puede manejar peticiones HTTP. Aquí tienes un manejador personalizado:

type GreetHandler struct {
    Greeting string
}

func (h GreetHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "%s, visitor!", h.Greeting)
}

Puedes usar este manejador directamente con un servidor:

handler := GreetHandler{Greeting: "Welcome"}
http.Handle("/greet", handler)

Para casos más sencillos, Go proporciona http.HandlerFunc, un tipo que te permite convertir una función regular en un manejador:

func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello!")
}

http.Handle("/hello", http.HandlerFunc(hello))

El poder de esta interfaz se vuelve evidente cuando te das cuenta de que los manejadores pueden envolver a otros manejadores. Esto permite patrones de middleware donde se añade registro (logging), autenticación u otros aspectos transversales sin modificar la lógica del manejador original.

Desafío

Fácil

¡Vamos a construir un sistema de manejo de HTTP simple que simule cómo se procesan las solicitudes web! Dado que no podemos ejecutar un servidor HTTP real en este entorno, crearás manejadores que implementen la interfaz http.Handler y demostrarás cómo procesan las solicitudes trabajando con objetos simulados (mock) de solicitud/respuesta.

Organizarás tu código en dos archivos:

handlers.go: Define tus manejadores HTTP personalizados.
Crea una estructura MockResponseWriter que capture lo que se escribiría en una respuesta HTTP. Debe almacenar el cuerpo de la respuesta como un string e implementar un método Write(data []byte) (int, error) que añada datos al cuerpo. Añade un método Body() string para recuperar la respuesta acumulada.

Crea una estructura MockRequest con los campos de string Path y Method para simular una solicitud HTTP.

Ahora crea dos estructuras de manejador que implementen el patrón de la interfaz http.Handler (con un método ServeHTTP que reciba un *MockResponseWriter y un *MockRequest):
- WelcomeHandler con un campo Message: escribe el mensaje seguido de la ruta de la solicitud.
- MethodHandler: escribe diferentes respuestas basadas en el método de la solicitud: "Fetching data" para GET, "Creating resource" para POST, y "Method not supported" para cualquier otra cosa.
main.go: Procesa las solicitudes a través de tus manejadores.
Lee un tipo de manejador (welcome o method), luego lee los detalles de la solicitud. Para el manejador de bienvenida, lee también el mensaje de bienvenida.

Crea el manejador apropiado, construye una solicitud simulada y llama a ServeHTTP para procesarla. Imprime el cuerpo de la respuesta.

Se proporcionarán las siguientes entradas:

Línea 1: Tipo de manejador (welcome o method)
Línea 2: Ruta de la solicitud
Línea 3: Método de la solicitud
Línea 4 (solo para welcome): Mensaje de bienvenida

Por ejemplo, dado:

welcome
/home
GET
Hello from

Tu salida debería ser:

Hello from /home

Y dado:

method
/api/users
POST

Tu salida debería ser:

Creating resource

Y dado:

method
/api/data
GET

Tu salida debería ser:

Fetching data

Y dado:

method
/api/items
DELETE

Tu salida debería ser:

Method not supported

Este desafío demuestra el concepto central de la interfaz http.Handler: cualquier tipo con un método ServeHTTP puede manejar solicitudes. En aplicaciones reales, el http.ResponseWriter y el *http.Request provienen de la biblioteca estándar de Go, pero el patrón de implementación de los manejadores sigue siendo exactamente el mismo.

Hoja de referencia

La interfaz http.Handler es la base de la arquitectura del servidor web de Go:

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

Cualquier tipo con un método ServeHTTP puede manejar solicitudes HTTP:

type GreetHandler struct {
    Greeting string
}

func (h GreetHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "%s, visitor!", h.Greeting)
}

Registra un manejador con el servidor:

handler := GreetHandler{Greeting: "Welcome"}
http.Handle("/greet", handler)

Para casos más sencillos, utiliza http.HandlerFunc para convertir una función en un manejador:

func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello!")
}

http.Handle("/hello", http.HandlerFunc(hello))

Los manejadores pueden envolver a otros manejadores, permitiendo patrones de middleware para el registro (logging), la autenticación u otros aspectos transversales.

Pruébalo tú mismo

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Leer el tipo de manejador
	scanner.Scan()
	handlerType := scanner.Text()
	
	// Leer la ruta de la solicitud
	scanner.Scan()
	path := scanner.Text()
	
	// Leer el método de la solicitud
	scanner.Scan()
	method := scanner.Text()
	
	// Crear una solicitud simulada (mock request)
	request := &MockRequest{
		Path:   path,
		Method: method,
	}
	
	// Crear un escritor de respuesta simulado (mock response writer)
	response := &MockResponseWriter{}
	
	// TODO: Basado en handlerType, crear el manejador apropiado
	// Si handlerType es "welcome", leer el mensaje de bienvenida y crear WelcomeHandler
	// Si handlerType es "method", crear MethodHandler
	// Llamar a ServeHTTP en el manejador con response y request
	
	if handlerType == "welcome" {
		scanner.Scan()
		message := scanner.Text()
		// TODO: Crear WelcomeHandler con el mensaje y llamar a ServeHTTP
		_ = message // Eliminar esta línea al implementar
	} else if handlerType == "method" {
		// TODO: Crear MethodHandler y llamar a ServeHTTP
	}
	
	// Imprimir el cuerpo de la respuesta
	fmt.Println(response.Body())
}