Modèle d'usine abstrait à Java

1. Vue d'ensemble

Dans cet article, nous aborderons le modèle de conception Abstract Factory.

Le livre Design Patterns: Elements of Reusable Object-Oriented Software déclare qu'une usine abstraite «fournit une interface pour créer des familles d'objets liés ou dépendants sans spécifier leurs classes concrètes». En d'autres termes, ce modèle nous permet de créer des objets qui suivent un modèle général.

Un exemple du modèle de conception Abstract Factory dans le JDK est la classe newInstance () de javax.xml.parsers.DocumentBuilderFactory .

2. Exemple de modèle de conception d'usine abstraite

Dans cet exemple, nous allons créer deux implémentations du modèle de conception de méthode d'usine: AnimalFactory et Color Factory.

Après cela, nous gérerons leur accès à l'aide d'une Abstract Factory AbstractFactory:

Tout d'abord, nous allons créer une famille de classe animale et nous l'utiliserons plus tard dans notre usine abstraite.

Voici l' interface Animal :

public interface Animal { String getAnimal(); String makeSound(); }

et une mise en œuvre concrète Canard :

public class Duck implements Animal { @Override public String getAnimal() { return "Duck"; } @Override public String makeSound() { return "Squeks"; } } 

De plus, nous pouvons créer des implémentations plus concrètes de l' interface Animal (comme Dog, Bear, etc.) exactement de cette manière.

La fabrique abstraite traite des familles d'objets dépendants. Dans cet esprit, nous allons introduire une autre famille Color comme interface avec quelques implémentations ( White, Brown,… ).

Nous allons ignorer le code réel pour le moment, mais il peut être trouvé ici.

Maintenant que nous avons plusieurs familles prêtes, nous pouvons créer une interface AbstractFactory pour elles:

public interface AbstractFactory { T create(String animalType) ; }

Ensuite, nous allons implémenter une AnimalFactory en utilisant le modèle de conception de la méthode Factory dont nous avons parlé dans la section précédente:

public class AnimalFactory implements AbstractFactory { @Override public Animal create(String animalType) { if ("Dog".equalsIgnoreCase(animalType)) { return new Dog(); } else if ("Duck".equalsIgnoreCase(animalType)) { return new Duck(); } return null; } } 

De même, nous pouvons implémenter une usine pour l' interface Color en utilisant le même modèle de conception.

Lorsque tout cela est défini, nous allons créer une classe FactoryProvider qui nous fournira une implémentation d' AnimalFactory ou ColorFactory en fonction de l'argument que nous fournissons à la méthode getFactory () :

public class FactoryProvider { public static AbstractFactory getFactory(String choice){ if("Animal".equalsIgnoreCase(choice)){ return new AnimalFactory(); } else if("Color".equalsIgnoreCase(choice)){ return new ColorFactory(); } return null; } }

3. Quand utiliser le modèle de fabrique abstraite:

  • Le client est indépendant de la façon dont nous créons et composons les objets dans le système
  • Le système se compose de plusieurs familles d'objets, et ces familles sont conçues pour être utilisées ensemble
  • Nous avons besoin d'une valeur d'exécution pour construire une dépendance particulière

Bien que le modèle soit excellent lors de la création d'objets prédéfinis, l'ajout de nouveaux peut être difficile . Pour prendre en charge le nouveau type d'objets, il faudra changer la classe AbstractFactory et toutes ses sous-classes.

4. Résumé

Dans cet article, nous avons découvert le modèle de conception Abstract Factory.

Enfin, comme toujours, l'implémentation de ces exemples peut être trouvée sur GitHub.