🍳 El Patrón Template Method: La Receta Maestra

El Patrón Template Method te monta el esqueleto de un algoritmo. Mantiene el proceso principal fijo, pero permite que las clases hijas personalicen ciertos pasos a su manera.

El problema que resuelve es este: ¿Cómo evitas duplicar código cuando tienes dos procesos que son casi idénticos menos un par de pasos intermedios?

La respuesta es crear una clase base con un método “plantilla” que llama a otros métodos (algunos ya implementados, otros abstractos). Las subclases solo tienen que implementar esos huecos.

En la imagen podemos ver que, tanto un gato doméstico como uno callejero, seguirán la misma rutina: despertarse, dormir, comer, lavarse y cazar. Pero la implementación cambia. Mientras el gato doméstico caza un ratón de juguete, el callejero caza una rata real. La acción es la misma en la rutina de ambos gatos, pero con distinta implementación.

---

☕ 1. Café vs Té

Imagina preparar una bebida caliente (El Algoritmo):

1. Hervir agua (igual para todos).
2. Preparar ingrediente (Café: filtrar. Té: infusionar).
3. Servir en taza (igual para todos).
4. Añadir condimentos (Café: azúcar/leche. Té: limón).

La estructura es la misma, pero los pasos 2 y 4 cambian. En vez de duplicar todo el proceso para café y para té, creas una “receta genérica” con huecos que cada bebida rellena a su manera.

Así es el Template Method. El padre define el orden y los pasos comunes, los hijos rellenan los huecos específicos.

---

🛠️ 2. Los roles del patrón

El Template Method es final. Las subclases no pueden cambiar el orden ni la estructura del algoritmo. Solo pueden rellenar los huecos. Esto se llama el Principio de Hollywood: “No nos llames, nosotros te llamaremos”. La clase base llama a los métodos de la subclase, no al revés.

---

🧑‍💻 3. Ejemplo práctico en PHP: Bebidas calientes

Vamos a implementar la receta de café y té, incluyendo un hook para que algunas bebidas puedan añadir un paso extra opcional.

<?php

// 1. Clase Abstracta con el Template Method
abstract class BebidaCaliente
{
    // El Template Method es FINAL: nadie puede cambiar el orden
    final public function prepararReceta(): void
    {
        $this->hervirAgua();
        $this->prepararIngrediente();
        $this->servirEnTaza();
        $this->anadirCondimentos();

        // Hook: paso opcional que las subclases pueden sobreescribir
        if ($this->clienteQuiereExtras()) {
            $this->anadirExtras();
        }

        echo "   ✅ ¡Bebida lista!\n";
    }

    // Métodos concretos (pasos comunes, no se sobreescriben)
    protected function hervirAgua(): void
    {
        echo "   💧 Herviendo agua...\n";
    }

    protected function servirEnTaza(): void
    {
        echo "   ☕ Sirviendo en la taza...\n";
    }

    // Métodos abstractos (huecos obligatorios)
    abstract protected function prepararIngrediente(): void;
    abstract protected function anadirCondimentos(): void;

    // Hook: implementación vacía por defecto
    protected function clienteQuiereExtras(): bool
    {
        return false; // Por defecto no se añaden extras
    }

    protected function anadirExtras(): void
    {
        // Vacío por defecto. Las subclases pueden sobreescribir
    }
}

// 2. Clases Concretas
class Cafe extends BebidaCaliente
{
    protected function prepararIngrediente(): void
    {
        echo "   🌑 Filtrando el café...\n";
    }

    protected function anadirCondimentos(): void
    {
        echo "   🍬 Añadiendo azúcar y leche...\n";
    }

    // El café sobreescribe el hook
    protected function clienteQuiereExtras(): bool
    {
        return true;
    }

    protected function anadirExtras(): void
    {
        echo "   🍫 Espolvoreando cacao por encima.\n";
    }
}

class Te extends BebidaCaliente
{
    protected function prepararIngrediente(): void
    {
        echo "   🌿 Infusionando el té...\n";
    }

