Go Academy · Leçon

Concevoir une interface de plugin

Contrats d’interface partagés entre l’hôte et le plugin

Concevoir une interface de plugin est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Modules d’extension fondés sur une interface

Définissez une interface Go stable que les modules d’extension doivent implémenter. L’hôte charge le module d’extension, récupère l’implémentation et l’appelle via l’interface — aucune assertion de type à chaque méthode.

type Processor interface {
    Name() string
    Process(ctx context.Context, data []byte) ([]byte, error)
}

Point d’entrée du module d’extension

Chaque module d’extension exporte un symbole connu (par exemple, Plugin) qui renvoie l’implémentation de l’interface :

// In the plugin:
var Plugin processor // exported symbol

type processor struct{}
func (p processor) Name() string { return "my-processor" }
func (p processor) Process(ctx context.Context, data []byte) ([]byte, error) {
    return bytes.ToUpper(data), nil
}

Chargement via l’interface

Dans l’hôte, chargez le symbole et effectuez une assertion de type vers l’interface :

sym, _ := p.Lookup("Plugin")
proc, ok := sym.(Processor)
if !ok { log.Fatal("plugin does not implement Processor") }

Modèle du registre

Conservez un registre des modules d’extension chargés, indexés par nom :

var registry = map[string]Processor{}

func register(p Processor) { registry[p.Name()] = p }
func get(name string) (Processor, bool) {
    p, ok := registry[name]
    return p, ok
}

Gestion des versions de l’interface

Ajoutez une méthode Version() à l’interface afin que l’hôte puisse vérifier la compatibilité avant d’enregistrer le module d’extension.

type Versioned interface {
    APIVersion() string
}
if v, ok := proc.(Versioned); ok && v.APIVersion() != "1.0" {
    log.Fatalf("incompatible plugin version: %s", v.APIVersion())
}

Contexte et annulation

Faites transiter le contexte dans les appels de méthodes du module d’extension afin que l’hôte puisse annuler les opérations longues lors de l’arrêt ou à l’expiration du délai d’attente d’une requête.

Contrat de gestion des erreurs

Définissez si les modules d’extension doivent déclencher une panique ou renvoyer des erreurs en cas d’échec. Renvoyer des erreurs est plus sûr : les paniques dans les modules d’extension peuvent ne pas être interceptées par le middleware recover de l’hôte.

Configuration

Transmettez la configuration aux modules d’extension au chargement au moyen d’une méthode Init(config map[string]string) error. Cela sépare la création du module d’extension de sa configuration.

Gestion du cycle de vie

Ajoutez Close() error à l’interface pour les modules d’extension qui détiennent des ressources (connexions à une base de données, goroutines) nécessitant un nettoyage lors de l’arrêt.

Tester les modules d’extension indépendamment

Testez directement l’implémentation du module d’extension (en tant que paquet Go), sans charger le binaire .so. L’interface facilite les tests avec des simulacres.

Contrat de documentation

Documentez clairement le contrat de l’interface : quand chaque méthode est appelée, quelles sont les garanties de concurrence et ce qui constitue une erreur par opposition à une condition fatale.

Vérification rapide

Pourquoi définir une interface Go stable pour les modules d’extension plutôt que rechercher les symboles de fonctions individuels ?

Récapitulatif : conception d’une interface de module d’extension

Points clés :

Définissez une interface stable que le module d’extension doit implémenter
Exportez un symbole connu (var Plugin InterfaceType) depuis le module d’extension
Effectuez une seule assertion de type au chargement ; tous les appels sont sûrs du point de vue des types via l’interface
Ajoutez Version(), Init() et Close() pour gérer le cycle de vie

Questions Fréquemment Posées

La leçon « Concevoir une interface de plugin » est-elle gratuite ?

Oui — le texte complet de « Concevoir une interface de plugin » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Concevoir une interface de plugin » ?

Contrats d’interface partagés entre l’hôte et le plugin Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Concevoir une interface de plugin » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy