Parlez du modèle de conception 'Constructeur'.

Le patron de conception "Builder" (Constructeur) est un patron de création qui permet de créer des objets complexes étape par étape. Il sépare le processus de construction d'un objet complexe de sa représentation, de sorte que le même processus de construction peut créer différentes représentations.

Composants principaux:

• Constructeur (Builder): Interface ou classe abstraite définissant les méthodes pour créer des parties d'un objet complexe.
• Constructeur Concret (Concrete Builder): Implémente l'interface du constructeur et fournit une implémentation concrète pour construire les parties de l'objet. Il stocke le résultat intermédiaire et fournit une méthode pour obtenir l'objet final.
• Directeur (Director): Composant optionnel. Définit l'ordre dans lequel les méthodes du constructeur sont appelées pour créer l'objet. Ne connaît pas les constructeurs concrets.
• Produit (Product): Objet complexe créé par le constructeur.

Applications:

• Lorsque le processus de création de l'objet est complexe et inclut plusieurs étapes optionnelles.
• Lorsqu'il est nécessaire de créer différentes représentations d'un même objet en utilisant le même processus de construction.
• Lorsque le constructeur de l'objet a de nombreux paramètres.

Exemple en Go:

// Produit - objet complexe
type Product struct {
	PartA string
	PartB string
	PartC string
}

// Builder - interface du constructeur
type Builder interface {
	BuildPartA()
	BuildPartB()
	BuildPartC()
	GetProduct() *Product
}

// ConcreteBuilder - constructeur concret
type ConcreteBuilder struct {
	product *Product
}

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

func (cb *ConcreteBuilder) BuildPartA() {
	cb.product.PartA = "Partie A construite"
}

func (cb *ConcreteBuilder) BuildPartB() {
	cb.product.PartB = "Partie B construite"
}

func (cb *ConcreteBuilder) BuildPartC() {
	cb.product.PartC = "Partie C construite"
}

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

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

// Utilisation
// concreteBuilder := NewConcreteBuilder()
// director := NewDirector(concreteBuilder)
// director.Construct()
// product := concreteBuilder.GetProduct()
// fmt.Printf("Produit créé: %+v\n", product)

Avantages:

• Isoler le code de construction de l'objet du code client.
• Permet de changer la représentation interne du produit sans modifier le code client.
• Permet de construire l'objet étape par étape.
• Simplifie la création d'objets avec de nombreux paramètres.

Inconvénients:

• Augmente la quantité de code (classes/interfaces) pour créer l'objet.
• Peut être redondant pour des objets simples.