Parlez-moi du patron de conception Builder (Constructeur).

Builder est un patron de création qui permet de créer des objets complexes étape par étape.

Il s'applique lorsque :

• Le processus de création de l'objet est complexe et implique plusieurs étapes.
• Il est nécessaire de créer différentes représentations du même objet.
• Le constructeur de l'objet a beaucoup de paramètres optionnels.

Le pattern se compose des rôles suivants :

• Builder : Interface définissant les étapes de construction de l'objet.
• ConcreteBuilder : Implémentation concrète de Builder qui réalise les étapes de construction et fournit la méthode pour obtenir l'objet fini.
• Product : L'objet complexe qui est construit.
• Director (optionnel) : Définit l'ordre d'appel des étapes de construction.

Exemple d'implémentation en Golang sans Director :

// Product - objet que nous construisons
type Pizza struct {
	Dough   string
	Sauce   string
	Toppings []string
}

// Builder - interface du constructeur
type PizzaBuilder interface {
	SetDough(dough string) PizzaBuilder
	SetSauce(sauce string) PizzaBuilder
	AddTopping(topping string) PizzaBuilder
	Build() Pizza // Méthode pour obtenir l'objet fini
}

// ConcreteBuilder - implémentation concrète du constructeur
type HawaiianPizzaBuilder struct {
	pizza Pizza
}

func NewHawaiianPizzaBuilder() *HawaiianPizzaBuilder {
	return &HawaiianPizzaBuilder{}
}

func (b *HawaiianPizzaBuilder) SetDough(dough string) PizzaBuilder {
	b.pizza.Dough = dough
	return b
}

func (b *HawaiianPizzaBuilder) SetSauce(sauce string) PizzaBuilder {
	b.pizza.Sauce = sauce
	return b
}

func (b *HawaiianPizzaBuilder) AddTopping(topping string) PizzaBuilder {
	b.pizza.Toppings = append(b.pizza.Toppings, topping)
	return b
}

func (b *HawaiianPizzaBuilder) Build() Pizza {
	return b.pizza
}

// Exemple d'utilisation
func main() {
	// Création du constructeur pour pizza hawaïenne
	builder := NewHawaiianPizzaBuilder()

	// Construction de la pizza étape par étape
	pizza := builder.
		SetDough("fin").
		SetSauce("tomate").
		AddTopping("ananas").
		AddTopping("jambon").
		Build() // Obtenir la pizza prête

	fmt.Printf("Pizza créée : %+v\n", pizza)
}

Avantages du pattern :

• Permet d'isoler le processus de construction d'un objet complexe de sa représentation.
• Fournit une construction étape par étape de l'objet.
• Facilite la création de différentes vues du même objet.
• Rend le code de création de l'objet plus lisible et maintenable lorsqu'il y a beaucoup de paramètres.

Inconvénients du pattern :

• Augmente le nombre de classes dans le projet.
• Peut être excessif pour des objets simples.