Pattern Builder en Go

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 80 sur 107.

Le Builder Pattern sépare la construction d'un objet complexe de sa représentation. Contrairement au pattern Functional Options, le Builder utilise une struct builder dédiée avec des méthodes qui configurent l'objet étape par étape.

Voici comment implémenter un builder pour une requête HTTP :

type Request struct {
    method  string
    url     string
    headers map[string]string
    body    string
}

type RequestBuilder struct {
    request *Request
}

func NewRequestBuilder() *RequestBuilder {
    return &RequestBuilder{
        request: &Request{
            headers: make(map[string]string),
        },
    }
}

func (b *RequestBuilder) Method(m string) *RequestBuilder {
    b.request.method = m
    return b
}

func (b *RequestBuilder) URL(u string) *RequestBuilder {
    b.request.url = u
    return b
}

func (b *RequestBuilder) Header(key, value string) *RequestBuilder {
    b.request.headers[key] = value
    return b
}

func (b *RequestBuilder) Build() *Request {
    return b.request
}

Chaque méthode retourne le pointeur du builder, permettant ainsi le chaînage de méthodes. La méthode Build() finalise et retourne l'objet construit :

req := NewRequestBuilder().
    Method("POST").
    URL("https://api.example.com").
    Header("Content-Type", "application/json").
    Build()

Le pattern Builder excelle lorsque les objets nécessitent plusieurs étapes de configuration ou lorsque vous souhaitez imposer une séquence de construction spécifique. Il est particulièrement utile pour créer des objets immuables ou lorsque le processus de construction lui-même nécessite une validation.

Défi

Facile

Construisons un compositeur de messages électroniques en utilisant le Builder Pattern ! Les messages électroniques comportent de nombreux composants optionnels — destinataires, CC, objet, corps, pièces jointes — ce qui en fait un candidat idéal pour une construction étape par étape avec chaînage de méthodes.

Vous organiserez votre code sur deux fichiers :

email.go : Définissez votre structure d'email et son builder.
Créez une structure Email avec ces champs :
- from (string)
- to (slice de strings)
- cc (slice de strings)
- subject (string)
- body (string)
Créez une structure EmailBuilder qui contient un pointeur vers un Email en cours de construction. Implémentez NewEmailBuilder() qui retourne un nouveau builder avec un Email initialisé (slices vides pour to et cc).

Ajoutez ces méthodes de builder, chacune retournant *EmailBuilder pour le chaînage :
- From(address string) - définit l'expéditeur
- To(address string) - ajoute un destinataire à la slice to
- CC(address string) - ajoute un destinataire à la slice cc
- Subject(subject string) - définit l'objet
- Body(body string) - définit le corps de l'email
Ajoutez une méthode Build() qui retourne l'*Email construit.

Enfin, ajoutez une méthode Summary() sur Email qui retourne une chaîne de caractères dans ce format :
```
From: [from]
To: [comma-separated to addresses]
CC: [comma-separated cc addresses or "none"]
Subject: [subject]
Body: [body]
```
main.go : Construisez et affichez des messages électroniques à l'aide du builder.
Lisez l'adresse de l'expéditeur, puis lisez le nombre de destinataires et chaque adresse de destinataire. Ensuite, lisez le nombre de destinataires en CC et chaque adresse en CC. Enfin, lisez l'objet et le corps.

Utilisez l'EmailBuilder avec le chaînage de méthodes pour construire l'email, puis affichez son résumé.

Les entrées suivantes seront fournies :

Ligne 1 : Adresse de l'expéditeur
Ligne 2 : Nombre de destinataires
Lignes suivantes : Chaque adresse de destinataire
Ligne suivante : Nombre de destinataires en CC
Lignes suivantes : Chaque adresse en CC
Ligne suivante : Objet
Dernière ligne : Corps

Par exemple, étant donné :

