Verständnis der Fabrik- und Fabrikmethoden-Entwurfsmuster

Was ist eine Factory-Klasse? Eine Factory-Klasse ist eine Klasse, die ein oder mehrere Objekte verschiedener Klassen erstellt.

Das Factory-Muster ist wohl das am häufigsten verwendete Entwurfsmuster in der Softwareentwicklung. In diesem Artikel werde ich die Entwurfsmuster „Simple Factory“ und „Factory Method“ anhand eines einfachen Beispielproblems ausführlich erläutern.

Das einfache Fabrikmuster

Angenommen, wir möchten ein System erstellen, das zwei Arten von Tieren unterstützt, z. B. Hund und Katze. Jede der Tierklassen sollte über eine Methode verfügen, die den Geräuschtyp des Tieres erzeugt. Jetzt möchte ein Kunde das System verwenden, um Tiergeräusche basierend auf den Benutzereingaben des Kunden zu erzeugen. Eine grundlegende Lösung für das obige Problem kann wie folgt geschrieben werden:

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!")

Mit dieser Lösung wird unser Kunde das System wie folgt nutzen

## 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()

Unsere Lösung wird gut funktionieren, aber Simple Factory Pattern sagt, dass wir es besser machen können. Warum? Wie Sie im obigen Client-Code gesehen haben, muss der Client entscheiden, welche unserer Tierklassen er jeweils aufrufen möchte. Stellen Sie sich vor, das System hätte beispielsweise zehn verschiedene Tierklassen. Sie können bereits erkennen, wie problematisch die Nutzung des Systems für unseren Kunden sein wird.

Das Simple Factory-Muster besagt also einfach, dass wir das System für den Client entscheiden lassen, anstatt den Client entscheiden zu lassen, welche Klasse aufgerufen werden soll.

Um das Problem mithilfe des Simple Factory-Musters zu lösen, müssen wir lediglich eine Factory-Klasse mit einer Methode erstellen, die sich um die Erstellung von Tierobjekten kümmert.

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

Mit diesem Ansatz wird der Client-Code zu:

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

Zusammenfassend geht es beim Simple Factory-Muster darum, eine Factory-Klasse zu erstellen, die die Objekterstellung im Namen eines Clients übernimmt.

Factory-Methodenmuster

Um auf unsere Problemstellung zurückzukommen, ein System zu haben, das nur zwei Tierarten (Hund und Katze) unterstützt: Was wäre, wenn diese Einschränkung aufgehoben würde und unser System bereit wäre, jede Tierart zu unterstützen? Natürlich konnte es sich unser System nicht leisten, Implementierungen für Millionen von Tieren bereitzustellen. Hier kommt das Factory Method Pattern zur Rettung.

Im Factory-Methodenmuster definieren wir eine abstrakte Klasse oder Schnittstelle zum Erstellen von Objekten, aber anstatt dass die Factory für die Objekterstellung verantwortlich ist, wird die Verantwortung auf die Unterklasse übertragen, die entscheidet, welche Klasse instanziiert werden soll.

Schlüsselkomponenten des Factory-Methodenmusters

1. Creator: Der Creator ist eine abstrakte Klasse oder Schnittstelle. Es deklariert die Factory-Methode, eine Methode zum Erstellen von Objekten. Der Creator stellt eine Schnittstelle zum Erstellen von Produkten bereit, spezifiziert jedoch nicht deren konkrete Klassen.

2. Concrete Creator: Concrete Creators sind die Unterklassen des Creators. Sie implementieren die Factory-Methode und entscheiden, welche konkrete Produktklasse instanziiert werden soll. Mit anderen Worten: Jeder Concrete Creator ist auf die Herstellung eines bestimmten Produkttyps spezialisiert.

3. Produkt: Das Produkt ist eine weitere abstrakte Klasse oder Schnittstelle. Es definiert den Typ der Objekte, die die Factory-Methode erstellt. Diese Produkte haben eine gemeinsame Schnittstelle, ihre konkreten Implementierungen können jedoch variieren.

4. Betonprodukt: Betonprodukte sind die Unterklassen des Produkts. Sie stellen die spezifischen Implementierungen der Produkte bereit. Jedes konkrete Produkt entspricht einem Objekttyp, der mit der Factory-Methode erstellt wurde.

Unten sehen Sie, wie unser Systemcode unter Verwendung des Factory-Methodenmusters aussehen wird:

Schritt 1: Definieren des Produkts

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!")

Schritt 2: Betonprodukte erstellen

## 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()

Schritt 3: Den Schöpfer definieren

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

Schritt 4: Konkrete Schöpfer implementieren

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

Und der Kunde kann die Lösung wie folgt nutzen:

from abc import ABC, abstractmethod

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

Mit der Factory Method Pattern-Lösung können Kunden das System erweitern und bei Bedarf benutzerdefinierte Tierimplementierungen bereitstellen.

Vorteile des Factory-Methodenmusters

1. Entkopplung: Es entkoppelt den Client-Code von den konkreten Klassen, reduziert Abhängigkeiten und verbessert die Codestabilität.

2. Flexibilität: Es bringt viel Flexibilität mit sich und macht den Code generisch, sodass er für die Instanziierung nicht an eine bestimmte Klasse gebunden ist. Auf diese Weise sind wir von der Schnittstelle (Product) abhängig und nicht von der ConcreteProduct-Klasse.

3. Erweiterbarkeit: Neue Produktklassen können hinzugefügt werden, ohne den vorhandenen Code zu ändern, wodurch ein Offen-Geschlossen-Prinzip gefördert wird.

Abschluss

Das Entwurfsmuster der Factory-Methode bietet eine systematische Möglichkeit, Objekte zu erstellen und gleichzeitig den Code wartbar und anpassungsfähig zu halten. Es eignet sich hervorragend für Szenarien, in denen Objekttypen variieren oder sich weiterentwickeln.

Frameworks, Bibliotheken, Plug-in-Systeme und Software-Ökosysteme profitieren von seiner Leistungsfähigkeit. Es ermöglicht Systemen, sich an sich ändernde Anforderungen anzupassen.

Es sollte jedoch mit Bedacht und unter Berücksichtigung der spezifischen Anforderungen der Anwendung und des Prinzips der Einfachheit verwendet werden. Bei richtiger Anwendung kann das Factory-Methodenmuster erheblich zum Gesamtdesign und zur Architektur eines Softwaresystems beitragen.

Viel Spaß beim Codieren!!!

Das obige ist der detaillierte Inhalt vonVerständnis der Fabrik- und Fabrikmethoden-Entwurfsmuster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!