Abstract Factory ist ein kreatives Designmuster, mit dem Sie verwandte Objekte erstellen können, ohne ihre konkreten Klassen anzugeben.

Problemstellung

Stellen Sie sich vor, Sie entwickeln ein GUI-Toolkit, das mehrere Look-and-Feel-Standards unterstützen soll (z. B. Windows, macOS, Linux). Jeder Look-and-Feel-Standard erfordert einen anderen Satz von UI-Komponenten wie Schaltflächen, Kontrollkästchen und Bildlaufleisten.

Ohne das Abstract Factory-Muster müssten Sie eine Menge bedingten Code schreiben, um die Erstellung dieser Komponenten basierend auf dem aktuellen Look-and-Feel-Standard zu bewältigen. Dieser Ansatz ist nicht skalierbar und erschwert die Wartung und Erweiterung der Codebasis.

Mithilfe des Abstract Factory-Musters können Sie eine Schnittstelle zum Erstellen von Familien verwandter Objekte (z. B. Schaltflächen, Kontrollkästchen, Bildlaufleisten) erstellen und diese Schnittstelle für jeden Look-and-Feel-Standard implementieren. Auf diese Weise kann der Client-Code mit jedem Look-and-Feel-Standard arbeiten, ohne die Besonderheiten der Erstellung der Komponenten zu kennen.

Beispiel aus der Praxis

Stellen Sie sich eine Möbelfabrik vor, die Stühle und Tische in verschiedenen Stilrichtungen wie klassisch und modern herstellt.

Jeder Stil erfordert einen anderen Satz an Komponenten (z. B. Beine, Rückenlehne, Armlehnen) und Materialien (z. B. Holz, Metall, Kunststoff).

Durchführung

• Führen Sie das Beispiel aus, indem Sie go run abstract-factory/main.go ausführen.

package main

import "fmt"

// Abstract Factory
type FurnitureFactory interface {
    MakeChair() Chair
    MakeTable() Table
}

func NewFurnitureFactory(style string) (FurnitureFactory, error) {
    if style == "classic" {
        return &Classic{}, nil
    }

    if style == "modern" {
        return &Modern{}, nil
    }

    return nil, fmt.Errorf("Style %s is not supported", style)
}

type Chair struct {
    Name     string
    Material string
}

type Table struct {
    Name     string
    Material string
}

// Concrete Classic Factory
type Classic struct{}

func (a *Classic) MakeChair() Chair {
    return Chair{
        Name:     "Classic Chair",
        Material: "Wood",
    }
}

func (a *Classic) MakeTable() Table {
    return Table{
        Name:     "Classic Table",
        Material: "Wood",
    }
}

// Concrete Modern Factory
type Modern struct{}

func (n *Modern) MakeChair() Chair {
    return Chair{
        Name:     "Modern Chair",
        Material: "Plastic",
    }
}

func (n *Modern) MakeTable() Table {
    return Table{
        Name:     "Modern Table",
        Material: "Plastic",
    }
}

func main() {
    factory, _ := NewFurnitureFactory("classic")

    chair := factory.MakeChair()
    table := factory.MakeTable()

    fmt.Printf("Chair: %s\n", chair.Name)
    fmt.Printf("Table: %s\n", table.Name)

    factory, _ = NewFurnitureFactory("modern")

    chair = factory.MakeChair()
    table = factory.MakeTable()

    fmt.Printf("Chair: %s\n", chair.Name)
    fmt.Printf("Table: %s\n", table.Name)
}

Erläuterung

Dieser Code demonstriert das Abstract Factory-Muster durch die Erstellung von Möbeln (Stühlen und Tischen) in verschiedenen Stilen (klassisch und modern). Es definiert eine Schnittstelle zum Erstellen von Familien verwandter Objekte und konkreter Implementierungen für jeden Stil und ermöglicht so eine einfache Skalierbarkeit und Wartung.