alice@company.com
2
bob@company.com
carol@company.com
1
manager@company.com
Weekly Report
Please find the weekly report attached.

Votre sortie devrait être :

From: alice@company.com
To: bob@company.com, carol@company.com
CC: manager@company.com
Subject: Weekly Report
Body: Please find the weekly report attached.

Et étant donné :

support@service.com
1
customer@email.com
0
Your Ticket Update
Your support ticket has been resolved.

Votre sortie devrait être :

From: support@service.com
To: customer@email.com
CC: none
Subject: Your Ticket Update
Body: Your support ticket has been resolved.

Remarquez comment le builder vous permet d'ajouter plusieurs destinataires un par un via des appels répétés à To(), et comment le pattern maintient le processus de construction propre et lisible même avec de nombreux champs optionnels.

Aide-mémoire

Le Builder Pattern (ou patron de conception Constructeur) sépare la construction d'un objet complexe de sa représentation en utilisant une structure de constructeur dédiée avec des méthodes qui configurent l'objet étape par étape.

Structure de base :

type Request struct {
    method  string
    url     string
    headers map[string]string
    body    string
}

type RequestBuilder struct {
    request *Request
}

func NewRequestBuilder() *RequestBuilder {
    return &RequestBuilder{
        request: &Request{
            headers: make(map[string]string),
        },
    }
}

Les méthodes du constructeur retournent le pointeur du constructeur pour permettre le chaînage de méthodes :

func (b *RequestBuilder) Method(m string) *RequestBuilder {
    b.request.method = m
    return b
}

func (b *RequestBuilder) URL(u string) *RequestBuilder {
    b.request.url = u
    return b
}

func (b *RequestBuilder) Header(key, value string) *RequestBuilder {
    b.request.headers[key] = value
    return b
}

La méthode Build() finalise et retourne l'objet construit :

func (b *RequestBuilder) Build() *Request {
    return b.request
}

Utilisation avec le chaînage de méthodes :

req := NewRequestBuilder().
    Method("POST").
    URL("https://api.example.com").
    Header("Content-Type", "application/json").
    Build()

Le pattern Builder est utile lorsque les objets nécessitent plusieurs étapes de configuration, lors de l'imposition d'une séquence de construction spécifique, pour la création d'objets immuables, ou lorsque le processus de construction nécessite une validation.

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Lire l'adresse de l'expéditeur
	from, _ := reader.ReadString('\n')
	from = strings.TrimSpace(from)

	// Lire le nombre de destinataires
	toCountStr, _ := reader.ReadString('\n')
	toCount, _ := strconv.Atoi(strings.TrimSpace(toCountStr))

	// Lire chaque adresse de destinataire
	toAddresses := make([]string, toCount)
	for i := 0; i < toCount; i++ {
		addr, _ := reader.ReadString('\n')
		toAddresses[i] = strings.TrimSpace(addr)
	}

	// Lire le nombre de destinataires en CC
	ccCountStr, _ := reader.ReadString('\n')
	ccCount, _ := strconv.Atoi(strings.TrimSpace(ccCountStr))

	// Lire chaque adresse en CC
	ccAddresses := make([]string, ccCount)
	for i := 0; i < ccCount; i++ {
		addr, _ := reader.ReadString('\n')
		ccAddresses[i] = strings.TrimSpace(addr)
	}

	// Lire le sujet
	subject, _ := reader.ReadString('\n')
	subject = strings.TrimSpace(subject)

	// Lire le corps du message
	body, _ := reader.ReadString('\n')
	body = strings.TrimSpace(body)

	// TODO: Utiliser le EmailBuilder avec le chaînage de méthodes pour construire l'e-mail
	// Commencer par NewEmailBuilder(), puis chaîner From(), To(), CC(), Subject(), Body()
	// Enfin, appeler Build() pour obtenir l'Email

	// TODO: Afficher le résumé de l'e-mail en utilisant la méthode Summary()
}