Erzählen Sie vom Entwurfsmuster 'Builder'.

Das Entwurfsmuster "Builder" ist ein kreierendes Muster, das die schrittweise Erstellung komplexer Objekte ermöglicht. Es trennt den Konstruktionsprozess eines komplexen Objekts von seiner Darstellung, sodass derselbe Bauprozess verschiedene Darstellungen erzeugen kann.

Hauptkomponenten:

• Builder: Schnittstelle oder abstrakte Klasse, die Methoden zur Erstellung von Teilen eines komplexen Objekts definiert.
• Konkreter Builder: Implementiert die Builder-Schnittstelle und stellt eine konkrete Umsetzung für den Bau der Teile des Objekts bereit. Er speichert das Zwischenergebnis und bietet eine Methode, um das fertige Objekt zu erhalten.
• Director: Optional. Bestimmt die Reihenfolge, in der die Builder-Methoden aufgerufen werden, um das Objekt zu erstellen. Kennt keine konkreten Builder.
• Produkt: Das komplexe Objekt, das vom Builder erstellt wird.

Anwendung:

• Wenn der Erstellungsprozess eines Objekts komplex ist und mehrere optionale Schritte umfasst.
• Wenn verschiedene Darstellungen desselben Objekts mit demselben Bauprozess erstellt werden sollen.
• Wenn der Konstruktor des Objekts viele Parameter hat.

Beispiel in Go:

// Produkt - komplexes Objekt
type Product struct {
	PartA string
	PartB string
	PartC string
}

// Builder - Schnittstelle des Builders
type Builder interface {
	BuildPartA()
	BuildPartB()
	BuildPartC()
	GetProduct() *Product
}

// ConcreteBuilder - konkreter Builder
type ConcreteBuilder struct {
	product *Product
}

func NewConcreteBuilder() *ConcreteBuilder {
	return &ConcreteBuilder{product: &Product{}}
}

func (cb *ConcreteBuilder) BuildPartA() {
	cb.product.PartA = "Teil A gebaut"
}

func (cb *ConcreteBuilder) BuildPartB() {
	cb.product.PartB = "Teil B gebaut"
}

func (cb *ConcreteBuilder) BuildPartC() {
	cb.product.PartC = "Teil C gebaut"
}

func (cb *ConcreteBuilder) GetProduct() *Product {
	return cb.product
}

// Director - Regisseur (optional)
type Director struct {
	builder Builder
}

func NewDirector(builder Builder) *Director {
	return &Director{builder: builder}
}

func (d *Director) Construct() {
	d.builder.BuildPartA()
	d.builder.BuildPartB()
	d.builder.BuildPartC()
}

// Verwendung
// concreteBuilder := NewConcreteBuilder()
// director := NewDirector(concreteBuilder)
// director.Construct()
// product := concreteBuilder.GetProduct()
// fmt.Printf("Produkt erstellt: %+v\n", product)

Vorteile:

• Isoliert den Konstruktionscode vom Client-Code.
• Ermöglicht es, die interne Darstellung des Produkts zu ändern, ohne den Client-Code zu modifizieren.
• Ermöglicht die schrittweise Konstruktion des Objekts.
• Vereinfacht die Erstellung von Objekten mit vielen Parametern.

Nachteile:

• Erhöht die Anzahl des Codes (Klassen/Interfaces) für die Objekterstellung.
• Kann für einfache Objekte überflüssig sein.