fx pour Go : guide complet avec exemples

Qu'est-ce que cette bibliothèque et pourquoi l'utiliser ?

fx est un framework d'injection de dépendances (DI) puissant pour le langage Go, développé par la société Uber. Il offre une manière élégante de gérer les dépendances dans les applications Go en automatisant la création, la liaison et le cycle de vie des objets.

Dans une application Go traditionnelle, les développeurs se heurtent souvent au problème de "l'enfer des constructeurs" (constructor hell), où la création d'un objet nécessite de transmettre de nombreuses dépendances. Cela entraîne :

• Un code volumineux avec une gestion manuelle des dépendances
• Des difficultés lors des tests
• Des problèmes pour modifier l'architecture de l'application

fx résout ces problèmes en offrant :

• Injection automatique des dépendances — le framework détermine lui-même quels objets sont nécessaires et dans quel ordre les créer
• Gestion du cycle de vie — démarrage et arrêt automatiques des composants
• Modularité — l'application est divisée en modules indépendants
• Testabilité — remplacement facile des dépendances réelles par des objets mock

fx est particulièrement utile pour développer :

• Des microservices
• Des applications web
• Des outils CLI
• Toute application avec une architecture de dépendances complexe

Installation

L'installation de fx se fait de manière standard pour les bibliothèques Go via go get :

go get go.uber.org/fx

Pour mettre à jour vers la dernière version :

go get -u go.uber.org/fx

Après l'installation, importez la bibliothèque dans votre code :

import "go.uber.org/fx"

Il est également recommandé d'installer l'utilitaire fx pour la génération de code (optionnel) :

go install go.uber.org/fx/cmd/fx@latest

Démarrage rapide avec un exemple de code

Examinons un exemple simple d'utilisation de fx pour créer un serveur HTTP :

package main

import (
    "context"
    "fmt"
    "net/http"
    "go.uber.org/fx"
)

// NewHandler crée un gestionnaire HTTP
func NewHandler() http.Handler {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Bonjour, fx !")
    })
    return mux
}

// NewServer crée un serveur HTTP
func NewServer(handler http.Handler) *http.Server {
    return &http.Server{
        Addr:    ":8080",
        Handler: handler,
    }
}

// StartServer démarre le serveur
func StartServer(lc fx.Lifecycle, server *http.Server) {
    lc.Append(fx.Hook{
        OnStart: func(ctx context.Context) error {
            go server.ListenAndServe()
            fmt.Println("Serveur démarré sur le port :8080")
            return nil
        },
        OnStop: func(ctx context.Context) error {
            return server.Shutdown(ctx)
        },
    })
}

func main() {
    app := fx.New(
        fx.Provide(NewHandler),
        fx.Provide(NewServer),
        fx.Invoke(StartServer),
    )
    app.Run()
}

Cet exemple illustre les mécanismes de base de fx :

• fx.Provide — enregistre les constructeurs
• fx.Invoke — exécute les fonctions qui utilisent les dépendances
• fx.Lifecycle — gère le cycle de vie des composants

Méthodes/Fonctions principales

1. fx.New

Fonction : Crée une nouvelle application fx qui gère les dépendances. C'est le point d'entrée principal du framework.

Paramètres :

• options ...Option — fonction variadique acceptant un ou plusieurs paramètres de type Option (fx.Provide, fx.Invoke, fx.Module, etc.)

Exemple de code fonctionnel :

package main

import (
    "go.uber.org/fx"
)

type Config struct {
    Port int
}

func NewConfig() *Config {
    retur