L’interface comme contrat

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

Considérer les interfaces comme des contrats vous aide à concevoir de meilleurs programmes Go. Lorsqu’une fonction accepte un type d’interface, elle dit : « Peu m’importe le type concret que vous me fournissez, tant qu’il respecte ce contrat. »

Cette réflexion fondée sur les contrats vous permet d’écrire des fonctions qui se concentrent sur le comportement plutôt que sur des types spécifiques. Considérez une fonction qui doit traiter des données provenant de diverses sources :

type DataSource interface {
    FetchData() string
}

func ProcessData(src DataSource) {
    data := src.FetchData()
    fmt.Println("Processing:", data)
}

La fonction ProcessData ne sait pas et ne se soucie pas de recevoir une connexion à une base de données, un client API ou un lecteur de fichier. Elle exige seulement que l’entrée puisse appeler FetchData(). Tout type respectant ce contrat fonctionne.

type Database struct{ ConnectionString string }
func (d Database) FetchData() string { return "data from DB" }

type APIClient struct{ Endpoint string }
func (a APIClient) FetchData() string { return "data from API" }

func main() {
    db := Database{ConnectionString: "localhost"}
    api := APIClient{Endpoint: "https://api.example.com"}
    
    ProcessData(db)   // Ça marche !
    ProcessData(api)  // Ça marche aussi !
}

Cette approche fondée sur un contrat rend également votre code plus facile à tester. Lors des tests, vous pouvez créer un type simulé qui respecte l’interface sans avoir besoin de véritables bases de données ni de connexions réseau. La fonction testée ne fait pas la différence, car le contrat est respecté.

Défi

Facile

Construisons un système de notification qui montre comment les interfaces servent de contrats. Vous allez créer une interface Notifier qui définit ce que signifie envoyer une notification, puis implémenter plusieurs canaux de notification qui respectent tous ce contrat.

Vous allez organiser votre code sur deux fichiers :

notifiers.go : définissez une interface Notifier avec une seule méthode Notify(message string) string. Créez ensuite trois structures différentes qui respectent ce contrat :
- ConsoleNotifier avec un champ Prefix
- FileNotifier avec un champ Filename
- WebhookNotifier avec un champ URL
Chaque structure doit implémenter la méthode Notify afin de renvoyer une chaîne décrivant comment la notification serait envoyée.
main.go : créez une fonction appelée BroadcastAlert qui accepte une tranche de valeurs Notifier et une chaîne de message. Cette fonction doit appeler Notify sur chaque notificateur et afficher les résultats. Lisez la configuration depuis l’entrée, créez les trois types de notificateurs et diffusez une alerte à travers chacun d’eux.

Les entrées suivantes seront fournies :

Ligne 1 : préfixe de la console
Ligne 2 : nom du fichier
Ligne 3 : URL du webhook
Ligne 4 : message d’alerte

Vos méthodes Notify doivent renvoyer des chaînes dans les formats suivants :

ConsoleNotifier : [Prefix] [message]
FileNotifier : Writing to [Filename]: [message]
WebhookNotifier : POST [URL]: [message]

Par exemple, pour les valeurs ALERT:, log.txt, https://hooks.example.com et Server down!, votre sortie doit être :

ALERT: Server down!
Writing to log.txt: Server down!
POST https://hooks.example.com: Server down!

L’intérêt de cette conception est que votre fonction BroadcastAlert ne connaît pas les types spécifiques de notificateurs et ne s’en préoccupe pas. Elle exige seulement que chacun respecte le contrat Notifier. Vous pourriez ajouter ultérieurement un SlackNotifier ou un EmailNotifier sans modifier la fonction de diffusion.

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
)

// BroadcastAlert envoie un message via tous les notifiers
// TODO: Implémentez cette fonction pour :
// - Accepter une slice de valeurs Notifier et une chaîne message
// - Appeler Notify sur chaque notifier et afficher les résultats
func BroadcastAlert(notifiers []Notifier, message string) {
	// TODO: Parcourir les notifiers et afficher chaque résultat de notification
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Lire le préfixe de la console
	scanner.Scan()
	prefix := scanner.Text()
	
	// Lire le nom de fichier
	scanner.Scan()
	filename := scanner.Text()
	
	// Lire l'URL du webhook
	scanner.Scan()
	url := scanner.Text()
	
	// Lire le message d'alerte
	scanner.Scan()
	message := scanner.Text()
	
	// TODO: Créer des instances des trois types de notifiers
	// - ConsoleNotifier avec le préfixe
	// - FileNotifier avec le nom de fichier
	// - WebhookNotifier avec l'URL
	
	// TODO: Créer une slice de Notifier contenant les trois notifiers
	
	// TODO: Appeler BroadcastAlert avec les notifiers et le message
	
	_ = prefix
	_ = filename
	_ = url
	_ = message
	fmt.Println("TODO: Implement the solution")
}