Technical Tutorials

Depuis l'introduction des génériques dans Go 1.18, le langage a gagné une flexibilité sans précédent sans sacrifier sa philosophie centrale de simplicité et de performance. Pour les développeurs intermédiaires et avancés, utiliser les génériques pour abstraire le code boilerplate courant—comme effectuer des requêtes HTTP ou implémenter le modèle de dépôt—n'est plus une simple astuce, mais une meilleure pratique pour construire des microservices évolutifs et maintenables.

Dans ce guide, nous explorerons comment créer une utilitaire de client HTTP générique et appliquer le modèle de dépôt en utilisant les paramètres de type de Go. Cette approche réduit considérablement la duplication de code dans votre projet tout en maintenant une sécurité de type stricte.

Construire un client HTTP générique

Traditionnellement, effectuer une requête HTTP en Go implique de configurer le client, de créer la requête, de gérer le contexte et de désérialiser manuellement la réponse JSON dans une structure. Si vous avez plusieurs points de terminaison, cette logique est souvent répétée. En introduisant une fonction générique, nous pouvons abstraire l'étape de décodage.

Considérez l'implémentation suivante. Nous définissons une fonction DoRequest qui accepte un type générique T. Cela permet au compilateur de s'assurer que le corps de la réponse est correctement décodé dans la structure spécifique que vous attendez.

package client

import (
	"encoding/json"
	"io"
	"net/http"
)

// DoRequest effectue une requête HTTP GET et décode la réponse JSON dans le type générique T fourni.
func DoRequest[T any](ctx context.Context, client *http.Client, url string) (*T, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return nil, err
	}

	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("code de statut inattendu : %d", resp.StatusCode)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	var result T
	if err := json.Unmarshal(body, &result); err != nil {
		return nil, fmt.Errorf("échec du décodage de la réponse : %w", err)
	}

	return &result, nil
}

Cette seule fonction peut désormais être utilisée pour récupérer des structures User, des structures Order, ou tout autre type sérialisable en JSON, à condition que l'URL soit valide et que la méthode HTTP soit GET. Bien qu'un client prêt pour la production gère les tentatives et les délais d'attente, cela démontre la puissance des contraintes de type génériques.

Le modèle de dépôt générique

Le modèle de dépôt agit comme un médiateur entre les couches de domaine et de mappage de données, fournissant une interface de type collection pour accéder aux objets de domaine. En Go, bien que nous n'ayons pas de classes, nous pouvons utiliser des interfaces et des génériques pour créer une abstraction de dépôt hautement réutilisable.

En définissant une interface générique, nous pouvons garantir que toute structure implémentant notre logique métier respecte des opérations CRUD spécifiques (Créer, Lire, Mettre à jour, Supprimer). Cela est particulièrement utile lors du travail avec différentes bases de données (par exemple, SQL vs NoSQL) ou lors du mock de services dans les tests.

package repository

import "context"

// Repository définit une interface générique pour les opérations CRUD.
type Repository[T any, ID comparable] interface {
	Get(ctx context.Context, id ID) (*T, error)
	Create(ctx context.Context, item *T) error
	Delete(ctx context.Context, id ID) error
}

// UserService gère la logique métier pour les utilisateurs.
type UserService struct {
	repo Repository[User, int]
}

func NewUserService(repo Repository[User, int]) *UserService {
	return &UserService{repo: repo}
}

func (s *UserService) GetUserProfile(ctx context.Context, id int) (*User, error) {
	// La logique métier peut être appliquée ici avant de récupérer depuis la base de données
	user, err := s.repo.Get(ctx, id)
	if err != nil {
		return nil, err
	}
	
	// Exemple : Enrichir les données utilisateur
	user.Status = "active"
	return user, nil
}

Avantages pratiques et considérations

L'utilisation des génériques pour le client HTTP et le modèle de dépôt offre trois avantages principaux :

Sécurité de type : Le compilateur Go détecte les types incompatibles au moment de la compilation plutôt qu'à l'exécution, empêchant les bugs subtils où une réponse JSON est décodée dans la mauvaise structure.
Code DRY : Éliminer le code répétitif de sérialisation et de gestion des erreurs rend votre base de code plus facile à lire et à maintenir.
Testabilité : Les interfaces génériques vous permettent de facilement simuler les dépendances. Par exemple, vous pouvez créer un MockRepository[T] qui renvoie des données prédéfinies pour tester le UserService sans toucher à une vraie base de données ou API.

Cependant, les développeurs devraient faire attention à ne pas sur-architecturer. Toutes les fonctions ne doivent pas être génériques. Utilisez des génériques lorsque vous observez un schéma clair de paramétrisation de type. Pour les scripts simples ou les fonctions utilitaires ponctuelles, les types concrets standards sont souvent plus lisibles et performants.

Conclusion

Les génériques en Go ont ouvert la porte à des modèles de conception plus sophistiqués qui étaient auparavant awkward ou verbeux à implémenter. En combinant un client HTTP générique avec le modèle de dépôt, vous pouvez construire des systèmes backend à la fois flexibles et robustes. Lors de la refonte de vos projets Go existants, cherchez des opportunités pour extraire la logique spécifique au type répétitive dans des abstractions génériques. Votre futur vous—et votre équipe—vous remercieront pour une base de code plus propre et plus maintenable.