TOC

Modèle de fabrique abstraite en Java

Modèle d'usine abstrait en Java

1. Vue d'ensemble

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

Le livreDesign Patterns: Elements of Reusable Object-Oriented Software déclare qu'une fabrique abstraite“provides an interface for creating families of related or dependent objects without specifying their concrete classes”.  En d'autres termes, ce modèle nous permet de créer des objets qui suivent un modèle général.

Un exemple de modèle de conception Abstract Factory dans le JDK est lenewInstance() de la classejavax.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 etColorFactory.

Après cela, nous gérerons leur accès à l'aide d'une usine abstraiteAbstractFactory:

image

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

Voici l’interface deAnimal: 

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

et une implémentation concrèteDuck: 

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'interfaceAnimal (commeDog, Bear, etc.) exactement de cette manière.

L'abstrait Factory traite des familles d'objets dépendants. Dans cet esprit, nous allons introduire une autre familleColor comme interface avec quelques implémentations (White, Brown,…).

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

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

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

Ensuite, nous allons implémenter unAnimalFactory en utilisant le modèle de conception de la méthode d'usine 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 fabrique pour l'interfaceColor en utilisant le même modèle de conception.

Lorsque tout cela est défini, nous allons créer une classeFactoryProvider qui nous fournira une implémentation deAnimalFactory ouColorFactory selon l'argument que nous fournissons auxgetFactory() méthode: 

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 un motif d'usine abstraite:

  • Le client est indépendant de la manière dont nous créons et composons les objets dans le système.

  • Le système se compose de plusieurs familles d’objets, conçus pour être utilisés ensemble.

  • Nous avons besoin d'une valeur d'exécution pour construire une dépendance particulière

While the pattern is great when creating predefined objects, adding the new ones might be challenging. Pour prendre en charge le nouveau type d'objets, il faudra changer la classeAbstractFactory et toutes ses sous-classes.

4. Sommaire

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éeover on GitHub.

Related