Patron Fabrique

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy — leçon 72 sur 91.

Le patron Fabrique (Factory Pattern) est un patron de conception de création qui délègue la création d'objets à une classe ou une méthode distincte. Au lieu d'utiliser new directement dans tout votre code, vous demandez à une fabrique de créer des objets pour vous.

Ce patron est particulièrement utile lorsque vous avez plusieurs classes liées qui partagent une interface commune, et que vous souhaitez décider laquelle instancier en fonction d'une certaine condition. Considérez un système de notification capable d'envoyer des messages via différents canaux :

<?php
interface Notification {
    public function send(string $message): string;
}

class EmailNotification implements Notification {
    public function send(string $message): string {
        return "Email: $message";
    }
}

class SmsNotification implements Notification {
    public function send(string $message): string {
        return "SMS: $message";
    }
}

Sans une fabrique, vous éparpilleriez des instructions if et des appels new partout. La fabrique centralise cette logique :

<?php
class NotificationFactory {
    public static function create(string $type): Notification {
        return match($type) {
            'email' => new EmailNotification(),
            'sms' => new SmsNotification(),
            default => throw new InvalidArgumentException("Unknown type: $type")
        };
    }
}

$notification = NotificationFactory::create('email');
echo $notification->send('Hello!');

Sortie :

Email: Hello!

L'avantage principal est que votre code dépend de l'interface Notification, et non de classes concrètes. Si vous ajoutez plus tard une classe PushNotification, vous n'avez qu'à mettre à jour la fabrique. Tout le code utilisant la fabrique accède automatiquement au nouveau type sans modification.

Défi

Facile

Construisons un système de générateur de documents en utilisant le Factory Pattern. Différents types de documents (PDF, HTML, Plain Text) partagent une interface commune mais produisent des sorties différentes — un scénario parfait pour centraliser la création d'objets dans une fabrique.

Vous organiserez votre code sur quatre fichiers :

Document.php — Créez une interface Document qui définit le contrat que tous les types de documents doivent suivre. Elle doit avoir une seule méthode render(string $content): string qui prend le contenu et retourne la sortie du document formaté.
Documents.php — Incluez l'interface Document et créez trois classes qui l'implémentent :
- PdfDocument — Sa méthode render() retourne "PDF: $content"
- HtmlDocument — Sa méthode render() retourne "<html>$content</html>"
- TextDocument — Sa méthode render() retourne "TXT: $content"
DocumentFactory.php — Incluez le fichier Documents et créez une classe DocumentFactory avec une méthode statique create(string $type): Document. Cette méthode doit utiliser match pour retourner l'objet document approprié en fonction du type :
- "pdf" retourne un nouveau PdfDocument
- "html" retourne un nouveau HtmlDocument
- "text" retourne un nouveau TextDocument
- Tout autre type doit lever une InvalidArgumentException avec le message "Unknown document type: $type"
main.php — Incluez le fichier DocumentFactory. Vous recevrez deux entrées : un type de document et le contenu à rendre.
Utilisez la fabrique pour créer le type de document approprié, puis appelez sa méthode render() avec le contenu et affichez le résultat.

Sur une nouvelle ligne, affichez "Factory benefit: Adding new types only requires updating the factory" pour souligner pourquoi ce patron est précieux.

Le Factory Pattern maintient la flexibilité de votre code — lorsque vous devrez ajouter un MarkdownDocument plus tard, vous n'aurez qu'à mettre à jour la fabrique tandis que tout le code existant continuera de fonctionner sans changement.

Aide-mémoire

Le Factory Pattern (ou patron de méthode de fabrique) délègue la création d'objets à une classe ou une méthode distincte au lieu d'utiliser new directement dans tout votre code.

Ce patron est utile lorsque vous avez plusieurs classes liées partageant une interface commune, et que vous devez décider laquelle instancier en fonction d'une condition.

Exemple avec un système de notification :

<?php
interface Notification {
    public function send(string $message): string;
}

class EmailNotification implements Notification {
    public function send(string $message): string {
        return "Email: $message";
    }
}

class SmsNotification implements Notification {
    public function send(string $message): string {
        return "SMS: $message";
    }
}

La fabrique centralise la logique de création d'objets :

<?php
class NotificationFactory {
    public static function create(string $type): Notification {
        return match($type) {
            'email' => new EmailNotification(),
            'sms' => new SmsNotification(),
            default => throw new InvalidArgumentException("Unknown type: $type")
        };
    }
}

$notification = NotificationFactory::create('email');
echo $notification->send('Hello!'); // Output: Email: Hello!

Avantages clés :

Le code dépend de l'interface, pas des classes concrètes
L'ajout de nouveaux types nécessite uniquement la mise à jour de la fabrique
Le code existant accède automatiquement aux nouveaux types sans modification

Essayez vous-même

<?php
require_once 'DocumentFactory.php';

// Lire l'entrée
$type = trim(fgets(STDIN));
$content = trim(fgets(STDIN));

// TODO: Utiliser DocumentFactory pour créer le type de document approprié
// TODO: Appeler la méthode render() avec le contenu et afficher le résultat
// TODO: Sur une nouvelle ligne, afficher "Factory benefit: Adding new types only requires updating the factory"

?>