Patron Fabrique

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

Le pattern Factory délègue la création d'objets à une méthode ou une classe distincte, vous permettant de créer des objets sans spécifier leur classe exacte. Ceci est différent du constructeur factory que vous avez appris précédemment - le pattern Factory est une approche de conception où la logique de création est centralisée et peut retourner différents types en fonction de l'entrée.

Considérez un scénario dans lequel vous devez créer différents types de notifications. Au lieu que le client décide quelle classe instancier, une fabrique gère cette décision :

abstract class Notification {
  void send(String message);
}

class EmailNotification implements Notification {
  @override
  void send(String message) => print('Email: $message');
}

class SMSNotification implements Notification {
  @override
  void send(String message) => print('SMS: $message');
}

class NotificationFactory {
  static Notification create(String type) {
    switch (type) {
      case 'email':
        return EmailNotification();
      case 'sms':
        return SMSNotification();
      default:
        return EmailNotification();
    }
  }
}

void main() {
  var notification = NotificationFactory.create('sms');
  notification.send('Hello!');  // SMS : Hello !
}

Le code client n'a pas besoin de connaître EmailNotification ou SMSNotification - il demande simplement à la fabrique une notification d'un certain type. Cela facilite l'ajout de nouveaux types de notification : vous modifiez uniquement la fabrique, et non chaque endroit qui crée des notifications.

Utilisez le pattern Factory lorsque la création d'objets implique une logique complexe, lorsque vous souhaitez masquer les classes d'implémentation aux clients, ou lorsque le type exact à créer dépend des conditions d'exécution.

Défi

Facile

Construisons un générateur de documents en utilisant le pattern Factory ! Vous allez créer un système qui produit différents types de documents (rapports, factures et lettres) via une usine centralisée, afin que le code client n'ait pas besoin de connaître les classes de documents spécifiques.

Vous organiserez votre code en deux fichiers :

document_factory.dart : Créez votre système de documents ici :
- Une classe abstraite Document avec une méthode generate(String content) qui retourne un String
- Trois classes concrètes qui implémentent Document :
  - Report - sa méthode generate retourne === REPORT ===\n[content]\n=============
  - Invoice - sa méthode generate retourne INVOICE\n--------\n[content]\nTotal Due
  - Letter - sa méthode generate retourne Dear Reader,\n[content]\nSincerely
- Une classe DocumentFactory avec une méthode statique create(String type) qui retourne le Document approprié en fonction de la chaîne de caractères type : "report", "invoice", ou "letter". Pour tout type inconnu, retournez un Letter par défaut
main.dart : Importez votre usine de documents et démontrez comment l'usine crée différents types de documents sans que le client ait besoin de connaître les classes concrètes :
- Utilisez l'usine pour créer un rapport et affichez le résultat de sa génération avec le contenu Sales increased by 25%
- Affichez une ligne vide
- Utilisez l'usine pour créer une facture et affichez le résultat de sa génération avec le contenu Widget x3 - $150
- Affichez une ligne vide
- Utilisez l'usine pour créer une lettre et affichez le résultat de sa génération avec le contenu Thank you for your order

Remarquez comment votre fichier principal interagit uniquement avec l'usine et le type abstrait Document - il ne crée jamais directement d'objets Report, Invoice, ou Letter !

Sortie attendue :

=== REPORT ===
Sales increased by 25%
=============

INVOICE
--------
Widget x3 - $150
Total Due

Dear Reader,
Thank you for your order
Sincerely

Aide-mémoire

Le pattern Factory (ou Fabrique) délègue la création d'objets à une méthode ou une classe distincte, vous permettant de créer des objets sans spécifier leur classe exacte. La logique de création est centralisée et peut retourner différents types en fonction des entrées.

Structure de base du pattern Factory :

abstract class Notification {
  void send(String message);
}

class EmailNotification implements Notification {
  @override
  void send(String message) => print('Email: $message');
}

class SMSNotification implements Notification {
  @override
  void send(String message) => print('SMS: $message');
}

class NotificationFactory {
  static Notification create(String type) {
    switch (type) {
      case 'email':
        return EmailNotification();
      case 'sms':
        return SMSNotification();
      default:
        return EmailNotification();
    }
  }
}

void main() {
  var notification = NotificationFactory.create('sms');
  notification.send('Hello!');  // SMS: Hello!
}

Le code client interagit uniquement avec la fabrique et le type abstrait, et non avec les classes d'implémentation concrètes. Cela facilite l'ajout de nouveaux types : il suffit de modifier la fabrique.

Utilisez le pattern Factory lorsque :

La création d'objets implique une logique complexe
Vous souhaitez masquer les classes d'implémentation aux clients
Le type exact à créer dépend de conditions au moment de l'exécution

Essayez vous-même

import 'document_factory.dart';

void main() {
  // TODO: Utiliser DocumentFactory.create() pour créer un rapport
  // Puis afficher le résultat de sa génération avec le contenu : "Sales increased by 25%"
  
  // TODO: Afficher une ligne vide
  
  // TODO: Utiliser DocumentFactory.create() pour créer une facture
  // Puis afficher le résultat de sa génération avec le contenu : "Widget x3 - \$150"
  
  // TODO: Afficher une ligne vide
  
  // TODO: Utiliser DocumentFactory.create() pour créer une lettre
  // Puis afficher le résultat de sa génération avec le contenu : "Thank you for your order"
}