Abstraktes Factory-Muster

Teil des Abschnitts Objektorientierte Programmierung der GO-Journey von Coddy. Lektion 88 von 107.

Das Abstract-Factory-Muster erweitert das Factory-Muster, indem es Familien verwandter Objekte erstellt, ohne ihre konkreten Typen anzugeben. Anstelle einer einzelnen Factory-Funktion definierst du eine Factory-Schnittstelle, die mehrere konkrete Factorys implementieren, wobei jede ein konsistentes Set verwandter Objekte erzeugt.

Stell dir ein UI-Toolkit vor, das Schaltflächen und Kontrollkästchen erstellen muss. Verschiedene Betriebssysteme erfordern unterschiedliche Implementierungen, aber die Komponenten müssen konsistent zusammenarbeiten:

type Button interface {
    Render() string
}

type Checkbox interface {
    Check() string
}

// Abstrakte Fabrik-Schnittstelle
type GUIFactory interface {
    CreateButton() Button
    CreateCheckbox() Checkbox
}

Jede konkrete Fabrik produziert eine Familie verwandter Komponenten:

// Windows-Familie
type WindowsButton struct{}
func (w WindowsButton) Render() string { return "Windows Button" }

type WindowsCheckbox struct{}
func (w WindowsCheckbox) Check() string { return "Windows Checkbox" }

type WindowsFactory struct{}
func (w WindowsFactory) CreateButton() Button { return WindowsButton{} }
func (w WindowsFactory) CreateCheckbox() Checkbox { return WindowsCheckbox{} }

// Mac-Familie
type MacButton struct{}
func (m MacButton) Render() string { return "Mac Button" }

type MacCheckbox struct{}
func (m MacCheckbox) Check() string { return "Mac Checkbox" }

type MacFactory struct{}
func (m MacFactory) CreateButton() Button { return MacButton{} }
func (m MacFactory) CreateCheckbox() Checkbox { return MacCheckbox{} }

Der Client-Code arbeitet mit der Factory-Schnittstelle und bleibt unabhängig von konkreten Implementierungen:

func BuildUI(factory GUIFactory) {
    button := factory.CreateButton()
    checkbox := factory.CreateCheckbox()
    fmt.Println(button.Render(), checkbox.Check())
}

Verwende Abstract Factory, wenn dein System mit mehreren Familien verwandter Produkte arbeiten muss und du sicherstellen möchtest, dass Komponenten derselben Familie zusammen verwendet werden. Sie ist komplexer als eine einfache Factory. Greife daher nur darauf zurück, wenn du tatsächlich Produktfamilien verwalten musst.

Aufgabe

Einfach

Lass uns ein Möbelladensystem mit dem Abstract-Factory-Muster erstellen! Du wirst Fabriken erstellen, die Familien verwandter Möbelstücke produzieren: Jede Fabrik produziert einen einheitlichen Stil (Modern oder Vintage) und stellt so sicher, dass Stühle und Tische aus derselben Fabrik ästhetisch zusammenpassen.

Du wirst deinen Code auf drei Dateien verteilen:

furniture.go: Definiere deine Produktschnittstellen und konkreten Möbeltypen.
Erstelle zwei Produktschnittstellen:
- Chair mit einer Methode SitOn() string
- Table mit einer Methode PlaceItems() string
Implementiere zwei Möbelfamilien:
- Moderne Familie: ModernChair gibt Sitting on a sleek modern chair zurück und ModernTable gibt Placing items on a glass modern table zurück
- Vintage-Familie: VintageChair gibt Sitting on an ornate vintage chair zurück und VintageTable gibt Placing items on a wooden vintage table zurück
factory.go: Definiere deine abstrakte Fabrikschnittstelle und konkrete Fabriken.
Erstelle eine FurnitureFactory-Schnittstelle mit zwei Methoden:
- CreateChair() Chair
- CreateTable() Table
Implementiere zwei konkrete Fabriken:
- ModernFactory, die ModernChair und ModernTable produziert
- VintageFactory, die VintageChair und VintageTable produziert
Erstelle außerdem eine Funktion GetFactory(style string) FurnitureFactory, die abhängig vom Stil (modern oder vintage) die passende Fabrik zurückgibt. Verwende für nicht erkannte Stile standardmäßig ModernFactory.
main.go: Verwende deine Fabriken, um Räume einzurichten.
Erstelle eine Funktion FurnishRoom(factory FurnitureFactory) string, die die Fabrik verwendet, um einen Stuhl und einen Tisch zu erstellen, und anschließend eine formatierte Zeichenkette zurückgibt, die beide Aktionen in separaten Zeilen darstellt.

Lies eine Stileingabe ein, rufe die passende Fabrik ab, richte einen Raum ein und gib das Ergebnis aus.

Die folgenden Eingaben werden bereitgestellt:

Zeile 1: Möbelstil (modern, vintage oder etwas anderes)

Zum Beispiel bei:

modern

Deine Ausgabe sollte sein:

Sitting on a sleek modern chair
Placing items on a glass modern table

Und bei:

vintage

Deine Ausgabe sollte sein:

Sitting on an ornate vintage chair
Placing items on a wooden vintage table

Und bei:

rustic

Deine Ausgabe sollte sein:

Sitting on a sleek modern chair
Placing items on a glass modern table

Beachte, wie die Funktion FurnishRoom über die Schnittstelle mit jeder Fabrik funktioniert. Sie weiß nicht, ob sie moderne oder Vintage-Möbel erstellt. Dadurch wird sichergestellt, dass alle Möbel in einem Raum aus derselben Familie stammen und ein einheitlicher Stil erhalten bleibt!

Probier es selbst

package main

import "fmt"

// FurnishRoom verwendet eine Factory, um Möbel zu erstellen und gibt das Ergebnis zurück
// TODO: Implementiere diese Funktion
// - Verwende die Factory, um einen Stuhl und einen Tisch zu erstellen
// - Gib einen String mit dem SitOn()-Ergebnis in der ersten Zeile und dem PlaceItems()-Ergebnis in der zweiten Zeile zurück
func FurnishRoom(factory FurnitureFactory) string {
	// TODO: Erstelle Stuhl und Tisch mithilfe der Factory
	// TODO: Gib einen formatierten String mit beiden Aktionen in separaten Zeilen zurück
	return ""
}

func main() {
	var style string
	fmt.Scanln(&style)

	// TODO: Hole die passende Factory basierend auf dem Stil
	// TODO: Richte einen Raum mithilfe der Factory ein
	// TODO: Gib das Ergebnis aus
}