Apprenez le modèle de conception "Méthode d'usine" en Python

En tant que matériel d'apprentissage des modèles de conception du GoF, le livre «Introduction aux modèles de conception appris dans le langage Java augmenté et révisé» semble être utile. Cependant, comme les exemples repris sont basés sur JAVA, j'ai essayé la même pratique avec Python pour approfondir ma compréhension.

■ Méthode d'usine

Le modèle de méthode d'usine est l'un des modèles de conception définis par GoF (Gang of Four). Le modèle de méthode d'usine vise à expulser la création d'objet spécifique à l'application vers des sous-classes et à augmenter la réutilisabilité des classes en remplaçant les constructeurs d'autres classes par leurs propres méthodes qui peuvent être remplacées par des sous-classes. Aussi connu sous le nom de modèle Virtual Constructor. UML class diagram (Ce qui précède est cité sur Wikipedia)

□ Mémorandum

Le modèle de comportement Template Method est une superclasse qui décrit le traitement et les sous-classes qui déterminent le traitement spécifique. Il semble que le modèle Méthode d'usine est celui qui applique ce modèle Méthode modèle à la scène de création d'une instance.

■ Exemple de programme "Méthode d'usine"

Le modèle de méthode d'usine semble avoir les caractéristiques suivantes.

--Déterminer comment créer une instance côté superclasse

• Aucun nom de classe spécifique n'est spécifié --Tout le remplissage spécifique est effectué du côté de la sous-classe

En faisant cela, il semble que le cadre de création d'une instance et la classe réelle de création d'une instance peuvent être considérés séparément. En fait, j'aimerais utiliser le modèle de méthode d'usine pour exécuter un exemple de programme avec le thème «une usine qui fabrique des cartes d'identification (cartes d'identité)» et vérifier l'opération suivante.

--Créez trois cartes d'identité, «Hiroshi Yuki», «Tomura» et «Hanako Sato». --Utilisez 3 cartes d'identité: Hiroshi Yuki", Tomura, Hanako Sato`

$ python Main.py 
I'll create Hiroshi Yuki's card
I'll create Tomura's card
I'll create Hanako Sato's card
I'll use Hiroshi Yuki's card
I'll use Tomura's card
I'll use Hanako Sato's card

Si vous exécutez simplement l'exemple de programme, vous n'êtes pas sûr de ce que vous voulez faire. Ensuite, vérifions les détails de l'exemple de programme.

■ Détails de l'exemple de programme

Un code similaire a été téléchargé dans le référentiel Git. https://github.com/ttsubo/study_of_design_pattern/tree/master/FactoryMethod

• Structure du répertoire

.
├── Main.py
└── framework
    ├── __init__.py
    ├── factory.py
    └── idcardfactory
        ├── __init__.py
        └── id_card_factory.py

(1) Rôle du produit

Le rôle Product définit l'interface que l'instance doit avoir. Dans l'exemple de programme, la classe Product remplit ce rôle.

framework/factory.py

from abc import ABCMeta, abstractmethod

... (snip)

class Product(metaclass=ABCMeta):
    @abstractmethod
    def use(self):
        pass

(2) Le rôle du créateur

Dans le rôle de "Créateur", il est responsable de la génération du "Produit". Je ne sais rien du rôle Concrete Product qui est réellement généré. De plus, le rôle Creator fournit des méthodes pour créer chaque partie de l'instance. Dans l'exemple de programme, la classe Factory remplit ce rôle.

framework/factory.py

from abc import ABCMeta, abstractmethod

class Factory(metaclass=ABCMeta):
    def create(self, owner):
        p = self.createProduct(owner)
        self.registerProduct(p)
        return p

    @abstractmethod
    def createProduct(self, owner):
        pass

    @abstractmethod
    def registerProduct(self, product):
        pass

... (snip)

(3) Rôle du produit en béton

Le rôle ConcreteProduct est une classe qui implémente l'interface pour le rôle Product. La méthode qui sera appelée après l'instanciation réelle est définie ici. Dans l'exemple de programme, la classe ʻIDCardProduct` remplit ce rôle.

framework/id_card_factory.py

from framework.factory import Factory, Product

... (snip)

class IDCardProduct(Product):
    def __init__(self, owner):
        self.owner = owner
        print("I'll create {0}'s card".format(self.owner))

    def use(self):
        print("I'll use {0}'s card".format(self.owner))

(4) Le rôle de Concrete Creator

Le rôle ConcreteCreator est une classe qui implémente l'interface pour le rôle Creator. Déterminez la classe pour fabriquer un produit spécifique. Dans l'exemple de programme, la classe ʻIDCardFactory` remplit ce rôle.

framework/id_card_factory.py

from framework.factory import Factory, Product

class IDCardFactory(Factory):
    def __init__(self):
        self.owners = []

    def createProduct(self, owner):
        return IDCardProduct(owner)

    def registerProduct(self, product):
        self.owners.append(product.owner)

... (snip)

(5) Le rôle du client

Dans l'exemple de programme, la méthode startMain remplit ce rôle.

Main.py

from framework.idcardfactory.id_card_factory import IDCardFactory

def startMain(factoryObject):
    card1 = factoryObject.create("Hiroshi Yuki")
    card2 = factoryObject.create("Tomura")
    card3 = factoryObject.create("Hanako Sato")
    card1.use()
    card2.use()
    card3.use()

if __name__ == "__main__":
    startMain(IDCardFactory())

■ URL de référence

• Finition "Introduction aux modèles de conception appris en langage Java" (non) Introduction aux modèles de conception appris dans Language-Finishing-No-2cc9b34a30b2)
• Modèle de méthode d'usine du "journal de tachikawa844"