Vertel over het ontwerppatroon 'Bouwer'.

Het ontwerp patroon "Builder" (Bouwer) is een creational patroon dat het mogelijk maakt om complexe objecten stapsgewijs te creëren. Het scheidt het bouwproces van een complex object van zijn representatie, zodat hetzelfde bouwproces verschillende representaties kan creëren.

Belangrijkste componenten:

• Bouwer (Builder): Interface of abstracte klasse die methoden definieert voor het maken van delen van een complex object.
• Concrete Bouwer (Concrete Builder): Implementeert de bouwerinterface en biedt een concrete implementatie voor het bouwen van de delen van het object. Het slaat de tussenresultaten op en biedt een methode om het uiteindelijke object te verkrijgen.
• Directeur (Director): Optioneel. Bepaalt de volgorde waarin de bouwer-methoden worden aangeroepen om het object te maken. Kent geen concrete bouwers.
• Product (Product): Het complexe object dat door de bouwer wordt gemaakt.

Toepassingen:

• Wanneer het proces van het maken van een object complex is en meerdere optionele stappen omvat.
• Wanneer verschillende representaties van hetzelfde object moeten worden gemaakt met hetzelfde bouwproces.
• Wanneer de constructor van het object veel parameters heeft.

Voorbeeld in Go:

// Product - complex object
type Product struct {
	PartA string
	PartB string
	PartC string
}

// Bouwer - interface van de bouwer
type Builder interface {
	BuildPartA()
	BuildPartB()
	BuildPartC()
	GetProduct() *Product
}

// ConcreteBouwer - concrete bouwer
type ConcreteBuilder struct {
	product *Product
}

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

func (cb *ConcreteBuilder) BuildPartA() {
	cb.product.PartA = "Deel A gebouwd"
}

func (cb *ConcreteBuilder) BuildPartB() {
	cb.product.PartB = "Deel B gebouwd"
}

func (cb *ConcreteBuilder) BuildPartC() {
	cb.product.PartC = "Deel C gebouwd"
}

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

// Directeur - optioneel
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()
}

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

Voordelen:

• Scheidt de bouwcode van het object van de clientcode.
• Maakt het mogelijk om de interne representatie van het product te wijzigen zonder de clientcode te wijzigen.
• Maakt stapsgewijze constructie van het object mogelijk.
• Vereenvoudigt het maken van objecten met veel parameters.

Nadelen:

• Verhoogt de hoeveelheid code (klassen/interfacen) die nodig is om het object te maken.
• Kan overbodig zijn voor eenvoudige objecten.