Wire Go : guide complet avec exemples concrets

Qu'est-ce que Wire et pourquoi l'utiliser ?

Wire est une bibliothèque d'injection de dépendances (Dependency Injection, DI) pour le langage Go, développée par l'équipe de Google. Contrairement à de nombreux autres frameworks DI qui fonctionnent à l'exécution (runtime), Wire utilise la génération de code à la compilation. C'est une différence clé : Wire analyse votre code et génère un fichier wire_gen.go contenant toute la logique de liaison des dépendances. Cette approche élimine les erreurs liées à la réflexion (reflect) et rend le code entièrement typé.

Pourquoi utiliser Wire ?

• Simplification de la configuration : Au lieu de créer manuellement toutes les dépendances dans main.go, Wire le fait automatiquement.
• Tests facilités : Remplacez facilement les implémentations réelles par des mocks pour les tests unitaires.
• Code plus propre : Le code devient plus modulaire et moins couplé (low coupling).
• Sécurité des types : Les erreurs de configuration sont détectées à la compilation, pas à l'exécution.

Wire est idéal pour les grands projets où les dépendances se comptent par dizaines, voire par centaines.

Installation

Wire n'est pas une bibliothèque traditionnelle (un package que vous importez). C'est un outil en ligne de commande (CLI). L'installation se fait via le gestionnaire de packages standard de Go :

go install github.com/google/wire/cmd/wire@latest

Après cette commande, le binaire wire sera disponible dans votre $GOPATH/bin (ou $GOBIN). Assurez-vous que ce répertoire est ajouté à la variable d'environnement PATH.

Vérifiez l'installation :

wire help

Si vous voyez l'aide des commandes, tout est prêt.

Démarrage rapide avec un exemple de code

Créons une application simple qui salue un utilisateur. Nous aurons trois composants : Message, Greeter (celui qui salue) et Event (l'événement).

Étape 1 : Structure du projet

myapp/
├── main.go
├── wire.go
└── wire_gen.go  (sera généré)

Étape 2 : Création des composants (main.go)

package main

import "fmt"

// Message — structure simple contenant un texte.
type Message struct {
    Text string
}

// NewMessage — constructeur pour Message.
func NewMessage(text string) Message {
    return Message{Text: text}
}

// Greeter — structure qui salue avec un Message.
type Greeter struct {
    Message Message
}

// NewGreeter — constructeur pour Greeter.
func NewGreeter(m Message) Greeter {
    return Greeter{Message: m}
}

// Greet — méthode retournant le message de salutation.
func (g Greeter) Greet() Message {
    return g.Message
}

// Event — structure représentant un événement.
type Event struct {
    Greeter Greeter
}

// NewEvent — constructeur pour Event.
func NewEvent(g Greeter) Event {
    return Event{Greeter: g}
}

// Start — méthode lançant l'événement.
func (e Event) Start() {
    msg := e.Greeter.Greet()
    fmt.Println(msg.Text)
}

func main() {
    // Création manuelle des dépendances (sans Wire)
    message := NewMessage("Bonjour, Wire !")
    greeter := NewGreeter(message)
    event := NewEvent(greeter)

    event.Start()
}

Étape 3 : Création du fichier wire.go

Ce fichier est le "fournisseur" pour Wire. Il contient les fonctions d'initialisation (providers) et une fonction qui indique à Wire ce qu'il doit assembler.

//go:build wireinject
// +build wireinject

package main

import "github.com/google/wire"

// InitializeEvent — fonction que Wire utilisera pour générer le code.
// Elle déclare que nous avons besoin d'un Event, et Wire construit le graphe de dépendances.
func InitializeEvent(text string) Event {
    wire.Build(NewEvent, NewGreeter, NewMessage)
    return Event{} // Cette ligne n'est pas exécutée, nécessaire uniquement pour