Pattern des options fonctionnelles

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 comportant de nombreux champs de configuration facultatifs, les fonctions constructor peuvent devenir difficiles à gérer. Le Functional Options Pattern résout ce problème avec élégance en utilisant des fonctions pour configurer les objets.

Considérons une structure de serveur avec plusieurs paramètres facultatifs. 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
}

La création de serveurs devient désormais 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 est particulièrement efficace, car les appelants spécifient uniquement ce dont ils ont besoin, les valeurs par défaut sont clairement définies en un seul endroit et l’ajout de nouvelles options ne casse pas le code existant. Il est largement utilisé dans des bibliothèques Go telles que grpc et zap.

Défi

Facile

Construisons une connexion à une base de données configurable à l’aide du modèle des options fonctionnelles ! Ce modèle est particulièrement utile lorsque vous avez de nombreux paramètres facultatifs avec des valeurs par défaut pertinentes, exactement ce dont une connexion à une base de données a besoin.

Vous organiserez votre code sur deux fichiers :

database.go : définissez votre type de connexion à la base de données et les fonctions d’option.
Créez une structure DBConnection avec ces champs non exportés :
- host (chaîne de caractères)
- port (entier)
- username (chaîne de caractères)
- password (chaîne de caractères)
- maxConnections (entier)
- timeout (entier) - en secondes
Définissez un type Option comme une fonction qui modifie un *DBConnection.

Créez ces fonctions d’option qui renvoient 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 renvoie 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 renvoie les informations de connexion dans ce format :
```
[username]:[password]@[host]:[port] (max:[maxConnections], timeout:[timeout]s)
```
main.go : construisez des connexions à la base de données avec différentes configurations.
Lisez l’hôte, puis lisez un nombre d’options à appliquer. Pour chaque option, lisez son type et sa ou ses valeurs :
- port suivi du numéro de port
- credentials suivi du nom d’utilisateur et du mot de passe (deux lignes)
- maxconn suivi du nombre maximal de connexions
- timeout suivi du délai d’expiration 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 et valeur(s) de l’option

Par exemple, avec :

localhost
0

Votre sortie doit être :

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

Et avec :

db.example.com
2
port
3306
credentials
root
mypassword

Votre sortie doit être :

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

Et avec :

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

Votre sortie doit être :

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

Remarquez que les appelants spécifient uniquement les options dont ils ont besoin : les paramètres non spécifiés utilisent des valeurs par défaut pertinentes. C’est toute l’élégance du modèle des options fonctionnelles !

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")
}