Pattern Functional Options

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

Lors de la création de structs avec de nombreux champs de configuration optionnels, les fonctions constructeurs peuvent devenir encombrantes. Le Functional Options Pattern résout cela élégamment en utilisant des fonctions pour configurer les objets.

Considérez une structure de serveur avec plusieurs paramètres optionnels. Au lieu d'un constructeur avec de nombreux paramètres, nous définissons un type d'option et des fonctions qui renvoient des options :

type Server struct {
    host    string
    port    int
    timeout int
}

type Option func(*Server)

func WithPort(port int) Option {
    return func(s *Server) {
        s.port = port
    }
}

func WithTimeout(timeout int) Option {
    return func(s *Server) {
        s.timeout = timeout
    }
}

Le constructeur accepte une liste variadique d'options et applique chacune d'elles :

func NewServer(host string, opts ...Option) *Server {
    s := &Server{
        host:    host,
        port:    8080,    // par défaut
        timeout: 30,      // par défaut
    }
    for _, opt := range opts {
        opt(s)
    }
    return s
}

Désormais, la création de serveurs devient lisible et flexible :

// Utiliser les valeurs par défaut
s1 := NewServer("localhost")

// Personnaliser des options spécifiques
s2 := NewServer("localhost", WithPort(3000), WithTimeout(60))

Ce modèle excelle car les appelants ne spécifient que ce dont ils ont besoin, les valeurs par défaut sont claires et centralisées, et l'ajout de nouvelles options ne casse pas le code existant. Il est largement utilisé dans les bibliothèques Go comme grpc et zap.

Défi

Facile

Construisons une connexion de base de données configurable en utilisant le Functional Options Pattern ! Ce modèle excelle lorsque vous avez de nombreux paramètres optionnels avec des valeurs par défaut judicieuses — exactement ce dont une connexion de base de données a besoin.

Vous organiserez votre code sur deux fichiers :

database.go : Définissez votre type de connexion de base de données et les fonctions d'option.
Créez une structure DBConnection avec ces champs non exportés :
- host (string)
- port (int)
- username (string)
- password (string)
- maxConnections (int)
- timeout (int) - en secondes
Définissez un type Option comme une fonction qui modifie un *DBConnection.

Créez ces fonctions d'option qui retournent une Option :
- WithPort(port int)
- WithCredentials(username, password string)
- WithMaxConnections(max int)
- WithTimeout(seconds int)
Créez un constructeur NewDBConnection(host string, opts ...Option) qui retourne un *DBConnection. Définissez ces valeurs par défaut : port 5432, username "admin", password "secret", maxConnections 10, timeout 30. Appliquez toutes les options fournies après avoir défini les valeurs par défaut.

Ajoutez une méthode ConnectionString() qui retourne les informations de connexion dans ce format :
```
[username]:[password]@[host]:[port] (max:[maxConnections], timeout:[timeout]s)
```
main.go : Construisez des connexions de base de données avec diverses configurations.
Lisez l'hôte, puis lisez un nombre d'options à appliquer. Pour chaque option, lisez le type d'option et sa ou ses valeur(s) :
- port suivi du numéro de port
- credentials suivi du nom d'utilisateur et du mot de passe (deux lignes)
- maxconn suivi du nombre maximum de connexions
- timeout suivi du délai d'attente en secondes
Créez une DBConnection avec les options spécifiées et affichez sa chaîne de connexion.

Les entrées suivantes seront fournies :

Ligne 1 : Nom de l'hôte
Ligne 2 : Nombre d'options
Lignes suivantes : Type d'option et valeur(s)

Par exemple, étant donné :

localhost
0

Votre sortie devrait être :

admin:secret@localhost:5432 (max:10, timeout:30s)

Et étant donné :

db.example.com
2
port
3306
credentials
root
mypassword

Votre sortie devrait être :

root:mypassword@db.example.com:3306 (max:10, timeout:30s)