    protected function anadirCondimentos(): void
    {
        echo "   🍋 Añadiendo limón...\n";
    }

    // El té NO sobreescribe el hook → no se añaden extras
}

// 3. Uso
echo "--- Preparando un Café ---\n";
$cafe = new Cafe();
$cafe->prepararReceta();

echo "\n--- Preparando un Té ---\n";
$te = new Te();
$te->prepararReceta();

// Salida:
// --- Preparando un Café ---
//    💧 Herviendo agua...
//    🌑 Filtrando el café...
//    ☕ Sirviendo en la taza...
//    🍬 Añadiendo azúcar y leche...
//    🍫 Espolvoreando cacao por encima.
//    ✅ ¡Bebida lista!
//
// --- Preparando un Té ---
//    💧 Herviendo agua...
//    🌿 Infusionando el té...
//    ☕ Sirviendo en la taza...
//    🍋 Añadiendo limón...
//    ✅ ¡Bebida lista!

Fíjate en los tres tipos de métodos:

• Concretos (hervirAgua(), servirEnTaza()): Comunes a todas las subclases. No se sobrescriben.
• Abstractos (prepararIngrediente(), anadirCondimentos()): Obligatorios. Cada subclase tiene que implementarlos.
• Hooks (clienteQuiereExtras(), anadirExtras()): Opcionales. Tienen implementación por defecto (vacía o con comportamiento base). Las subclases sobrescriben solo si quieren.

Los hooks son la diferencia entre un Template Method rígido y uno flexible. Sin hooks, todas las subclases siguen exactamente los mismos pasos. Con hooks, tienes puntos de extensión opcionales.

---

🧑‍💻 4. Ejemplo avanzado: Framework de tests

Vamos a ver un caso más real: un mini framework de testing donde cada test sigue la misma estructura (setup → execute → assert → teardown) pero los detalles cambian.

<?php

abstract class TestCase
{
    private string $nombre;
    private bool $paso = false;

    public function __construct(string $nombre)
    {
        $this->nombre = $nombre;
    }

    // Template Method: el flujo de un test
    final public function ejecutar(): void
    {
        echo "🧪 Test: {$this->nombre}\n";

        try {
            $this->setUp();
            $this->execute();
            $this->assert();
            $this->paso = true;
            echo "   ✅ PASS\n";
        } catch (\Exception $e) {
            echo "   ❌ FAIL: {$e->getMessage()}\n";
        } finally {
            $this->tearDown();
            echo "   🧹 Limpieza completada.\n";
        }
    }

    public function hasPasado(): bool
    {
        return $this->paso;
    }

    // Métodos abstractos: cada test los implementa
    abstract protected function execute(): void;
    abstract protected function assert(): void;

    // Hooks con implementación por defecto
    protected function setUp(): void
    {
        // Por defecto no hace nada. Sobreescribe si necesitas preparación
    }

    protected function tearDown(): void
    {
        // Por defecto no hace nada. Sobreescribe si necesitas limpieza
    }
}

// Test concreto: verificar conexión a BD
class TestConexionBD extends TestCase
{
    private ?\PDO $conexion = null;

    protected function setUp(): void
    {
        echo "   📋 setUp: Preparando conexión de test...\n";
        // Simula crear conexión
        $this->conexion = new \stdClass(); // Simulado
    }

    protected function execute(): void
    {
        echo "   🔄 Ejecutando query de prueba...\n";
        // Simula ejecutar una consulta
    }

    protected function assert(): void
    {
        if ($this->conexion === null) {
            throw new \Exception("La conexión no se estableció");
        }
        echo "   🔍 Verificando que la conexión existe...\n";
    }

    protected function tearDown(): void
    {
        echo "   🗑️ tearDown: Cerrando conexión de test...\n";
        $this->conexion = null;
    }
}

// Test concreto: verificar cálculo
class TestCalculadora extends TestCase
{
    private float $resultado = 0;

