Introduction aux Design Patterns

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

Les design patterns sont des solutions réutilisables à des problèmes courants qui surviennent dans la conception logicielle. Ce ne sont pas du code que vous copiez directement, mais plutôt des modèles qui vous guident dans la manière de structurer vos types et leurs interactions pour résoudre des problèmes spécifiques.

Les patrons de conception sont généralement regroupés en trois catégories :

Catégorie	Objectif	Exemples
Création	Mécanismes de création d’objets	Singleton, Factory, Builder
Structure	Composition de types en structures plus grandes	Adapter, Decorator, Composite
Comportement	Communication entre les objets	Observer, Strategy, Command

En Go, les patrons de conception sont différents de ceux des langages POO traditionnels.

Sans classes ni héritage, Go met en œuvre des modèles à l’aide d’interfaces, de l’intégration de structures et de la composition. Par exemple, là où Java pourrait utiliser une classe abstraite, Go utilise une interface. Là où C++ pourrait utiliser l’héritage, Go utilise l’intégration.

Apprendre les patterns vous aide à reconnaître les problèmes courants et à communiquer efficacement les solutions avec les autres développeurs. Lorsque quelqu’un mentionne « utilisez le pattern Strategy ici », toute l’équipe comprend l’approche sans longues explications.

Au cours des prochaines leçons, vous implémenterez plusieurs modèles fondamentaux en Go, en commençant par des modèles de création comme Singleton et Factory, puis en passant à des modèles comportementaux comme Observer et Strategy.

Défi

Facile

Construisons un système simple de notifications qui montre comment les patrons de conception aident à organiser le code ! Tu vas créer une structure qui pourra facilement être étendue avec des patrons comme Observer ou Strategy dans les prochaines leçons, mais pour l'instant, concentre-toi sur la mise en place d'interfaces et de types propres qui suivent les bons principes de la POO.

Tu vas organiser ton code sur trois fichiers :

notifier.go : définir l'interface principale et les types de ton système de notifications.
Crée une interface Notifier avec une seule méthode Send(message string) string qui renvoie un message de confirmation.

Implémente deux types de notificateurs concrets :
- EmailNotifier avec un champ Address. Sa méthode Send renvoie Email to [address]: [message]
- SMSNotifier avec un champ PhoneNumber. Sa méthode Send renvoie SMS to [phone]: [message]
dispatcher.go : créer un répartiteur qui fonctionne avec n'importe quel notificateur grâce à l'interface.
Construis une structure NotificationDispatcher qui contient une tranche d'interfaces Notifier. Ajoute ces méthodes :
- AddNotifier(n Notifier) pour enregistrer un notificateur
- Broadcast(message string) []string qui envoie le message à tous les notificateurs enregistrés et renvoie une tranche de toutes les chaînes de confirmation
Crée également un constructeur NewNotificationDispatcher() qui renvoie un répartiteur initialisé.
main.go : configurer les notificateurs et diffuser les messages.
Lis le nombre de notificateurs à créer. Pour chaque notificateur, lis son type (email ou sms) et sa destination (adresse ou numéro de téléphone). Ajoute chacun d'eux à un répartiteur.

Lis ensuite un message à diffuser. Envoie-le à tous les notificateurs et affiche chaque confirmation sur sa propre ligne.

Les entrées suivantes seront fournies :

Ligne 1 : nombre de notificateurs
Pour chaque notificateur : type (email ou sms), puis destination
Dernière ligne : message à diffuser

Par exemple, avec :

3
email
alice@example.com
sms
555-1234
email
bob@example.com
Server maintenance at midnight

Ta sortie doit être :

Email to alice@example.com: Server maintenance at midnight
SMS to 555-1234: Server maintenance at midnight
Email to bob@example.com: Server maintenance at midnight

Et avec :

2
sms
555-9999
sms
555-0000
Meeting canceled

Ta sortie doit être :

SMS to 555-9999: Meeting canceled
SMS to 555-0000: Meeting canceled

Cette structure montre comment les interfaces permettent de créer des conceptions flexibles et extensibles. Le répartiteur ne connaît pas les types spécifiques de notificateurs. Il sait simplement qu'ils peuvent effectuer Send. C'est la base sur laquelle s'appuient des patrons comme Observer et Strategy !

Essayez vous-même

package main

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

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

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

	// Créer un nouveau dispatcher
	dispatcher := NewNotificationDispatcher()

	// Lire chaque notifier et l'ajouter au dispatcher
	for i := 0; i < count; i++ {
		notifierType, _ := reader.ReadString('\n')
		notifierType = strings.TrimSpace(notifierType)

		destination, _ := reader.ReadString('\n')
		destination = strings.TrimSpace(destination)

		// TODO: Créer le notifier approprié selon le type
		// et l'ajouter au dispatcher
		// Hint: Vérifier si notifierType est "email" ou "sms"

	}

	// Lire le message à diffuser
	message, _ := reader.ReadString('\n')
	message = strings.TrimSpace(message)

	// TODO: Diffuser le message et afficher chaque confirmation

}