Golang Fabrikmuster

1. Was ist das Factory Method Pattern

Das Factory Method Pattern ist ein Erzeugungsmuster, das eine Möglichkeit bietet, den Objekterstellungsprozess in Unterklassen zu kapseln. Auf diese Weise kann der Client Objekte erstellen, indem er die Factory-Methode aufruft, ohne sich um den spezifischen Objekterstellungsprozess kümmern zu müssen.

2. Merkmale und Vorteile des Factory Method Pattern

Die Merkmale des Factory Method Pattern umfassen:

• Entkopplung der Erstellung und Verwendung von Objekten, wobei sich der Client nur um die Factory-Methode und das abstrakte Produktinterface kümmern muss.
• Das System kann durch das Hinzufügen neuer spezifischer Factory-Klassen und spezifischer Produktklassen erweitert werden, was dem Open/Closed-Prinzip entspricht.

Die Vorteile des Factory Method Pattern umfassen:

• Kapselung des Objekterstellungsprozesses, wodurch das System flexibler und erweiterbarer wird.
• Verbergen der Implementierungsdetails spezifischer Produktklassen, was die Abhängigkeit des Clients und die Kopplung an spezifische Klassen reduziert.
• Bereitstellung einer standardisierten Möglichkeit zur Erstellung von Produkten, was die Wartung und Erweiterung des Systems erleichtert.

3. Anwendungsszenarien des Factory Method Pattern

Das Factory Method Pattern eignet sich für folgende Szenarien:

• Der Client hängt nicht von spezifischen Produktklassen ab, sondern vom abstrakten Produktinterface.
• Der Client muss basierend auf unterschiedlichen Bedingungen dynamisch verschiedene Produktobjekte erstellen.
• Die Notwendigkeit, den Prozess der Produktobjekterstellung zu kapseln und zu verbergen.

4. Implementierung des Factory Method Pattern in Golang

4.1 UML Klassendiagramm

4.2 Implementierung Schritt 1: Definition des abstrakten Produktinterfaces

package factory

// Product ist das abstrakte Produktinterface
type Product interface {
	Operation() string
}

4.3 Implementierung Schritt 2: Erstellung von konkreten Produktimplementierungsklassen

package factory

// ConcreteProductA ist die konkrete Produktklasse A
type ConcreteProductA struct{}

// Operation ist die Methode der konkreten Produktklasse A
func (p *ConcreteProductA) Operation() string {
	return "ConcreteProductA"
}

// ConcreteProductB ist die konkrete Produktklasse B
type ConcreteProductB struct{}

// Operation ist die Methode der konkreten Produktklasse B
func (p *ConcreteProductB) Operation() string {
	return "ConcreteProductB"
}

4.4 Implementierung Schritt 3: Definition des abstrakten Factory-Interfaces

package factory

// Factory ist das abstrakte Factory-Interface
type Factory interface {
	CreateProduct() Product
}

4.5 Implementierung Schritt 4: Erstellung von konkreten Factory-Implementierungsklassen

package factory

// ConcreteFactoryA ist die konkrete Factory-Klasse A
type ConcreteFactoryA struct{}

// CreateProduct ist die Methode der konkreten Factory-Klasse A
func (f *ConcreteFactoryA) CreateProduct() Product {
	return &ConcreteProductA{}
}

// ConcreteFactoryB ist die konkrete Factory-Klasse B
type ConcreteFactoryB struct{}

// CreateProduct ist die Methode der konkreten Factory-Klasse B
func (f *ConcreteFactoryB) CreateProduct() Product {
	return &ConcreteProductB{}
}

4.6 Implementierung Schritt 5: Der Client ruft die Factory-Methode auf, um Produktobjekte zu erstellen

package main

import (
	"fmt"
	"github.com/your/package/factory"
)

func main() {
	// Erstellung von Concrete Factory A
	factoryA := &factory.ConcreteFactoryA{}
	// Aufruf der Factory-Methode zur Erstellung von Produktobjekten
	productA := factoryA.CreateProduct()
	fmt.Println(productA.Operation())

	// Erstellung von Concrete Factory B
	factoryB := &factory.ConcreteFactoryB{}
	// Aufruf der Factory-Methode zur Erstellung von Produktobjekten
	productB := factoryB.CreateProduct()
	fmt.Println(productB.Operation())
}

Im obigen Code definieren wir das abstrakte Produktinterface Product und die konkreten Produktklassen ConcreteProductA und ConcreteProductB. Anschließend definieren wir das abstrakte Factory-Interface Factory und die konkreten Factory-Klassen ConcreteFactoryA und ConcreteFactoryB. Der Client kann spezifische Produktobjekte erstellen, indem er die Factory-Methode der konkreten Factory-Klasse aufruft, wodurch das Factory Method Pattern implementiert wird.

Mit den oben genannten Schritten haben wir die Implementierung des Factory Method Patterns in Golang abgeschlossen. Dieser Ansatz entkoppelt den Client von den spezifischen Produktklassen und ermöglicht es dem Client, sich nur auf das abstrakte Produktinterface zu konzentrieren. Gleichzeitig sind die Implementierungsdetails spezifischer Produktklassen in der konkreten Factory-Klasse gekapselt, was das System flexibler und erweiterbarer macht. Das Factory Method Pattern ist in der Praxis sehr verbreitet, insbesondere in Szenarien, in denen die dynamische Erstellung verschiedener Objekttypen erforderlich ist, was die Code-Wiederverwendbarkeit und -wartbarkeit effektiv verbessert.