Mis apuntes · Aprende Go desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

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 lectura 4 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.

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
}
Ruta en GoQué haceEn Laravel
GET /tareasPinta la lista y el formularioRoute::get('/tareas', [TareasController::class, 'index'])
POST /tareasCrea una tarea desde el formularioRoute::post('/tareas', ...)
POST /tareas/{id}/completarMarca una como hechaRoute::post('/tareas/{id}/completar', ...)
POST /tareas/{id}/borrarLa borraRoute::post('/tareas/{id}/borrar', ...)
GET /api/tareasLista en JSONRoute::get('/api/tareas', ...) en routes/api.php
GET /api/tareas/{id}Una en JSON, o 404Route::get('/api/tareas/{id}', ...)

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
<?php
declare(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;

final readonly class TareasController
{
    public function __construct(private CrearTareaHandler $crear) {}

    #[Route("/tareas", methods: ["POST"])]
    public function crear(Request $request): Response
    {
        $prioridad = Prioridad::tryFrom($request->request->getInt("prioridad"))
            ?? Prioridad::Media;
        try {
            ($this->crear)($request->request->getString("titulo"), $prioridad);
        } catch (TituloVacio | TituloLargo $e) {
            return new Response($e->getMessage(), 422);
        }
        // Post/Redirect/Get: F5 no vuelve a crear la tarea
        return new RedirectResponse("/tareas", 303);
    }
}
Gocontrolador.go
package web

type Controlador struct {
    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.

  1. Las cabeceras: w.Header().Set("Content-Type", "application/json").
  2. El código de estado: w.WriteHeader(http.StatusCreated). Si no lo llamas, el primer Write envía un 200.
  3. 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.
func estadoHTTP(err error) int {
    switch {
    case errors.Is(err, dominio.ErrTareaNoEncontrada):
        return http.StatusNotFound
    case errors.Is(err, dominio.ErrTituloVacio),
        errors.Is(err, dominio.ErrTituloLargo),
        errors.Is(err, dominio.ErrPrioridadInvalida),
        errors.Is(err, dominio.ErrEtiquetaInvalida):
        return http.StatusUnprocessableEntity
    case 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"
)

var ErrTareaNoEncontrada = errors.New("tarea no encontrada")

// Lo que devolvería CompletarTarea con un id que no existe.
func completar(id int) error {
    errRepo := fmt.Errorf("buscar tarea %d: %w", id, ErrTareaNoEncontrada)
    return fmt.Errorf("completar: %w", errRepo)
}

func conIgual(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
    }
}

func conErrorsIs(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
    }
}

func main() {
    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())
    }
}
ErrorCódigoPor qué
ErrTareaNoEncontrada404 Not FoundEl id no existe
ErrTituloVacio, ErrTituloLargo…422 Unprocessable EntityLa petición se entiende, pero los datos no valen
ErrYaCompletada409 ConflictChoca con el estado actual de la tarea
Cualquier otro500 Internal Server ErrorFallo 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:

$ cat internal/web/plantillas/lista.html
<h1>Mis tareas</h1>
{{with .Error}}<p class="error">{{.}}</p>{{end}}
<form method="post" action="/tareas">
    <input name="titulo" required maxlength="100">
    <button>Añadir</button>
</form>
<ul>
{{range .Tareas}}
    <li>
        {{if .Hecha}}[x]{{else}}[ ]{{end}} {{.Titulo}} ({{.Prioridad}})
        <form method="post" action="/tareas/{{.ID}}/completar"><button>Hecha</button></form>
    </li>
{{else}}
    <li>No hay tareas. ¡A descansar!</li>
{{end}}
</ul>
QuéGo (html/template)BladeTwig
Pintar escapado{{.Titulo}}{{ $tarea->titulo }}{{ tarea.titulo }}
Bucle{{range .Tareas}} … {{end}}@foreach ($tareas as $tarea){% for tarea in tareas %}
Bucle vacío{{range …}} … {{else}} … {{end}}@forelse … @empty{% for … %}{% else %}
Condición{{if .Hecha}} … {{else}} … {{end}}@if ($tarea->hecha){% if tarea.hecha %}
Si no está vacío{{with .Error}}{{.}}{{end}}@isset($error){% if error %}
Sin escapar (peligro)template.HTML(...) en Go{!! $html !!}{{ html|raw }}

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.

Gomain.go
package main

import (
    "html/template"
    "os"
)

type Tarea struct {
    ID     int
    Titulo string
    Hecha  bool
}

const plantilla = `<ul>
{{range .}}  <li>{{if .Hecha}}[x]{{else}}[ ]{{end}} {{.Titulo}} <a href="/tareas/{{.ID}}">ver</a></li>
{{else}}  <li>No hay tareas</li>
{{end}}</ul>
`

func main() {
    vista := template.Must(template.New("lista").Parse(plantilla))
    tareas := []Tarea{
        {ID: 1, Titulo: "Comprar pan", Hecha: true},
        {ID: 2, Titulo: "<script>alert('hola')</script>"},
    }
    // En PHP: echo view('lista', ['tareas' => $tareas]);
    vista.Execute(os.Stdout, tareas)
    vista.Execute(os.Stdout, []Tarea{})
}

¿Por qué? · En PHP no existe

¿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, siempre html/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 []string

func crear(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)
}

func main() {
    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:

Gomain.go
func nuevaApp(t *testing.T) http.Handler {
    t.Helper()
    ctrl, err := NuevoControlador(casosdeuso.Nuevos(repositorio.NuevoMemoria()))
    if err != nil {
        t.Fatal(err)
    }
    return ctrl.Rutas()
}

func TestApiVerNoEncontrada(t *testing.T) {
    rec := httptest.NewRecorder()
    nuevaApp(t).ServeHTTP(rec, httptest.NewRequest("GET", "/api/tareas/7", nil))
    if rec.Code != http.StatusNotFound {
        t.Errorf("GET /api/tareas/7 = %d; quería 404", rec.Code)
    }
}
$ 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:

  • Routing enhancements for Go 1.22: el artículo oficial sobre las rutas con método y {id}.
  • html/template: la documentación de las plantillas, con todos sus contextos de escape.
  • net/http/httptest: para probar handlers y servidores.
  • 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

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

Resumen

Lo que te llevas de esta lección

  1. mux.HandleFunc("POST /tareas/{id}/completar", c.completar) registra una ruta con método (en Laravel, Route::post()).
  2. 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()).
  3. Los errores del dominio se traducen a 404/422/409 con errors.Is en un solo sitio (en PHP, los catch del controlador).
  4. html/template escapa según el contexto (en PHP, Blade o Twig con {{ }}); text/template no escapa nada.
  5. 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.