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 donnez, tant qu'il remplit ce contrat. »

Cette réflexion basé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 savoir si elle reçoit une connexion de base de données, un client API ou un lecteur de fichiers. Elle exige seulement que l'entrée puisse 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)   // Fonctionne !
    ProcessData(api)  // Fonctionne également !
}

Cette approche par contrat rend également votre code plus facile à tester. Pendant les tests, vous pouvez créer un type simulé (mock) qui satisfait l'interface sans avoir besoin de bases de données ou de connexions réseau réelles. La fonction testée ne voit pas la différence car le contrat est rempli.

Défi

Facile

Construisons un système de notification qui démontre comment les interfaces agissent comme des 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 organiserez votre code sur deux fichiers :

notifiers.go : Définissez une interface Notifier avec une seule méthode Notify(message string) string. Ensuite, créez trois structures différentes qui satisfont 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 pour renvoyer une chaîne de caractères décrivant comment la notification serait envoyée.
main.go : Créez une fonction appelée BroadcastAlert qui accepte une tranche (slice) de valeurs Notifier et une chaîne de caractères pour le message. Cette fonction doit appeler Notify sur chaque notificateur et afficher les résultats. Lisez la configuration depuis l'entrée standard, 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 de caractères selon ces formats :

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

Par exemple, avec ALERT:, log.txt, https://hooks.example.com, et Server down!, votre sortie devrait être :

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

La puissance de cette conception réside dans le fait que votre fonction BroadcastAlert ne connaît pas et ne se soucie pas des types de notificateurs spécifiques — elle exige seulement que chacun remplisse le contrat Notifier. Vous pourriez ajouter un SlackNotifier ou un EmailNotifier plus tard sans modifier du tout la fonction de diffusion.

Aide-mémoire

Les interfaces en Go agissent comme des contrats qui définissent le comportement requis sans spécifier de types concrets. Lorsqu'une fonction accepte un type d'interface, n'importe quel type implémentant les méthodes de l'interface peut être utilisé.

Définissez une interface en spécifiant les signatures de méthode :

type DataSource interface {
    FetchData() string
}

Les fonctions acceptant des interfaces fonctionnent avec n'importe quel type qui satisfait le contrat :

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

Plusieurs types peuvent implémenter la même interface :

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)   // Works!
    ProcessData(api)  // Also works!
}

Cette approche basée sur les contrats permet :

Des fonctions qui se concentrent sur le comportement plutôt que sur des types spécifiques
Une meilleure testabilité grâce aux implémentations fictives (mocks)
Une extensibilité sans modifier le code existant

Essayez vous-même

package main

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

// BroadcastAlert envoie un message via tous les notifiers
// TODO: Implémenter cette fonction pour :
// - Accepter un 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 du 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 notifier
	// - ConsoleNotifier avec le prefix
	// - FileNotifier avec le filename
	// - WebhookNotifier avec l'url
	
	// TODO: Créer un slice de Notifier contenant les trois notifiers
	
	// TODO: Appeler BroadcastAlert avec les notifiers et message
	
	_ = prefix
	_ = filename
	_ = url
	_ = message
	fmt.Println("TODO: Implement the solution")
}