    // No necesita setUp ni tearDown → usa los hooks por defecto (vacíos)

    protected function execute(): void
    {
        echo "   🔄 Calculando 2 + 2...\n";
        $this->resultado = 2 + 2;
    }

    protected function assert(): void
    {
        if ($this->resultado !== 4.0) {
            throw new \Exception("Se esperaba 4, se obtuvo {$this->resultado}");
        }
        echo "   🔍 Verificando que 2+2 = 4...\n";
    }
}

// Uso
$tests = [
    new TestConexionBD('Conexión a base de datos'),
    new TestCalculadora('Suma básica'),
];

foreach ($tests as $test) {
    $test->ejecutar();
    echo "\n";
}

// Salida:
// 🧪 Test: Conexión a base de datos
//    📋 setUp: Preparando conexión de test...
//    🔄 Ejecutando query de prueba...
//    🔍 Verificando que la conexión existe...
//    ✅ PASS
//    🗑️ tearDown: Cerrando conexión de test...
//    🧹 Limpieza completada.
//
// 🧪 Test: Suma básica
//    🔄 Calculando 2 + 2...
//    🔍 Verificando que 2+2 = 4...
//    ✅ PASS
//    🧹 Limpieza completada.

Esto es exactamente cómo funcionan PHPUnit, JUnit y prácticamente todos los frameworks de testing: setUp() → test() → tearDown(). El framework (clase base) controla el flujo, tú (subclase) solo rellenas los pasos. Template Method literal bro.

Fíjate en que TestCalculadora no sobreescribe setUp() ni tearDown() porque no los necesita. Eso son hooks funcionando: opcionales, con valor por defecto.

---

🌍 5. Casos de uso en el mundo real

---

🔄 6. Comparativa con otros patrones

La confusión más frecuente: Template Method vs Strategy. Ambos manejan variaciones de algoritmos, pero de forma opuesta:

• Template Method: usa herencia. La clase base define el esqueleto y las subclases rellenan los pasos variables. El algoritmo está parcialmente fijo.
• Strategy: usa composición. El contexto delega el algoritmo completo a un objeto externo. El algoritmo es totalmente intercambiable.

Dicho en cristiano: si quieres variar algunos pasos de un proceso fijo, Template Method. Si quieres intercambiar todo el algoritmo, Strategy.

---

⚖️ 7. Relación con SOLID

---

✅ 8. Ventajas y desventajas

---

⚠️ 9. Errores comunes

1. No declarar el Template Method como final

Si el método plantilla no es final, una subclase puede sobrescribirlo y romper todo el algoritmo:

// ❌ MAL: sin final, la subclase puede cambiar el flujo
abstract class BebidaCaliente
{
    public function prepararReceta(): void // Sin final 💀
    {
        $this->hervirAgua();
        $this->prepararIngrediente();
        $this->servirEnTaza();
    }
}

class CafeRebelde extends BebidaCaliente
{
    // Sobreescribe el template y cambia el orden
    public function prepararReceta(): void
    {
        $this->anadirCondimentos(); // ¡Primero los condimentos! 💀
        $this->servirEnTaza();
        // Ni hierve agua ni prepara ingrediente
    }
}

// ✅ BIEN: con final, nadie puede tocar el flujo
abstract class BebidaCaliente
{
    final public function prepararReceta(): void
    {
        $this->hervirAgua();
        $this->prepararIngrediente();
        $this->servirEnTaza();
    }
}

2. Demasiados métodos abstractos

Si tu clase base tiene 10 métodos abstractos, cada subclase tiene que implementar los 10. Eso es un horror de mantenimiento:

// ❌ MAL: 8 métodos abstractos
abstract class ExportadorDatos
{
    abstract protected function abrirArchivo(): void;
    abstract protected function escribirCabecera(): void;
    abstract protected function formatearFila(array $fila): string;
    abstract protected function escribirFila(string $fila): void;
    abstract protected function escribirPie(): void;
    abstract protected function cerrarArchivo(): void;
    abstract protected function validarDatos(): void;
    abstract protected function notificarCompletado(): void;
    // Cada subclase tiene que implementar 8 métodos... overkill
}

