Pattern Singleton

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 86 sur 107.

Le pattern Singleton garantit qu’un type ne possède qu’une seule instance dans l’ensemble de votre programme et fournit un point d’accès global à celle-ci. Cela est utile pour les ressources partagées comme les gestionnaires de configuration, les connexions à une base de données ou les loggers.

En Go, nous implémentons Singleton à l’aide d’une variable au niveau du package combinée à sync.Once afin de garantir une initialisation sûre vis-à-vis des threads :

package config

import "sync"

type Config struct {
    DatabaseURL string
    MaxRetries  int
}

var (
    instance *Config
    once     sync.Once
)

func GetInstance() *Config {
    once.Do(func() {
        instance = &Config{
            DatabaseURL: "localhost:5432",
            MaxRetries:  3,
        }
    })
    return instance
}

sync.Once garantit que la fonction d’initialisation s’exécute exactement une fois, même lorsque plusieurs goroutines appellent GetInstance() simultanément. Chaque appel ultérieur renvoie la même instance sans réexécuter le code d’initialisation.

cfg1 := config.GetInstance()
cfg2 := config.GetInstance()
// cfg1 et cfg2 pointent vers la même instance

Utilisez Singleton avec parcimonie. Bien que pratique, il introduit un état global qui peut compliquer les tests et masquer les dépendances. Déterminez si l’injection de dépendances pourrait constituer une meilleure alternative pour votre cas d’utilisation.

Défi

Facile

Construisons un singleton Logger qui garantit qu’une seule instance de logger existe dans toute votre application ! C’est un cas d’utilisation classique du modèle Singleton. Vous voulez que toutes les parties de votre programme partagent la même configuration et le même état du logger.

Vous allez organiser votre code sur deux fichiers :

logger.go : implémentez votre logger Singleton thread-safe.
Créez une structure Logger avec deux champs : Prefix (string) pour les préfixes des messages de log, et MessageCount (int) pour suivre le nombre de messages enregistrés.

Utilisez des variables au niveau du package avec sync.Once pour garantir qu’une seule instance est créée. Implémentez une fonction GetLogger() qui initialise le logger avec le préfixe par défaut "[LOG]" et renvoie l’instance singleton.

Ajoutez ces méthodes à votre Logger :
- SetPrefix(prefix string) - modifie le préfixe du logger
- Log(message string) string - incrémente le compteur de messages et renvoie une chaîne formatée : [prefix] #[count]: [message]
- GetCount() int - renvoie le nombre total de messages enregistrés
main.go : démontrez que plusieurs appels à GetLogger() renvoient la même instance.
Lisez une nouvelle valeur de préfixe, puis lisez un nombre de messages suivi de chaque message à enregistrer.

Récupérez l’instance du logger, définissez le préfixe personnalisé, puis enregistrez chaque message et affichez le résultat. Après avoir enregistré tous les messages, récupérez à nouveau l’instance du logger (pour prouver qu’il s’agit de la même) et affichez le nombre total de messages.

Les entrées suivantes seront fournies :

Ligne 1 : préfixe personnalisé à définir
Ligne 2 : nombre de messages
Lignes suivantes : chaque message à enregistrer

Par exemple, avec :

[APP]
3
Server started
User connected
Request processed

Votre sortie doit être :

[APP] #1: Server started
[APP] #2: User connected
[APP] #3: Request processed
Total messages logged: 3

Et avec :

[DEBUG]
2
Initializing cache
Cache ready

Votre sortie doit être :

[DEBUG] #1: Initializing cache
[DEBUG] #2: Cache ready
Total messages logged: 2

Et avec :

[ERROR]
1
Connection failed

Votre sortie doit être :

[ERROR] #1: Connection failed
Total messages logged: 1

L’idée essentielle est que, quel que soit le nombre de fois où vous appelez GetLogger(), vous obtenez toujours la même instance avec son état partagé. Le nombre de messages persiste, car il n’existe qu’un seul Logger !

Essayez vous-même

package main

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

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

	// Lire le préfixe personnalisé
	prefix, _ := reader.ReadString('\n')
	prefix = strings.TrimSpace(prefix)

	// Lire le nombre de messages
	countStr, _ := reader.ReadString('\n')
	countStr = strings.TrimSpace(countStr)
	count, _ := strconv.Atoi(countStr)

	// Lire chaque message
	messages := make([]string, count)
	for i := 0; i < count; i++ {
		msg, _ := reader.ReadString('\n')
		messages[i] = strings.TrimSpace(msg)
	}

	// TODO: Obtenir l'instance du logger en utilisant GetLogger()

	// TODO: Définir le préfixe personnalisé en utilisant SetPrefix()

	// TODO: Logger chaque message et afficher le résultat

	// TODO: Obtenir à nouveau l'instance du logger (pour prouver que c'est la même)
	// and print the total message count in format: "Total messages logged: X"
}