Aller aux modèles de conception #Builder

Constructeur

Le Builder Pattern est un modèle de conception créationnel qui fournit une solution flexible pour construire des objets complexes étape par étape. Il permet de créer différentes représentations d'un objet en utilisant le même processus de construction.

Énoncé du problème

• Lorsque la création d'un objet implique plusieurs étapes ou paramètres, la gestion du processus de construction peut devenir fastidieuse.
• Vous voulez éviter un problème de « constructeur télescopique » (où les constructeurs prennent de nombreux paramètres) et vous assurer que votre objet est immuable après la création.

Avantages du modèle Builder

• Flexibilité : construisez facilement différentes représentations d'un objet.
• Lisibilité : le chaînage des méthodes rend le processus de construction clair et concis.
• Encapsulation : la logique de construction est encapsulée dans le constructeur, la séparant du code client.

Exemple concret

Envisagez de construire un ordinateur. Un ordinateur peut avoir divers composants comme le processeur, la RAM, le stockage, etc.

Au lieu d'exiger tous ces paramètres dans un constructeur, le modèle de constructeur vous permet de définir chaque composant étape par étape.

Mise en œuvre

package main

import "fmt"

// Product
type Computer struct {
    CPU     string
    RAM     string
    Storage string
    OS      string
}

// Builder Interface
type ComputerBuilder interface {
    SetCPU(cpu string) ComputerBuilder
    SetRAM(ram string) ComputerBuilder
    SetStorage(storage string) ComputerBuilder
    SetOS(os string) ComputerBuilder
    Build() *Computer
}

// Concrete Builder
type PCBuilder struct {
    computer *Computer
}

func NewPCBuilder() *PCBuilder {
    return &PCBuilder{&Computer{}}
}

func (b *PCBuilder) SetCPU(cpu string) ComputerBuilder {
    b.computer.CPU = cpu
    return b
}

func (b *PCBuilder) SetRAM(ram string) ComputerBuilder {
    b.computer.RAM = ram
    return b
}

func (b *PCBuilder) SetStorage(storage string) ComputerBuilder {
    b.computer.Storage = storage
    return b
}

func (b *PCBuilder) SetOS(os string) ComputerBuilder {
    b.computer.OS = os
    return b
}

func (b *PCBuilder) Build() *Computer {
    return b.computer
}

// Client Code
func main() {
    builder := NewPCBuilder()

    computer := builder.
        SetCPU("Intel i7").
        SetRAM("16GB").
        SetStorage("1TB SSD").
        SetOS("Windows 7").
        Build()

    fmt.Printf("Computer built: %+v\n", computer)
}

Produit (Ordinateur) : Représente l'objet complexe qui sera construit avec divers attributs.

Interface Builder (ComputerBuilder) : définit les méthodes de configuration de chaque composant du produit.

Concrete Builder (PCBuilder) : implémente l'interface du constructeur.

• Fournit des méthodes pour définir le processeur, la RAM, le stockage et le système d'exploitation, renvoyant le constructeur lui-même pour le chaînage des méthodes.
• La méthode Build() renvoie l'objet Computer final.

Code client : crée une nouvelle instance de générateur.

• Configure l'ordinateur étape par étape en utilisant le chaînage de méthodes.
• Appelle Build() pour récupérer le produit final.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!