Modello Template Method

Fa parte della sezione Programmazione orientata agli oggetti del percorso PHP di Coddy. Lezione 78 di 91.

Il Template Method Pattern è un pattern di progettazione comportamentale che definisce lo scheletro di un algoritmo in una classe base, consentendo alle sottoclassi di ridefinire passaggi specifici senza modificare la struttura complessiva. La classe base controlla il flusso di lavoro, mentre le sottoclassi personalizzano i singoli elementi.

Considera la creazione di diversi tipi di documenti.

Ogni documento segue lo stesso processo: creare l'intestazione, aggiungere il contenuto, creare il piè di pagina. Ma i dettagli di ogni passaggio variano in base al tipo di documento. Il metodo template definisce questa sequenza, mentre le sottoclassi ne implementano i dettagli.

<?php
abstract class DocumentGenerator {
    // El método plantilla - define la estructura del algoritmo
    public final function generate(): string {
        $output = $this->createHeader();
        $output .= $this->createContent();
        $output .= $this->createFooter();
        return $output;
    }
    
    // Pasos que deben implementar las subclases
    abstract protected function createHeader(): string;
    abstract protected function createContent(): string;
    abstract protected function createFooter(): string;
}

class HtmlDocument extends DocumentGenerator {
    protected function createHeader(): string {
        return "<html><head></head><body>";
    }
    
    protected function createContent(): string {
        return "<p>Hello World</p>";
    }
    
    protected function createFooter(): string {
        return "</body></html>";
    }
}

class TextDocument extends DocumentGenerator {
    protected function createHeader(): string {
        return "=== DOCUMENT ===\n";
    }
    
    protected function createContent(): string {
        return "Hello World\n";
    }
    
    protected function createFooter(): string {
        return "=== END ===";
    }
}

$html = new HtmlDocument();
echo $html->generate() . "\n";

$text = new TextDocument();
echo $text->generate();

Risultato:

<html><head></head><body><p>Hello World</p></body></html>
=== DOCUMENT ===
Hello World
=== END ===

Nota la parola chiave final sul metodo modello. Questo impedisce alle sottoclassi di modificare la struttura dell'algoritmo. Il pattern è ideale quando hai più classi che seguono lo stesso flusso di lavoro ma differiscono nei dettagli di implementazione. Aggiungere un nuovo tipo di documento significa creare una nuova sottoclasse senza modificare il codice esistente.

Sfida

Facile

Costruiamo un sistema di generazione di report usando il pattern Template Method. Diversi tipi di report seguono la stessa struttura: una sezione per il titolo, una per i dati e una per il riepilogo, ma ciascun tipo di report formatta queste sezioni in modo diverso. Il metodo template definirà questo flusso di lavoro, mentre le sottoclassi personalizzeranno ogni passaggio.

Organizzerai il codice in quattro file:

ReportGenerator.php: crea una classe astratta ReportGenerator che definisce lo scheletro dell’algoritmo di generazione dei report. La tua classe deve:
- Accettare un titolo del report nel costruttore (usa la promozione del costruttore)
- Avere un metodo pubblico final generate(): string che richiama tre passaggi in ordine: createTitle(), createBody() e createSummary(), concatenandone i risultati
- Dichiarare tre metodi astratti protetti che le sottoclassi devono implementare: createTitle(): string, createBody(): string e createSummary(): string
HtmlReport.php: includi il file ReportGenerator e crea una classe HtmlReport che lo estende. Questo report formatta l’output come HTML:
- createTitle() restituisce "<h1>[title]</h1>"
- createBody() restituisce "<p>Report data goes here</p>"
- createSummary() restituisce "<footer>End of report</footer>"
PlainTextReport.php: includi il file ReportGenerator e crea una classe PlainTextReport che lo estende. Questo report usa una formattazione testuale semplice:
- createTitle() restituisce "### [title] ###\n"
- createBody() restituisce "Report data goes here\n"
- createSummary() restituisce "--- End of report ---"
main.php: includi entrambi i file dei report. Riceverai due input: un tipo di report ("html" o "text") e un titolo del report.
In base al tipo di report, crea il generatore di report appropriato con il titolo fornito. Chiama generate() e stampa il report completo.

Il pattern Template Method garantisce che tutti i report seguano la stessa struttura in tre passaggi, consentendo al contempo a ciascun tipo di report di formattare le proprie sezioni in modo diverso. La parola chiave final su generate() impedisce alle sottoclassi di modificare la sequenza dell’algoritmo. Possono personalizzare solo i singoli passaggi.

Provalo tu

<?php

require_once 'HtmlReport.php';
require_once 'PlainTextReport.php';

// Leggi l'input
$reportType = trim(fgets(STDIN));
$reportTitle = trim(fgets(STDIN));

// TODO: In base al tipo di report ("html" o "text"),
// crea il generatore di report appropriato con il titolo fornito

// TODO: Chiama generate() e stampa il report completo

?>