Comprendre les modèles de conception d'usine et de méthode d'usine

Qu'est-ce qu'un cours Factory ? Une classe d'usine est une classe qui crée un ou plusieurs objets de classes différentes.

Le modèle Factory est sans doute le modèle de conception le plus utilisé en génie logiciel. Dans cet article, je fournirai une explication détaillée des modèles de conception Simple Factory et Factory Method à l'aide d'un exemple de problème simple.

Le modèle d’usine simple

Disons que nous devons créer un système qui prend en charge deux types d'animaux, par exemple Chien et Chat, chacune des classes d'animaux devrait avoir une méthode qui fait le type de son de l'animal. Désormais, un client aimera utiliser le système pour émettre des sons d'animaux en fonction des entrées de l'utilisateur. Une solution de base au problème ci-dessus peut s'écrire comme suit :

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("Bhow Bhow!")

class Cat(Animal):
    def make_sound(self):
        print("Meow Meow!")

Avec cette solution, notre client utilisera le système comme ceci

## client code
if __name__ == '__main__':
    animal_type = input("Which animal should make sound Dog or Cat?")
    if animal_type.lower() == 'dog':
        Dog().make_sound()
    elif animal_type.lower() == 'cat':
        Cat().make_sound()

Notre solution fonctionnera bien, mais Simple Factory Pattern dit que nous pouvons faire mieux. Pourquoi? Comme vous l'avez vu dans le code client ci-dessus, le client devra décider laquelle de nos classes d'animaux appeler à la fois. Imaginez que le système ait, disons, dix classes d'animaux différentes. Vous pouvez déjà voir à quel point il sera problématique pour notre client d'utiliser le système.

Donc, ici, le modèle Simple Factory dit simplement qu'au lieu de laisser le client décider quelle classe appeler, laissons le système décider pour le client.

Pour résoudre le problème en utilisant le modèle Simple Factory, il suffit de créer une classe d'usine avec une méthode qui prend en charge la création de l'objet animal.

...
...
class AnimalFactory:
    def make_sound(self, animal_type):
        return eval(animal_type.title())().make_sound()

Avec cette approche, le code client devient :

## client code
if __name__ == '__main__':
    animal_type = input("Which animal should make sound Dog or Cat?")
    AnimalFactory().make_sound(animal_type)

En résumé, le modèle Simple Factory consiste à créer une classe d'usine qui gère la création d'objets pour le compte d'un client.

Modèle de méthode d'usine

Pour en revenir à notre problème d'avoir un système qui ne prend en charge que deux types d'animaux (chien et chat), que se passera-t-il si cette limitation est supprimée et que notre système est prêt à prendre en charge n'importe quel type d'animal ? Bien entendu, notre système ne pouvait pas se permettre de fournir des implémentations pour des millions d’animaux. C’est là que le modèle de méthode Factory vient à la rescousse.

Dans le modèle Factory Method, nous définissons une classe ou une interface abstraite pour créer des objets, mais au lieu que l'usine soit responsable de la création de l'objet, la responsabilité est transférée à la sous-classe qui décide de la classe à instancier.

Composants clés du modèle de méthode Factory

1. Creator : Le Creator est une classe ou une interface abstraite. Il déclare la méthode Factory, qui est une méthode de création d'objets. Le Créateur fournit une interface pour créer des produits mais ne précise pas leurs classes concrètes.

2. Créateur concret : Les créateurs concrets sont les sous-classes du Créateur. Ils implémentent la méthode Factory, décidant quelle classe de produits concrète à instancier. Autrement dit, chaque Créateur de Béton est spécialisé dans la création d'un type de produit particulier.

3. Produit : Le produit est une autre classe ou interface abstraite. Il définit le type d'objets créés par la méthode Factory. Ces produits partagent une interface commune, mais leurs implémentations concrètes peuvent varier.

4. Produit en béton : Les produits en béton sont les sous-classes du produit. Ils fournissent les implémentations spécifiques des produits. Chaque produit en béton correspond à un type d'objet créé par la Méthode Factory.

Voici à quoi ressemblera notre code système en utilisant le modèle Factory Method :

Étape 1 : Définir le produit

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("Bhow Bhow!")

class Cat(Animal):
    def make_sound(self):
        print("Meow Meow!")

Étape 2 : Création de produits en béton

## client code
if __name__ == '__main__':
    animal_type = input("Which animal should make sound Dog or Cat?")
    if animal_type.lower() == 'dog':
        Dog().make_sound()
    elif animal_type.lower() == 'cat':
        Cat().make_sound()

Étape 3 : Définir le créateur

...
...
class AnimalFactory:
    def make_sound(self, animal_type):
        return eval(animal_type.title())().make_sound()

Étape 4 : Implémenter des créateurs concrets

## client code
if __name__ == '__main__':
    animal_type = input("Which animal should make sound Dog or Cat?")
    AnimalFactory().make_sound(animal_type)

Et le client peut utiliser la solution comme suit :

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

La solution Factory Method Pattern permet aux clients d'étendre le système et de fournir des implémentations d'animaux personnalisées si nécessaire.

Avantages du modèle de méthode d'usine

1. Découplage : il dissocie le code client des classes concrètes, réduisant ainsi les dépendances et améliorant la stabilité du code.

2. Flexibilité : Cela apporte beaucoup de flexibilité et rend le code générique, n'étant pas lié à une certaine classe pour l'instanciation. De cette façon, nous dépendons de l'interface (Product) et non de la classe ConcreteProduct.

3. Extensibilité : De nouvelles classes de produits peuvent être ajoutées sans modifier le code existant, favorisant un principe ouvert-fermé.

Conclusion

Le modèle de conception Factory Method offre un moyen systématique de créer des objets tout en gardant le code maintenable et adaptable. Il excelle dans les scénarios où les types d'objets varient ou évoluent.

Les frameworks, bibliothèques, systèmes de plug-ins et écosystèmes logiciels bénéficient de sa puissance. Cela permet aux systèmes de s'adapter à l'évolution des demandes.

Cependant, il doit être utilisé judicieusement, en tenant compte des besoins spécifiques de l'application et du principe de simplicité. Lorsqu'il est appliqué de manière appropriée, le modèle Factory Method peut contribuer de manière significative à la conception et à l'architecture globales d'un système logiciel.

Bon codage !!!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!