Das Builder-Entwurfsmuster wird zum schrittweisen Erstellen komplexer Objekte verwendet und ermöglicht die Erstellung verschiedener Darstellungen eines Objekts mit demselben Konstruktionsprozess. In diesem Artikel werden wir untersuchen, wie das Builder-Muster in Golang implementiert wird, seine Vorteile verstehen und ein praktisches Anwendungsbeispiel analysieren.

Was ist Builder?

Das Builder-Muster trennt die Konstruktion eines komplexen Objekts von seiner Darstellung, sodass mit demselben Konstruktionsprozess unterschiedliche Darstellungen erstellt werden können. Dies ist besonders nützlich, wenn ein Objekt in mehreren Schritten oder mit mehreren möglichen Konfigurationen erstellt werden muss.

Vorteile für Bauherren

• Trennung von Konstruktion und Darstellung: Ermöglicht die Trennung der Konstruktion eines Objekts von seiner endgültigen Darstellung.
• Inkrementelle Konstruktion: Ermöglicht die schrittweise und schrittweise Konstruktion komplexer Objekte.
• Code-Wiederverwendung: Erleichtert die Wiederverwendung von Code durch die Definition allgemeiner Build-Schritte, die auf verschiedene Arten kombiniert werden können.

Implementieren eines Builders

Um unseren Builder zu implementieren, stellen wir uns ein komplexes Objekt vor, bei dem mehrere Felder und sogar andere gruppierte Objekte initialisiert werden müssen. Wie wäre es mit einem Haus? Wo wir zwei Bauarten haben werden, eine konventionelle, bei der Beton und Ziegel verwendet werden, und eine zweite aus Holz.

1 – Definieren der Struktur

Zuerst müssen wir die Struktur des Objekts definieren, das wir erstellen möchten. Wie bereits gesagt, wir werden ein Haus bauen. In dieser Struktur werden wir alles platzieren, was zum Erstellen einer Struktur erforderlich ist.

// house.go

package main

type House struct {
    Foundation string
    Structure  string
    Roof       string
    Interior   string
}

2 – Definieren der Builder-Schnittstelle

Noch in derselben Datei definieren wir unsere Builder-Schnittstelle, die die Methoden angibt, die zum Bau der verschiedenen Teile des Hauses erforderlich sind.

//house.go

package main

type House struct {
    Foundation string
    Structure  string
    Roof       string
    Interior   string
}

type HouseBuilder interface {
    SetFoundation()
    SetStructure()
    SetRoof()
    SetInterior()
    GetHouse() House
}

3 – Konkrete Umsetzung des Builders

Lassen Sie uns zwei neue Dateien erstellen, ConcreteHouse und WoodHouse. Sie werden die Implementierung einer konkreten Klasse sein, die der HouseBuilder-Schnittstelle folgt.

//concreteHouse.go

package main

type ConcreteHouseBuilder struct {
    house House
}

func (b *ConcreteHouseBuilder) SetFoundation() {
    b.house.Foundation = "Concrete, brick, and stone"
}

func (b *ConcreteHouseBuilder) SetStructure() {
    b.house.Structure = "Wood and brick"
}

func (b *ConcreteHouseBuilder) SetRoof() {
    b.house.Roof = "Concrete and reinforced steel"
}

func (b *ConcreteHouseBuilder) SetInterior() {
    b.house.Interior = "Gypsum board, plywood, and paint"
}

func (b *ConcreteHouseBuilder) GetHouse() House {
    return b.house
}

//woodHouse.go

package main

type WoodHouseBuilder struct {
    house House
}

func (b *WoodHouseBuilder) SetFoundation() {
    b.house.Foundation = "Wooden piles"
}

func (b *WoodHouseBuilder) SetStructure() {
    b.house.Structure = "Wooden frame"
}

func (b *WoodHouseBuilder) SetRoof() {
    b.house.Roof = "Wooden shingles"
}

func (b *WoodHouseBuilder) SetInterior() {
    b.house.Interior = "Wooden panels and paint"
}

func (b *WoodHouseBuilder) GetHouse() House {
    return b.house
}

4 – Den Regisseur definieren

Der Director ist eine Klasse, die die Konstruktion eines Objekts verwaltet und sicherstellt, dass die Konstruktionsschritte in der richtigen Reihenfolge aufgerufen werden. Es weiß nichts über die Details bestimmter Builder-Implementierungen, es ruft lediglich Builder-Methoden in einer logischen Reihenfolge auf, um das Endprodukt zu erstellen.

//director.go

package main

type Director struct {
    builder HouseBuilder
}

func (d *Director) Build() {
    d.builder.SetFoundation()
    d.builder.SetStructure()
    d.builder.SetRoof()
    d.builder.SetInterior()
}

func (d *Director) SetBuilder(b HouseBuilder) {
    d.builder = b
}

5 – Verwendung des Builders

Schließlich werden wir den Direktor und Betonbauer einsetzen, um verschiedene Arten von Häusern zu bauen.

//main.go

package main

import (
    "fmt"
)

func main() {
    cb := &builder.ConcreteHouseBuilder{}
    director := builder.Director{Builder: cb}

    director.Build()
    concreteHouse := cb.GetHouse()

    fmt.Println("Concrete House")
    fmt.Println("Foundation:", concreteHouse.Foundation)
    fmt.Println("Structure:", concreteHouse.Structure)
    fmt.Println("Roof:", concreteHouse.Roof)
    fmt.Println("Interior:", concreteHouse.Interior)
    fmt.Println("-------------------------------------------")

    wb := &builder.WoodHouseBuilder{}
    director.SetBuilder(wb)

    director.Build()
    woodHouse := wb.GetHouse()

    fmt.Println("Wood House")
    fmt.Println("Foundation:", woodHouse.Foundation)
    fmt.Println("Structure:", woodHouse.Structure)
    fmt.Println("Roof:", woodHouse.Roof)
    fmt.Println("Interior:", woodHouse.Interior)
}

Zusamenfassend

1. Strukturhaus: Stellt das Endprodukt dar, das wir bauen.
2. HouseBuilder-Schnittstelle: Definiert die Methoden zum Bau der verschiedenen Teile des Hauses.
3. Betonimplementierungen (ConcreteHouseBuilder und WoodHouseBuilder): Implementieren Sie die HouseBuilder-Schnittstelle und definieren Sie spezifische Bauschritte.
4. Direktor: Verwaltet den Bauprozess und stellt sicher, dass die Schritte in der richtigen Reihenfolge aufgerufen werden.
5. Hauptfunktion: Demonstriert die Verwendung des Builder-Musters zum Bau verschiedener Haustypen, ruft den Direktor auf, um den Prozess zu verwalten und das Endprodukt zu erhalten.

Abschluss

Das Builder-Muster ist ein Werkzeug zum schrittweisen und flexiblen Erstellen komplexer Objekte. In Golang ist die Umsetzung dieses Musters direkt und effektiv und ermöglicht die Erstellung modularer und leicht zu wartender Systeme. Durch die Verwendung konkreter Schnittstellen und Klassen können wir die Konstruktionslogik zentralisieren und die Codeentwicklung vereinfachen, wenn neue Anforderungen entstehen.