Et étant donné :

production.server
4
port
5433
credentials
dbuser
securepass123
maxconn
50
timeout
60

Votre sortie devrait être :

dbuser:securepass123@production.server:5433 (max:50, timeout:60s)

Remarquez comment les appelants ne spécifient que les options dont ils ont besoin — les paramètres non spécifiés utilisent des valeurs par défaut judicieuses. C'est toute l'élégance du Functional Options Pattern !

Aide-mémoire

Le Functional Options Pattern (modèle d'options fonctionnelles) offre un moyen élégant de configurer des structures comportant de nombreux champs optionnels en utilisant des fonctions au lieu de longs paramètres de constructeur.

Définissez un type Option comme une fonction qui modifie un pointeur vers votre structure :

type Server struct {
    host    string
    port    int
    timeout int
}

type Option func(*Server)

Créez des fonctions d'option qui retournent des fermetures (closures) Option :

func WithPort(port int) Option {
    return func(s *Server) {
        s.port = port
    }
}

func WithTimeout(timeout int) Option {
    return func(s *Server) {
        s.timeout = timeout
    }
}

Le constructeur accepte une liste variadique d'options, définit les valeurs par défaut, puis applique chaque option :

func NewServer(host string, opts ...Option) *Server {
    s := &Server{
        host:    host,
        port:    8080,    // default
        timeout: 30,      // default
    }
    for _, opt := range opts {
        opt(s)
    }
    return s
}

L'utilisation est propre et flexible — les appelants ne spécifient que ce dont ils ont besoin :

// Use defaults
s1 := NewServer("localhost")

// Customize specific options
s2 := NewServer("localhost", WithPort(3000), WithTimeout(60))

Avantages : les valeurs par défaut sont centralisées, les appelants ne spécifient que ce dont ils ont besoin, et l'ajout de nouvelles options ne casse pas le code existant.

Essayez vous-même

package main

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

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

	// Lire l'hôte
	host, _ := reader.ReadString('\n')
	host = strings.TrimSpace(host)

	// Lire le nombre d'options
	numOptionsStr, _ := reader.ReadString('\n')
	numOptions, _ := strconv.Atoi(strings.TrimSpace(numOptionsStr))

	// Collecter les options
	var opts []Option

	for i := 0; i < numOptions; i++ {
		optionType, _ := reader.ReadString('\n')
		optionType = strings.TrimSpace(optionType)

		switch optionType {
		case "port":
			portStr, _ := reader.ReadString('\n')
			port, _ := strconv.Atoi(strings.TrimSpace(portStr))
			// TODO: Ajouter l'option WithPort à opts
			_ = port // Supprimer cette ligne lors de l'implémentation

		case "credentials":
			username, _ := reader.ReadString('\n')
			username = strings.TrimSpace(username)
			password, _ := reader.ReadString('\n')
			password = strings.TrimSpace(password)
			// TODO: Ajouter l'option WithCredentials à opts
			_, _ = username, password // Supprimer cette ligne lors de l'implémentation

		case "maxconn":
			maxStr, _ := reader.ReadString('\n')
			maxConn, _ := strconv.Atoi(strings.TrimSpace(maxStr))
			// TODO: Ajouter l'option WithMaxConnections à opts
			_ = maxConn // Supprimer cette ligne lors de l'implémentation

		case "timeout":
			timeoutStr, _ := reader.ReadString('\n')
			timeout, _ := strconv.Atoi(strings.TrimSpace(timeoutStr))
			// TODO: Ajouter l'option WithTimeout à opts
			_ = timeout // Supprimer cette ligne lors de l'implémentation
		}
	}

	// TODO: Créer DBConnection en utilisant NewDBConnection avec host et opts
	// TODO: Afficher la chaîne de connexion en utilisant la méthode ConnectionString()

	_ = opts // Supprimer cette ligne lors de l'implémentation
	fmt.Println("TODO: Print connection string here")
}