[GO] Lernen Sie das Entwurfsmuster "Factory Method" in Python
Als Material zum Erlernen von GoF-Entwurfsmustern scheint das Buch "Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden" hilfreich zu sein. Da die aufgeführten Beispiele jedoch auf JAVA basieren, habe ich dieselbe Vorgehensweise mit Python versucht, um mein Verständnis zu vertiefen.
■ Werksmethode
Das Factory-Methodenmuster ist eines der von GoF (Gang of Four) definierten Entwurfsmuster. Das Factory-Methodenmuster zielt darauf ab, die anwendungsspezifische Objekterstellung in Unterklassen zu verschieben und die Wiederverwendbarkeit von Klassen zu erhöhen, indem die Konstruktoren anderer Klassen durch ihre eigenen Methoden ersetzt werden, die von Unterklassen überschrieben werden können.
Wird auch als Virtual Constructor-Muster bezeichnet.
UML class diagram
(Das Obige wird aus Wikipedia zitiert)
□ Memorandum
Das Verhaltensmuster Template Method for Behavior ist eine Oberklasse, die die Verarbeitung und Unterklassen beschreibt, die die spezifische Verarbeitung bestimmen. Es scheint, dass das Muster "Factory Method" das Muster "Template Method" auf die Szene beim Erstellen einer Instanz anwendet.
■ Beispielprogramm "Factory Method"
Das Factory-Methodenmuster scheint die folgenden Funktionen zu haben.
- Bestimmen Sie, wie eine Instanz auf der Seite der Oberklasse erstellt wird
- Es wurde kein spezifischer Klassenname angegeben
- Alle spezifischen Fleischarbeiten werden auf der Seite der Unterklasse durchgeführt
Auf diese Weise können das Framework zum Erstellen einer Instanz und die tatsächliche Klasse zum Erstellen einer Instanz separat betrachtet werden. Eigentlich möchte ich das Factory-Methodenmuster verwenden, um ein Beispielprogramm mit dem Thema "Eine Fabrik, die Identifikationskarten (ID-Karten) herstellt" auszuführen und den folgenden Vorgang zu überprüfen.
- Erstellen Sie drei ID-Karten, "Hiroshi Yuki", "Tomura" und "Hanako Sato". --Verwenden Sie 3 ID-Karten: "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
Wenn Sie nur das Beispielprogramm ausführen, sind Sie sich nicht sicher, was Sie tun möchten. Als nächstes überprüfen wir die Details des Beispielprogramms.
■ Details zum Beispielprogramm
Ähnlicher Code wurde in das Git-Repository hochgeladen. https://github.com/ttsubo/study_of_design_pattern/tree/master/FactoryMethod
--Verzeichnisaufbau
.
├── Main.py
└── framework
├── __init__.py
├── factory.py
└── idcardfactory
├── __init__.py
└── id_card_factory.py
(1) Rolle des Produkts
Die Rolle "Produkt" definiert die Schnittstelle, die die Instanz haben soll. Im Beispielprogramm übernimmt die Klasse "Produkt" diese Rolle.
framework/factory.py
from abc import ABCMeta, abstractmethod
... (snip)
class Product(metaclass=ABCMeta):
@abstractmethod
def use(self):
pass
(2) Die Rolle des Schöpfers
In der Rolle des "Schöpfers" ist es für die Erzeugung des "Produkts" verantwortlich. Ich weiß nichts über die Rolle des "konkreten Produkts", die tatsächlich generiert wird. Darüber hinaus bietet die Rolle "Ersteller" Methoden zum Erstellen jedes Teils der Instanz. Im Beispielprogramm übernimmt die Factory-Klasse diese Rolle.
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) Rolle des Betonprodukts
Die Rolle "ConcreteProduct" ist eine Klasse, die die Schnittstelle für die Rolle "Product" implementiert. Hier wird die Methode definiert, die nach der eigentlichen Instanziierung aufgerufen wird. Im Beispielprogramm übernimmt die IDCardProduct-Klasse diese Rolle.
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) Die Rolle des konkreten Schöpfers
Die Rolle "ConcreteCreator" ist eine Klasse, die die Schnittstelle für die Rolle "Creator" implementiert. Bestimmen Sie die Klasse für ein bestimmtes Produkt. Im Beispielprogramm übernimmt die IDCardFactory-Klasse diese Rolle.
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) Die Rolle des Kunden
Im Beispielprogramm übernimmt die Methode "startMain" diese Rolle.
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())
■ Referenz-URL
- [Abschluss "Einführung in in Java-Sprache erlernte Entwurfsmuster" (nicht)](https://medium.com/since-i-want-to-start-blog-that-looks-like-men-do/java Einführung in Entwurfsmuster, die in Sprachen gelernt wurden - Finishing-Not-2cc9b34a30b2)
- Factory Method Pattern aus "Tagebuch von Tachikawa844"
Recommended Posts