Lección 35 de 36 · Proyecto final: CRUD de tareas con SQLite✦ WebMCP implementado
Fase 5: controladores y vistas, MVC con net/http
10 min de lectura4 retos
Toca abrir la puerta de la calle: la web. En esta fase escribes el paquete internal/web con las rutas, los controladores (que llaman a los casos de uso) y las vistas con html/template. Todo con la biblioteca estándar, sin framework, y probado con httptest.
¿De dónde vienen los nombres?
ServeMux = serve (servir) + mux, de multiplexer (multiplexor)
Un multiplexor recibe muchas entradas y elige a dónde va cada una. La documentación lo llama «HTTP request multiplexer»: es tu router, el routes/web.php de Laravel.
PathValue = path (ruta) + value (valor)
Lee un trozo de la URL marcado con llaves, como {id} en /tareas/{id}. En Laravel, el $id que recibe el controlador.
httptest = http + test
Paquete para probar handlers sin abrir un puerto: fabrica peticiones falsas y graba las respuestas. Como el $this->get('/tareas') de los tests de Laravel.
En 4 ideas
1/4
Las rutas se registran en un http.ServeMux con el método y la URL: mux.HandleFunc("POST /tareas/{id}/completar", c.completar). Es tu Route::post('/tareas/{id}/completar', ...) de Laravel.
Un controlador es una función (w http.ResponseWriter, r *http.Request): lee de r (r.FormValue, r.PathValue) y escribe en w. En PHP lee $_POST o $request y devuelve un Response.
Los errores del dominio se traducen a códigos HTTP con errors.Is: ErrTareaNoEncontrada → 404. En PHP, un catch (TareaNoEncontrada) que devuelve un 404.
html/template es tu Blade o Twig: escapa solo todo lo que pintas. Y httptest prueba los handlers sin servidor, como los tests HTTP de Laravel.
1 · Las rutas: el routes/web.php de Go
MVC es repartir el trabajo en tres: el Modelo (nuestro dominio y casos de uso), la Vista (las plantillas HTML) y el Controlador, que recibe la petición, llama al modelo y elige la vista. Como en un restaurante: el camarero (controlador) toma nota, la cocina (modelo) cocina y el emplatado (vista) lo presenta.
Ya montaste un servidor con net/http en el módulo 07. Desde Go 1.22, el ServeMux de la biblioteca estándar entiende el método y los trozos variables de la URL, así que para un CRUD no hace falta ningún router de fuera:
Gomain.go
// Rutas es el routes/web.php de la app.func (c *Controlador) Rutas() http.Handler {
mux := http.NewServeMux()
// {$} = solo «/» exacta, no cualquier ruta que empiece por /
mux.HandleFunc("GET /{$}", func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "/tareas", http.StatusSeeOther)
})
mux.HandleFunc("GET /tareas", c.listar)
mux.HandleFunc("POST /tareas", c.crear)
mux.HandleFunc("POST /tareas/{id}/completar", c.completar)
mux.HandleFunc("POST /tareas/{id}/borrar", c.borrar)
mux.HandleFunc("GET /api/tareas", c.apiListar)
mux.HandleFunc("GET /api/tareas/{id}", c.apiVer)
return mux
}
El controlador es un struct que guarda lo que necesita: los casos de uso de la fase 4 y las plantillas ya cargadas. Cada ruta apunta a uno de sus métodos (c.listar, c.crear…), que Go acepta como función (módulo 06).
2 · Los controladores: leer, llamar, responder
Cada handler hace siempre lo mismo, en tres pasos: lee la petición, llama a un caso de uso y responde. No hay lógica de negocio dentro: eso ya lo hace el dominio.
PHP 8.5tareas-controller.php
<?phpdeclare(strict_types=1);
namespace App\Infrastructure\Http;
use App\Application\CrearTareaHandler;
use App\Domain\{Prioridad, TituloLargo, TituloVacio};
use Symfony\Component\HttpFoundation\{RedirectResponse, Request, Response};
use Symfony\Component\Routing\Attribute\Route;
finalreadonlyclass TareasController
{
publicfunction__construct(private CrearTareaHandler $crear) {}
#[Route("/tareas", methods: ["POST"])]
publicfunctioncrear(Request $request): Response
{
$prioridad = Prioridad::tryFrom($request->request->getInt("prioridad"))
?? Prioridad::Media;
try {
($this->crear)($request->request->getString("titulo"), $prioridad);
} catch (TituloVacio | TituloLargo $e) {
returnnewResponse($e->getMessage(), 422);
}
// Post/Redirect/Get: F5 no vuelve a crear la tareareturnnewRedirectResponse("/tareas", 303);
}
}
Gocontrolador.go
package web
typeControladorstruct {
cu casosdeuso.Tareas
vistas *template.Template
}
func (c *Controlador) crear(w http.ResponseWriter, r *http.Request) {
// En PHP: $request->request->getInt("prioridad") o $_POST["prioridad"]
prioridad, err := strconv.Atoi(r.FormValue("prioridad"))
if err != nil {
prioridad = int(dominio.Media)
}
_, err = c.cu.Crear.Ejecutar(r.FormValue("titulo"), dominio.Prioridad(prioridad))
if err != nil {
c.fallo(w, err)
return
}
// Post/Redirect/Get: F5 no vuelve a crear la tarea
http.Redirect(w, r, "/tareas", http.StatusSeeOther)
}
func (c *Controlador) completar(w http.ResponseWriter, r *http.Request) {
// En PHP: el {id} de la ruta, que llega como string
id, err := strconv.Atoi(r.PathValue("id"))
if err != nil {
http.Error(w, "id no válido", http.StatusBadRequest)
return
}
if _, err := c.cu.Completar.Ejecutar(id); err != nil {
c.fallo(w, err)
return
}
http.Redirect(w, r, "/tareas", http.StatusSeeOther)
}
r.FormValue("titulo") es tu $_POST['titulo'] ?? '': si no viene, devuelve un string vacío, nunca null. Y r.PathValue("id") siempre es texto, así que se convierte con strconv.Atoi (módulo 01) y, si no es un número, 400 Bad Request.
¿Por qué? · En PHP no existe
¿Por qué el handler no devuelve la respuesta? En PHP haces return new Response()
En Symfony o Laravel el controlador devuelve un objeto Response y el framework lo envía al final. En Go no hay framework que espere: el handler escribe directamente en w, que es la conexión con el navegador. Así se puede enviar un fichero enorme poco a poco sin cargarlo entero en memoria.
A cambio, hay un orden obligatorio, como al mandar una carta: primero el sobre y luego el contenido.
Las cabeceras: w.Header().Set("Content-Type", "application/json").
El código de estado: w.WriteHeader(http.StatusCreated). Si no lo llamas, el primer Write envía un 200.
El cuerpo: w.Write(...), fmt.Fprint(w, ...) o json.NewEncoder(w).Encode(...).
Una vez enviado el cuerpo, ya no puedes cambiar el código. Es el mismo problema que el «headers already sent» de PHP, pero sin aviso: Go escribe en el log superfluous response.WriteHeader call y el navegador recibe el código antiguo. Por eso, tras un http.Error(...), siempre va un return.
3 · De errores del dominio a códigos HTTP
Los casos de uso devuelven errores del dominio, envueltos con más contexto. La web los traduce a un código HTTP en un solo sitio, una función pequeña:
Gomain.go
// estadoHTTP traduce un error del dominio a un código HTTP.funcestadoHTTP(err error) int {
switch {
case errors.Is(err, dominio.ErrTareaNoEncontrada):
return http.StatusNotFoundcase errors.Is(err, dominio.ErrTituloVacio),
errors.Is(err, dominio.ErrTituloLargo),
errors.Is(err, dominio.ErrPrioridadInvalida),
errors.Is(err, dominio.ErrEtiquetaInvalida):
return http.StatusUnprocessableEntitycase errors.Is(err, dominio.ErrYaCompletada):
return http.StatusConflict
}
return http.StatusInternalServerError
}
Fíjate: siempre errors.Is, nunca ==. El error que llega es completar: buscar tarea 9: tarea no encontrada, una cadena de sobres (fase 3), y solo errors.Is los abre. Míralo con httptest, que graba la respuesta sin abrir ningún puerto:
Gomain.go
package main
import (
"errors""fmt""net/http""net/http/httptest"
)
varErrTareaNoEncontrada = errors.New("tarea no encontrada")
// Lo que devolvería CompletarTarea con un id que no existe.funccompletar(id int) error {
errRepo := fmt.Errorf("buscar tarea %d: %w", id, ErrTareaNoEncontrada)
return fmt.Errorf("completar: %w", errRepo)
}
funcconIgual(w http.ResponseWriter, r *http.Request) {
err := completar(9)
// En PHP sería como comparar el mensaje de la excepción con ===if err == ErrTareaNoEncontrada {
http.Error(w, err.Error(), http.StatusNotFound)
return
}
if err != nil {
http.Error(w, "algo ha ido mal", http.StatusInternalServerError)
return
}
}
funcconErrorsIs(w http.ResponseWriter, r *http.Request) {
err := completar(9)
// En PHP: catch (TareaNoEncontrada $e)if errors.Is(err, ErrTareaNoEncontrada) {
http.Error(w, err.Error(), http.StatusNotFound)
return
}
if err != nil {
http.Error(w, "algo ha ido mal", http.StatusInternalServerError)
return
}
}
funcmain() {
handlers := []struct {
nombre string
handler http.HandlerFunc
}{
{"con ==", conIgual},
{"con errors.Is", conErrorsIs},
}
for _, h := range handlers {
rec := httptest.NewRecorder()
h.handler(rec, httptest.NewRequest("POST", "/tareas/9/completar", nil))
fmt.Printf("%-14s → %d %s", h.nombre, rec.Code, rec.Body.String())
}
}
Error
Código
Por qué
ErrTareaNoEncontrada
404 Not Found
El id no existe
ErrTituloVacio, ErrTituloLargo…
422 Unprocessable Entity
La petición se entiende, pero los datos no valen
ErrYaCompletada
409 Conflict
Choca con el estado actual de la tarea
Cualquier otro
500 Internal Server Error
Fallo nuestro: se escribe en el log y al usuario no se le enseña el detalle
4 · Las vistas: html/template frente a Blade y Twig
La vista es un fichero HTML con huecos, como una plantilla de Blade o Twig. Va en internal/web/plantillas/ y se mete en el binario con //go:embed, igual que las migraciones de la fase 1:
El punto . es «el dato actual»: fuera del range son los datos que pasas a la plantilla y dentro es cada tarea. Y {{.Prioridad}} pinta alta porque llama solo al String() de la fase 2.
¿Por qué html/template y no text/template? En PHP con echo no hay elección
Go trae dos paquetes de plantillas con la misma sintaxis. text/template pinta el texto tal cual: sirve para correos de texto o ficheros de configuración. html/template sabe que está escribiendo HTML y escapa cada hueco según dónde está: dentro de una etiqueta, de un atributo, de una URL o de un <script>.
En PHP, con un echo $titulo a pelo, una tarea llamada <script>…</script> se ejecuta en el navegador de todos tus usuarios (un ataque XSS). Blade y Twig lo evitan escapando con htmlspecialchars(), que solo conoce un contexto. html/template va más allá: en un href también bloquea un javascript: con #ZgotmplZ.
La regla: si sale en una página web, siemprehtml/template. Se nota solo en el import, así que revísalo.
5 · Probar los handlers con httptest
httptest.NewRequest fabrica una petición falsa y httptest.NewRecorder es un ResponseWriter que lo apunta todo: el código, las cabeceras y el cuerpo. Se la pasas al mux completo y así pruebas también las rutas, como $this->post('/tareas') en Laravel:
Gomain.go
package main
import (
"fmt""net/http""net/http/httptest""net/url""strings"
)
var titulos []stringfunccrear(w http.ResponseWriter, r *http.Request) {
// En PHP: $titulo = trim($_POST['titulo'] ?? '');
titulo := strings.TrimSpace(r.FormValue("titulo"))
if titulo == "" {
http.Error(w, "el título está vacío", http.StatusUnprocessableEntity)
return
}
titulos = append(titulos, titulo)
http.Redirect(w, r, "/tareas", http.StatusSeeOther)
}
funcmain() {
mux := http.NewServeMux()
mux.HandleFunc("POST /tareas", crear)
for _, titulo := range []string{"Comprar pan", " "} {
form := url.Values{"titulo": {titulo}}
req := httptest.NewRequest("POST", "/tareas", strings.NewReader(form.Encode()))
// Sin esta cabecera, FormValue no lee el cuerpo.
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
rec := httptest.NewRecorder()
mux.ServeHTTP(rec, req)
fmt.Printf("POST %q → %d %s\n", titulo, rec.Code, rec.Header().Get("Location"))
}
rec := httptest.NewRecorder()
mux.ServeHTTP(rec, httptest.NewRequest("GET", "/tareas", nil))
fmt.Println("GET /tareas →", rec.Code)
fmt.Println("guardadas:", titulos)
}
Fíjate en el GET /tareas → 405: en este mux de juguete solo existe el POST, y el ServeMux contesta solo «método no permitido», como viste al principio de la lección.
En el proyecto, los tests montan la app de verdad con el repositorio en memoria, sin SQLite:
$ go test -v ./internal/web/
=== RUN TestCrearYListar
--- PASS: TestCrearYListar (0.00s)
=== RUN TestApiVerNoEncontrada
--- PASS: TestApiVerNoEncontrada (0.00s)
=== RUN TestApiListarVacia
--- PASS: TestApiListarVacia (0.00s)
PASS
ok tareas/internal/web 0.015s
La pregunta que te vas a hacer
«Vale, pero… ¿y Laravel o Symfony? ¿No uso ningún framework?»
Para un CRUD como este, la biblioteca estándar basta y sobra: rutas con método, plantillas seguras, JSON y tests. Muchos equipos de Go trabajan así. Si tu proyecto crece y echas de menos algo, hay piezas sueltas para cada cosa:
chi: router con grupos y middlewares, compatible con net/http (como Slim).
Gin: framework con validación y binding de formularios (como Lumen).
templ: plantillas que se compilan a Go y dan error si te equivocas de campo, como un Blade con tipos.
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
La API en JSON
Completa el handler apiListar: debe responder 200, con la cabecera Content-Type: application/json y la lista en JSON usando tareaJSON (ya tiene sus etiquetas), por ejemplo [{"id":1,"titulo":"Comprar pan","hecha":false}]. Si no hay tareas, el cuerpo debe ser [], no null. Es el return response()->json($tareas) de Laravel.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Convierte cada Tarea en tareaJSON dentro de un slice creado con make([]tareaJSON, 0, len(tareas)): un slice nil sale como null en JSON. Luego, en orden: w.Header().Set(...), w.WriteHeader(200) y json.NewEncoder(w).Encode(salida).
Reto 2 de 4 · ✓ Resuelto
Ver una tarea: 200, 400 o 404
Completa apiVer, la ruta GET /api/tareas/{id}: lee el id con r.PathValue("id"); si no es un número, 400; si el repositorio da un error que lleva dentroErrTareaNoEncontrada, 404; con cualquier otro error, 500; y si va bien, 200 con el JSON de la tarea. En Laravel sería el findOrFail($id) que da un 404 solo.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.strconv.Atoi(r.PathValue("id")) para el id (con su 400 si falla). El error del repositorio viene envuelto (buscar tarea 7: …): compáralo con errors.Is, no con ==. Usa escribirJSON para cada respuesta y no olvides el return después de cada error.
Reto 3 de 4 · ✓ Resuelto
El formulario: crear y redirigir
Completa crear, la ruta POST /tareas: lee titulo del formulario y llama a a.crearTarea(titulo). Si da ErrTituloVacio, responde 422 con el mensaje del error; si va bien, redirige a /tareas con un 303 See Other (el patrón Post/Redirect/Get). En PHP sería $_POST['titulo'] y un header('Location: /tareas', true, 303).
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Guarda el error de a.crearTarea(titulo). Si errors.Is(err, ErrTituloVacio), http.Error(w, err.Error(), http.StatusUnprocessableEntity) y return. Si todo fue bien, http.Redirect(w, r, "/tareas", http.StatusSeeOther).
Reto 4 de 4 · ✓ Resuelto
Una vista segura
Completa PintarLista(w io.Writer, tareas []Tarea) error y su plantilla: cada tarea en un <li> con [x] si está hecha o [ ] si no, seguido del título; si no hay tareas, un único <li>No hay tareas</li>. Y un título como <b>Comprar pan</b> debe salir escapado (<b>…). Es tu @forelse de Blade con {{ }}.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Tres cambios: dentro del range, {{if .Hecha}}[x]{{else}}[ ]{{end}} y un espacio antes de {{.Titulo}}; un {{else}} antes del {{end}} del range para la lista vacía; y mira bien el import: text/template no escapa nada.
Resumen
Lo que te llevas de esta lección
mux.HandleFunc("POST /tareas/{id}/completar", c.completar) registra una ruta con método (en Laravel, Route::post()).
Un handler lee de r (FormValue, PathValue) y escribe en w: cabeceras, código y cuerpo, en ese orden (en PHP, $_POST y return new Response()).
Los errores del dominio se traducen a 404/422/409 con errors.Is en un solo sitio (en PHP, los catch del controlador).
html/template escapa según el contexto (en PHP, Blade o Twig con {{ }}); text/template no escapa nada.
httptest.NewRequest + NewRecorder prueban rutas y handlers sin servidor (en Laravel, $this->post() y assertStatus()).
Para recordarlo: «Lee, Llama, Responde»
LLee r.FormValue("titulo")
LLlama c.cu.Crear.Ejecutar(...)
RResponde http.Redirect(w, r, "/tareas", 303)
Todo controlador hace solo esto: Lee la petición, Llama a un caso de uso y Responde. Si ves un if de negocio dentro, se ha colado el dominio en la web.