Vorbește despre șablonul de proiectare 'Constructor'.

Modelul de proiectare "Builder" (Constructor) este un model creational care permite crearea pas cu pas a obiectelor complexe. El separă procesul de construcție al unui obiect complex de reprezentarea sa, astfel încât același proces de construcție poate crea diferite reprezentări.

Componente principale:

• Builder (Constructor): Interfață sau clasă abstractă care definește metodele pentru crearea părților unui obiect complex.
• Builder Concret (Concrete Builder): Implementează interfața Builder și oferă o implementare concretă pentru construirea părților obiectului. Stochează rezultatul intermediar și oferă o metodă pentru obținerea obiectului final.
• Director (Director): Componentă opțională. Definește ordinea în care sunt apelate metodele builder pentru crearea obiectului. Nu cunoaște constructorii concreți.
• Produs (Product): Obiect complex creat de builder.

Aplicații:

• Când procesul de creare a obiectului este complex și include multiple pași opționali.
• Când este necesar să se creeze diferite reprezentări ale aceluiași obiect, folosind același proces de construcție.
• Când constructorul obiectului are mulți parametri.

Exemplu în Go:

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

// Builder - interfața builder-ului
type Builder interface {
	BuildPartA()
	BuildPartB()
	BuildPartC()
	GetProduct() *Product
}

// BuilderConcret - builder concret
type ConcreteBuilder struct {
	product *Product
}

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

func (cb *ConcreteBuilder) BuildPartA() {
	cb.product.PartA = "Parte A construită"
}

func (cb *ConcreteBuilder) BuildPartB() {
	cb.product.PartB = "Parte B construită"
}

func (cb *ConcreteBuilder) BuildPartC() {
	cb.product.PartC = "Parte C construită"
}

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

// Director - director (opțional)
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()
}

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

Avantaje:

• Izolează codul de construcție a obiectului de codul client.
• Permite schimbarea reprezentării interne a produsului fără a modifica codul client.
• Permite construirea pas cu pas a obiectului.
• Simplifică crearea obiectelor cu mulți parametri.

Dezavantaje:

• Crește cantitatea de cod (clase/interfețe) necesară pentru crearea obiectului.
• Poate fi redundant pentru obiecte simple.