Patrón Template Method explicado con ejemplos

Intención y el problema que resuelve

Intención: definir el esqueleto de un algoritmo en una operación, delegando algunos pasos a las subclases. Template Method permite que las subclases redefinan ciertos pasos de un algoritmo sin cambiar su estructura. Es uno de los patrones de comportamiento del libro de la Banda de los Cuatro (Gang of Four, GoF).

Imagina una herramienta de informes que exporta datos como CSV y como JSON. Ambos exportadores hacen lo mismo en el mismo orden: cargar las filas, comprobar que hay alguna, darles formato y añadir un pie con el número de filas. Solo difiere el formato. Si cada exportador se escribe por separado, los pasos compartidos se copian, y una corrección en uno (por ejemplo, un mejor manejo de un resultado vacío) se olvida fácilmente en el otro.

Con Template Method, una clase base Exporter contiene el método export con la secuencia fija de pasos. Los pasos que varían son métodos abstractos. CsvExporter y JsonExporter implementan solo esos.

Estructura y participantes

Este diseño invierte el control: la clase base llama a los métodos de la subclase, y no al revés. A veces se llama el principio de Hollywood: "no nos llames, nosotros te llamaremos".

Implementación en TypeScript

export es el método plantilla. format es una operación primitiva que las subclases deben implementar, y header es un hook con un valor por defecto vacío.

type Row = { name: string; score: number };

abstract class Exporter {
  // The template method: fixed order of steps
  export(rows: Row[]): string {
    if (rows.length === 0) return "no data";
    const lines = [this.header(), this.format(rows), "rows: " + rows.length];
    return lines.filter((line) => line !== "").join("\n");
  }

  protected abstract format(rows: Row[]): string; // required step
  protected header(): string { return ""; }       // hook: optional step
}

class CsvExporter extends Exporter {
  protected header() { return "name,score"; }
  protected format(rows: Row[]) {
    return rows.map((r) => r.name + "," + r.score).join("\n");
  }
}

class JsonExporter extends Exporter {
  protected format(rows: Row[]) {
    return JSON.stringify(rows);
  }
}

const rows = [{ name: "Ana", score: 9 }, { name: "Ben", score: 7 }];
console.log(new CsvExporter().export(rows));
// name,score
// Ana,9
// Ben,7
// rows: 2
console.log(new JsonExporter().export(rows));
// [{"name":"Ana","score":9},{"name":"Ben","score":7}]
// rows: 2
console.log(new JsonExporter().export([])); // no data

La comprobación de datos vacíos y el pie viven en un solo lugar. Un nuevo exportador XML implementaría format y obtendría el resto gratis.

La misma idea con composición

La herencia no es la única vía. Puedes pasar los pasos variables como funciones, lo que convierte el patrón en un pariente cercano de Strategy y evita las jerarquías de clases:

type Row = { name: string; score: number };
type Steps = { format: (rows: Row[]) => string; header?: () => string };

function exportRows(rows: Row[], steps: Steps): string {
  if (rows.length === 0) return "no data";
  const lines = [steps.header?.() ?? "", steps.format(rows), "rows: " + rows.length];
  return lines.filter((line) => line !== "").join("\n");
}

console.log(exportRows([{ name: "Ana", score: 9 }], { format: (r) => r[0].name }));
// Ana
// rows: 1

Prefiere esta forma cuando los pasos son pequeños y no necesitas estado compartido en una clase base, o cuando un exportador debe combinar pasos de varias fuentes.

Cuándo usarlo y cuándo no

• Úsalo cuando varias clases ejecutan el mismo algoritmo y solo difieren unos pocos pasos, y quieres eliminar las partes duplicadas.
• Úsalo en frameworks que deben controlar el orden de las operaciones mientras permiten a los usuarios personalizar pasos, como la preparación y la limpieza en las pruebas.
• Usa hooks para ofrecer puntos de extensión opcionales sin obligar a cada subclase a implementarlos.
• No lo uses cuando las variaciones son grandes o deben cambiar en tiempo de ejecución. Strategy, con composición, es más flexible.
• Evita las jerarquías profundas de métodos plantilla. Cuando las subclases sobrescriben pasos de subclases de subclases, el flujo se vuelve difícil de seguir.

Usos en el mundo real

• AbstractList de Java: implementas get(int) y size(), y la clase base ofrece la iteración, indexOf, contains y otros métodos construidos sobre ellos.
• InputStream de Java: las subclases implementan read() de un solo byte, y la clase base implementa read(byte[], int, int) llamándolo (las subclases pueden sobrescribirlo para ganar velocidad).
• Frameworks de pruebas: JUnit, unittest de Python y otros llaman a setUp, al método de prueba y a tearDown en un orden fijo, y tú sobrescribes los pasos que necesitas.
• Los frameworks de interfaz con métodos de ciclo de vida, como componentDidMount en los componentes de clase de React, llaman a tus métodos en puntos fijos de su propio algoritmo.

Patrones relacionados