// ✅ BIEN: pocos abstractos, el resto hooks con valor por defecto
abstract class ExportadorDatos
{
    // Solo 2 abstractos (los que realmente cambian)
    abstract protected function formatearFila(array $fila): string;
    abstract protected function getExtension(): string;

    // Hooks con implementación por defecto
    protected function escribirCabecera(): void { /* vacío */ }
    protected function escribirPie(): void { /* vacío */ }

    // Métodos concretos (comunes)
    protected function abrirArchivo(): void { /* lógica común */ }
    protected function cerrarArchivo(): void { /* lógica común */ }
}

Si una subclase tiene que implementar un método pero el 80% de las veces no hace nada, debería ser un hook, no un método abstracto.

3. Lógica en la subclase que debería estar en la base

Si te encuentras duplicando código en todas las subclases, probablemente debería subir a la clase base:

// ❌ MAL: todas las subclases repiten lo mismo
class ExportadorCSV extends ExportadorDatos
{
    protected function exportar(): void
    {
        echo "Validando datos...\n"; // Duplicado en todas
        echo "Abriendo archivo...\n"; // Duplicado en todas
        // ... lógica específica de CSV
    }
}

class ExportadorPDF extends ExportadorDatos
{
    protected function exportar(): void
    {
        echo "Validando datos...\n"; // Lo mismo 💀
        echo "Abriendo archivo...\n"; // Lo mismo 💀
        // ... lógica específica de PDF
    }
}

// ✅ BIEN: lo común sube a la base
abstract class ExportadorDatos
{
    final public function exportar(): void
    {
        echo "Validando datos...\n";     // Una sola vez
        echo "Abriendo archivo...\n";     // Una sola vez
        $this->escribirContenido();       // Abstracto: cada uno a su manera
        echo "Archivo cerrado.\n";
    }

    abstract protected function escribirContenido(): void;
}

4. Usar Template Method cuando necesitas composición

Si cada variante necesita combinar comportamientos de forma flexible, la herencia se queda corta. Ahí es mejor Strategy:

// ❌ MAL: Template Method para algo que necesita composición
class PedidoConPayPalYEnvioExpress extends ProcesadorPedido { ... }
class PedidoConBizumYEnvioEstandar extends ProcesadorPedido { ... }
class PedidoConTarjetaYRecogidaTienda extends ProcesadorPedido { ... }
// Explosión de subclases: N pagos × M envíos = N*M clases 💀

// ✅ BIEN: usa Strategy (composición) para combinar
class ProcesadorPedido
{
    public function __construct(
        private EstrategiaPago $pago,
        private EstrategiaEnvio $envio,
    ) {}

    public function procesar(): void
    {
        $this->pago->pagar(...);
        $this->envio->enviar(...);
    }
}

---

🤔 10. ¿Cuándo usarlo y cuándo no?

Si te encuentras copiando y pegando un proceso que tiene 5 pasos donde 3 son iguales y 2 cambian, es Template Method pidiéndote que lo uses.

---

💡 11. Conclusión

El Patrón Template Method es la base de la herencia bien hecha. En vez de que las subclases decidan todo, la clase base define el esqueleto y las subclases solo rellenan los huecos. Es el Principio de Hollywood en acción: “No me llames, yo te llamo”.

Lo ves por todas partes: cada setUp() → test() → tearDown() en PHPUnit es Template Method. Cada ciclo de vida en Android o React es Template Method. Cada vez que un framework te pide que “sobreescribas este método”, alguien usó Template Method.

Su fuerza está en la reutilización y el control: código común en un solo sitio, flujo garantizado con final, y hooks para extensión opcional. Eso sí, cuidado con la herencia. Si necesitas combinar comportamientos de forma flexible (pago + envío + descuento), la composición (Strategy) es mejor opción.

EA, ¡saluditos y nos vemos en los bares! 🍻