Le modèle de conception Builder est utilisé pour construire des objets complexes de manière incrémentielle, permettant la création de différentes représentations d'un objet en utilisant le même processus de construction. Dans cet article, nous explorerons comment implémenter le modèle Builder dans Golang, comprendrons ses avantages et analyserons un exemple pratique d'utilisation.

Qu'est-ce que le Constructeur ?

Le modèle Builder sépare la construction d'un objet complexe de sa représentation, permettant au même processus de construction de créer différentes représentations. Ceci est particulièrement utile lorsqu'un objet doit être créé en plusieurs étapes ou avec plusieurs configurations possibles.

Avantages du constructeur

• Séparation de la construction et de la représentation : Permet de séparer la construction d'un objet de sa représentation finale.
• Construction incrémentielle : permet la construction d'objets complexes de manière incrémentielle et étape par étape.
• Réutilisation du code : facilite la réutilisation du code en définissant des étapes de construction communes qui peuvent être combinées de plusieurs manières.

Implémentation d'un constructeur

Pour implémenter notre Builder, imaginons un objet complexe où il faudra initialiser plusieurs champs et même d'autres objets regroupés. Que diriez-vous d'une maison ? Où nous aurons deux types de construction, une conventionnelle où seront utilisés du béton et des briques, et une seconde en bois.

1 - Définir la structure

Tout d'abord, nous devons définir la structure de l'objet que nous voulons construire. Comme dit précédemment, nous allons construire une maison. À l’intérieur de cette Struct, nous placerons ce qui est nécessaire pour en créer un.

// house.go

package main

type House struct {
    Foundation string
    Structure  string
    Roof       string
    Interior   string
}

2 - Définir l'interface du constructeur

Toujours dans le même fichier, nous définirons notre interface Builder qui précise les méthodes nécessaires à la construction des différentes parties de la Maison.

//house.go

package main

type House struct {
    Foundation string
    Structure  string
    Roof       string
    Interior   string
}

type HouseBuilder interface {
    SetFoundation()
    SetStructure()
    SetRoof()
    SetInterior()
    GetHouse() House
}

3 – Mettre en œuvre concrètement le Builder

Créons deux nouveaux fichiers, ConcreteHouse et WoodHouse. Il s'agira de l'implémentation d'une classe concrète qui suit l'interface HouseBuilder.

//concreteHouse.go

package main

type ConcreteHouseBuilder struct {
    house House
}

func (b *ConcreteHouseBuilder) SetFoundation() {
    b.house.Foundation = "Concrete, brick, and stone"
}

func (b *ConcreteHouseBuilder) SetStructure() {
    b.house.Structure = "Wood and brick"
}

func (b *ConcreteHouseBuilder) SetRoof() {
    b.house.Roof = "Concrete and reinforced steel"
}

func (b *ConcreteHouseBuilder) SetInterior() {
    b.house.Interior = "Gypsum board, plywood, and paint"
}

func (b *ConcreteHouseBuilder) GetHouse() House {
    return b.house
}

//woodHouse.go

package main

type WoodHouseBuilder struct {
    house House
}

func (b *WoodHouseBuilder) SetFoundation() {
    b.house.Foundation = "Wooden piles"
}

func (b *WoodHouseBuilder) SetStructure() {
    b.house.Structure = "Wooden frame"
}

func (b *WoodHouseBuilder) SetRoof() {
    b.house.Roof = "Wooden shingles"
}

func (b *WoodHouseBuilder) SetInterior() {
    b.house.Interior = "Wooden panels and paint"
}

func (b *WoodHouseBuilder) GetHouse() House {
    return b.house
}

4 - Définir le réalisateur

Le Directeur est une classe qui gère la construction d'un objet, en s'assurant que les étapes de construction sont appelées dans le bon ordre. Il ne sait rien des détails des implémentations spécifiques de Builder, il appelle simplement les méthodes Builder dans une séquence logique pour créer le produit final.

//director.go

package main

type Director struct {
    builder HouseBuilder
}

func (d *Director) Build() {
    d.builder.SetFoundation()
    d.builder.SetStructure()
    d.builder.SetRoof()
    d.builder.SetInterior()
}

func (d *Director) SetBuilder(b HouseBuilder) {
    d.builder = b
}

5 - Utiliser le constructeur

Enfin, nous utiliserons le directeur et les constructeurs en béton pour construire différents types de maisons.

//main.go

package main

import (
    "fmt"
)

func main() {
    cb := &builder.ConcreteHouseBuilder{}
    director := builder.Director{Builder: cb}

    director.Build()
    concreteHouse := cb.GetHouse()

    fmt.Println("Concrete House")
    fmt.Println("Foundation:", concreteHouse.Foundation)
    fmt.Println("Structure:", concreteHouse.Structure)
    fmt.Println("Roof:", concreteHouse.Roof)
    fmt.Println("Interior:", concreteHouse.Interior)
    fmt.Println("-------------------------------------------")

    wb := &builder.WoodHouseBuilder{}
    director.SetBuilder(wb)

    director.Build()
    woodHouse := wb.GetHouse()

    fmt.Println("Wood House")
    fmt.Println("Foundation:", woodHouse.Foundation)
    fmt.Println("Structure:", woodHouse.Structure)
    fmt.Println("Roof:", woodHouse.Roof)
    fmt.Println("Interior:", woodHouse.Interior)
}

En bref

1. Struct House : représente le produit final que nous construisons.
2. Interface HouseBuilder : Définit les méthodes de construction des différentes parties de la maison.
3. Implémentations de béton (ConcreteHouseBuilder et WoodHouseBuilder) : implémentez l'interface HouseBuilder et définissez des étapes de construction spécifiques.
4. Directeur : Gère le processus de construction, en s'assurant que les étapes sont appelées dans le bon ordre.
5. Fonction principale : démontre l'utilisation du modèle Builder pour construire différents types de maisons, en appelant le directeur pour gérer le processus et obtenir le produit final.

Conclusion

Le modèle Builder est un outil permettant de créer des objets complexes de manière incrémentielle et flexible. Chez Golang, la mise en œuvre de ce modèle est directe et efficace, permettant la création de systèmes modulaires et faciles à entretenir. En utilisant des interfaces et des classes concrètes, nous pouvons centraliser la logique de construction et simplifier l'évolution du code à mesure que de nouvelles exigences émergent.