Das Factory-Entwurfsmuster wird häufig in der objektorientierten Programmierung verwendet. Es bietet eine Schnittstelle zum Erstellen von Objekten, lässt aber Unterklassen entscheiden, welche Klassen instanziiert werden sollen. In diesem Artikel untersuchen wir, wie das Factory-Muster in Golang implementiert wird, verstehen seine Vorteile und analysieren ein praktisches Anwendungsbeispiel, das von alltäglichen Situationen inspiriert ist.

Was ist Fabrik?

Factory definiert eine Schnittstelle zum Erstellen von Objekten, delegiert jedoch die Verantwortung für die Instanziierung der konkreten Klasse an Unterklassen. Dies fördert die entkoppelte und flexible Erstellung von Objekten, wodurch der Code modularer und einfacher zu warten ist.

Vorteile

• Entkopplung: Trennt die Erstellung von Objekten von ihrer Implementierung und fördert so saubereren und modulareren Code.
• Flexibilität: Erleichtert die Einführung neuer Klassen, ohne den vorhandenen Code zu ändern.
• Wartung: Erleichtert die Wartung und Weiterentwicklung des Codes, da die Erstellungslogik an einem einzigen Ort zentralisiert ist.

Implementierung einer Fabrik

Lassen Sie uns das Factory-Muster anhand eines alltäglichen Beispiels veranschaulichen: ein System zur Essensbestellung, bei dem verschiedene Arten von Mahlzeiten (Pizza und Salat) erstellt werden können.

1 – Erstellen der Schnittstelle

Zuerst müssen wir eine Schnittstelle definieren, die von allen „konkreten Klassen“ von Mahlzeiten implementiert wird.

package main

type Food interface {
    Prepare()
}

2 – Erstellen einer ENUM und Implementierung der Schnittstelle

Um uns das Leben während der Entwicklung zu erleichtern und zu vermeiden, dass wir bei der Validierung etwas falsch eingeben, besteht eine gute Vorgehensweise darin, eine ENUM zu erstellen, um Konsistenz zu gewährleisten und es auch einfacher zu machen, wenn wir in Zukunft neue Lebensmittel hinzufügen möchten

package main

type FoodType int

const (
    PizzaType FoodType = iota
    SaladType
)

type Food interface {
    Prepare()
}

Und jetzt implementieren wir die Food-Schnittstelle. Im Beispiel zeigen wir nur eine Nachricht an, im wirklichen Leben würde hier das Objekt erstellt werden, an dem wir arbeiten

package main

type FoodType int

const (
    PizzaType FoodType = iota
    SaladType
)

type Food interface {
    Prepare()
}

type Pizza struct{}

func (p Pizza) Prepare() {
    fmt.Println("Preparing a Pizza...")
}

type Salad struct{}

func (s Salad) Prepare() {
    fmt.Println("Preparing a Salad...")
}

3 – Die Fabrik erschaffen

Jetzt erstellen wir die Fabrik, die basierend auf der als Parameter empfangenen Aufzählung entscheidet, welche konkrete Klasse instanziiert werden soll.

package main

type FoodFactory struct{}

func (f FoodFactory) CreateFood(ft FoodType) Food {
    switch ft {
    case PizzaType:
        return &Pizza{}
    case SaladType:
        return &Salad{}
    default:
        return nil
    }
}

4 – Factory verwenden

Schließlich werden wir die Fabrik nutzen, um unser Essen herzustellen.

package main

func main() {
    kitchen := FoodFactory{}

    pizza := kitchen.CreateFood(PizzaType)
    if pizza != nil {
        pizza.Prepare()
    }

    salad := kitchen.CreateFood(SaladType)
    if salad != nil {
        salad.Prepare()
    }
}

Dies wird das Ergebnis sein, nachdem unsere Anwendung ausgeführt wurde:

Preparing a Pizza...
Preparing a Salad...

Zusammenfassung dessen, was wir getan haben

1. Lebensmittelschnittstelle: Definiert den Vertrag, dem alle konkreten Mahlzeiten folgen müssen, um sicherzustellen, dass sie alle die Prepare-Methode implementieren.
2. Enum FoodType: Verwendet typisierte Konstanten, um verschiedene Arten von Lebensmitteln darzustellen, wodurch die Lesbarkeit und Sicherheit des Codes erhöht wird.
3. Konkrete Klassen (Pizza und Salat): Implementieren Sie die Food-Schnittstelle und stellen Sie ihre eigenen Implementierungen der Prepare-Methode bereit.
4. FoodFactory: Enthält Objekterstellungslogik. Die CreateFood-Methode entscheidet basierend auf der FoodType-Enumeration, welche konkrete Klasse instanziiert werden soll.
5. Hauptmethode: Demonstriert die Verwendung der Factory zum Erstellen verschiedener Objekte und zum Aufrufen ihrer Methoden und veranschaulicht die Flexibilität und Entkopplung, die das Factory-Muster bietet.

Abschluss

Das Factory-Entwurfsmuster ist ein leistungsstarkes Werkzeug zur Förderung der Entkopplung und Flexibilität bei der Objekterstellung. In Golang ist die Umsetzung dieses Musters direkt und effektiv und ermöglicht die Erstellung modularer und leicht zu wartender Systeme. Mithilfe von Schnittstellen und Fabriken können wir die Erstellungslogik zentralisieren und die Codeentwicklung vereinfachen, wenn neue Anforderungen entstehen.