Technical Tutorials

Depuis l'introduction de Go 1.18, l'écosystème Go a considérablement évolué. L'ajout des génériques a répondu à l'une des plaintes les plus courantes dans le développement Go : le besoin de code boilerplate pour gérer plusieurs types. Pour les développeurs intermédiaires et avancés, exploiter les génériques n'est plus une option si vous souhaitez écrire du code propre, DRY (Don't Repeat Yourself) et maintenable.

Dans cet article, nous explorerons comment implémenter un motif de Repository robuste et typé en utilisant les génériques Go. Ce motif est crucial pour l'abstraction de base de données, permettant à votre logique métier de rester découplée des implémentations de base de données spécifiques tout en garantissant la sécurité des types à la compilation.

Pourquoi le motif Repository en Go ?

Le motif Repository 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. Dans le développement Go traditionnel sans génériques, l'implémentation d'un repository pour chaque entité (Utilisateur, Produit, Commande) nécessitait du code boilerplate répétitif pour chaque opération de base de données (Créer, Lire, Mettre à jour, Supprimer).

En utilisant les génériques, nous pouvons définir une seule interface Repository et une implémentation qui fonctionnent pour différents types d'entités, réduisant ainsi la duplication de code et améliorant la maintenabilité.

Définir l'interface Repository générique

Le cœur de notre solution réside dans la définition d'une interface générique. Nous utilisons un paramètre de type T pour représenter le type d'entité. De plus, nous introduisons une interface de contrainte Entity pour imposer que seules les structures avec des champs spécifiques (comme un ID) puissent être utilisées comme entités.

package repository

import "context"

// EntityConstraint assure que seules les structures avec un champ ID peuvent être utilisées comme entités.
type EntityConstraint interface {
	~struct{
		ID int64
	}
}

// Repository définit l'interface générique pour les opérations de base de données.
type Repository[T any] interface {
	Create(ctx context.Context, entity *T) error
	Read(ctx context.Context, id int64) (*T, error)
	Update(ctx context.Context, entity *T) error
	Delete(ctx context.Context, id int64) error
	List(ctx context.Context) ([]*T, error)
}

Ici, any permet tout type, mais en pratique, vous pourriez restreindre T pour implémenter l'interface EntityConstraint si vous devez imposer des règles structurelles. Les méthodes acceptent *T, garantissant que l'appelant fournit des pointeurs vers le type d'entité spécifique.

Implémentation du Repository générique

Créons une implémentation concrète en utilisant sqlx, une bibliothèque SQL populaire pour Go qui prend en charge le scan dans des structures. Cette implémentation démontre comment les génériques nous permettent d'écrire un seul gestionnaire pour plusieurs types de tables.

package repository

import (
	"context"
	"database/sql"
	"fmt"
)

type GenericRepository[T any] struct {
	db *sql.DB
	tableName string
}

func NewGenericRepository[T any](db *sql.DB, tableName string) *GenericRepository[T] {
	return &GenericRepository[T]{
		db:        db,
		tableName: tableName,
	}
}

func (r *GenericRepository[T]) Create(ctx context.Context, entity *T) error {
	// Dans un scénario réel, vous utiliseriez la réflexion ou une requête générée par macro
	// pour construire dynamiquement la requête INSERT en fonction des champs de la structure.
	// Pour plus de concision, nous supposons qu'une fonction d'aide existe qui génère la requête.
	query := fmt.Sprintf("INSERT INTO %s VALUES (?, ?, ?)", r.tableName)
	_, err := r.db.ExecContext(ctx, query, /* champs de l'entité */ )
	return err
}

func (r *GenericRepository[T]) Read(ctx context.Context, id int64) (*T, error) {
	var entity T
	query := fmt.Sprintf("SELECT * FROM %s WHERE id = ?", r.tableName)
	err := r.db.QueryRowContext(ctx, query, id).Scan(&entity)
	if err != nil {
		return nil, err
	}
	return &entity, nil
}

Remarquez comment la méthode Read retourne *T. Le compilateur garantit que si vous appelez cette méthode, la variable retournée correspond au type avec lequel vous avez instancié le repository. Cela élimine le besoin d'assertions de type (entity.(*User)), qui sont sujettes aux erreurs et lentes.

Utilisation du Repository dans la couche Service

La véritable puissance de ce motif est visible lorsque vous l'utilisez dans votre couche de service. Ici, nous pouvons injecter un repository générique et effectuer des opérations sans connaître les détails SQL sous-jacents.

type UserService struct {
	userRepo repository.Repository[*User]
}

func NewUserService(userRepo repository.Repository[*User]) *UserService {
	return &UserService{userRepo: userRepo}
}

func (s *UserService) GetUserByID(ctx context.Context, id int64) (*User, error) {
	return s.userRepo.Read(ctx, id)
}

Dans cet exemple, userRepo est typé comme Repository[*User]. Cela fournit des garanties fortes à la compilation. Si vous essayez accidentellement de passer un *Product à ce service spécifique aux utilisateurs, le compilateur Go générera une erreur, empêchant les bogues d'exécution.

Meilleures pratiques et considérations

Évitez la sur-abstraction : Les génériques ajoutent de la complexité. Utilisez-les uniquement lorsque vous avez réellement besoin de réutiliser la logique entre différents types. Pour les applications simples, des implémentations concrètes peuvent être plus claires.
Performance : Bien que les génériques réduisent la duplication de code, assurez-vous que vos fonctions génériques sont intégrées (inlinées) par le compilateur. Évitez une réflexion excessive dans les méthodes génériques, car cela peut impacter les performances.
Gestion des erreurs : Assurez-vous que la gestion des erreurs dans les fonctions génériques est robuste. Puisque le type T est inconnu à la compilation, vous ne pouvez pas vous fier à des types d'erreur spécifiques au type.

Conclusion

Maîtriser les génériques Go ouvre de nouvelles possibilités pour construire des applications évolutives et maintenables. En implémentant un motif Repository générique, vous pouvez atteindre un haut degré de réutilisation de code tout en maintenant la sécurité des types pour laquelle Go est connu. Alors que vous continuez à développer en Go, adoptez les génériques non pas seulement comme une fonctionnalité, mais comme un outil fondamental pour concevoir des architectures propres.

Commencez à refactoriser vos gestionnaires de base de données répétitifs dès aujourd'hui et découvrez les avantages du code générique et typé.