Patron Méthode modèle

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy. Leçon 78 sur 91.

Le patron de méthode modèle est un patron de conception comportemental qui définit la structure d’un algorithme dans une classe de base, permettant aux sous-classes de remplacer certaines étapes sans modifier la structure globale. La classe de base contrôle le flux de travail, tandis que les sous-classes personnalisent des éléments individuels.

Envisagez de créer différents types de documents.

Chaque document suit le même processus : créer l’en-tête, ajouter le contenu, créer le pied de page. Mais les détails de chaque étape varient selon le type de document. La méthode modèle définit cette séquence, tandis que les sous-classes en implémentent les détails.

<?php
abstract class DocumentGenerator {
    // La méthode template - définit la structure de l'algorithme
    public final function generate(): string {
        $output = $this->createHeader();
        $output .= $this->createContent();
        $output .= $this->createFooter();
        return $output;
    }
    
    // Étapes à implémenter par les sous-classes
    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();

Sortie :

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

Remarquez le mot-clé final sur la méthode modèle. Cela empêche les sous-classes de modifier la structure de l’algorithme. Ce modèle est idéal lorsque vous avez plusieurs classes qui suivent le même flux de travail, mais qui diffèrent dans leurs détails d’implémentation. Ajouter un nouveau type de document signifie créer une nouvelle sous-classe sans toucher au code existant.

Défi

Facile

Construisons un système de génération de rapports à l'aide du pattern Template Method. Différents types de rapports suivent la même structure : une section de titre, une section de données et une section de résumé, mais chaque type de rapport met en forme ces sections différemment. La méthode template définira ce flux de travail, tandis que les sous-classes personnaliseront chaque étape.

Vous organiserez votre code dans quatre fichiers :

ReportGenerator.php : créez une classe abstraite ReportGenerator qui définit la structure de l'algorithme de génération de rapports. Votre classe doit :
- Accepter un titre de rapport dans son constructeur (utilisez la promotion de constructeur)
- Posséder une méthode publique final generate(): string qui appelle trois étapes dans l'ordre : createTitle(), createBody() et createSummary(), en concaténant leurs résultats
- Déclarer trois méthodes protégées abstraites que les sous-classes doivent implémenter : createTitle(): string, createBody(): string et createSummary(): string
HtmlReport.php : incluez le fichier ReportGenerator et créez une classe HtmlReport qui en hérite. Ce rapport met en forme la sortie en HTML :
- createTitle() renvoie "<h1>[title]</h1>"
- createBody() renvoie "<p>Report data goes here</p>"
- createSummary() renvoie "<footer>End of report</footer>"
PlainTextReport.php : incluez le fichier ReportGenerator et créez une classe PlainTextReport qui en hérite. Ce rapport utilise une mise en forme textuelle simple :
- createTitle() renvoie "### [title] ###\n"
- createBody() renvoie "Report data goes here\n"
- createSummary() renvoie "--- End of report ---"
main.php : incluez les deux fichiers de rapports. Vous recevrez deux entrées : un type de rapport ("html" ou "text") et un titre de rapport.
En fonction du type de rapport, créez le générateur de rapports approprié avec le titre fourni. Appelez generate() et affichez le rapport complet.

Le pattern Template Method garantit que tous les rapports suivent la même structure en trois étapes, tout en permettant à chaque type de rapport de mettre en forme ses sections de manière unique. Le mot-clé final sur generate() empêche les sous-classes de modifier l'ordre de l'algorithme. Elles peuvent uniquement personnaliser les différentes étapes.

Essayez vous-même

<?php

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

// Lire l'entrée
$reportType = trim(fgets(STDIN));
$reportTitle = trim(fgets(STDIN));

// TODO: En fonction du type de rapport ("html" ou "text"),
// créer le générateur de rapport approprié avec le titre donné

// TODO: Appeler generate() et afficher le rapport complet

?>