Een plugininterface ontwerpen
Gedeelde interfacecontracten tussen host en plugin
Een plugininterface ontwerpen is een gratis Go Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Go Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Go Academy bevat in totaal 4 lessen.
Plugins op basis van interfaces
Definieer een stabiele Go-interface die plugins moeten implementeren. De host laadt de plugin, haalt de implementatie op en roept deze via de interface aan — zonder bij elke methode typeasserties uit te voeren.
type Processor interface {
Name() string
Process(ctx context.Context, data []byte) ([]byte, error)
}Ingangspunt van de plugin
Elke plugin exporteert een bekend symbool (bijv. Plugin) dat de implementatie van de interface retourneert:
// 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
}Laden via een interface
Laad in de host het symbool en pas daarop een typeassertie toe naar de interface:
sym, _ := p.Lookup("Plugin")
proc, ok := sym.(Processor)
if !ok { log.Fatal("plugin does not implement Processor") }Registerpatroon
Houd een register bij van geladen plugins op naam:
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
}Interfaceversies beheren
Voeg een methode Version() toe aan de interface, zodat de host de compatibiliteit kan controleren voordat de plugin wordt geregistreerd.
type Versioned interface {
APIVersion() string
}
if v, ok := proc.(Versioned); ok && v.APIVersion() != "1.0" {
log.Fatalf("incompatible plugin version: %s", v.APIVersion())
}Context en annulering
Geef context door via aanroepen van pluginmethoden, zodat de host langdurige pluginbewerkingen kan annuleren bij het afsluiten of wanneer de time-out van een verzoek is verstreken.
Contract voor foutafhandeling
Bepaal of plugins bij fouten een panic moeten veroorzaken of fouten moeten retourneren. Fouten retourneren is veiliger — panics in plugins kunnen mogelijk niet worden onderschept door de recover-middleware van de host.
Configuratie
Geef configuratie tijdens het laden door aan plugins via de methode Init(config map[string]string) error. Hierdoor zijn het maken van de plugin en de configuratie van elkaar gescheiden.
Levenscyclusbeheer
Voeg Close() error toe aan de interface voor plugins die resources vasthouden (DB-verbindingen, goroutines) die bij het afsluiten moeten worden opgeruimd.
Plugins onafhankelijk testen
Test de pluginimplementatie rechtstreeks (als Go-pakket) zonder het .so-binaire bestand te laden. De interface maakt testen met mocks eenvoudig.
Contract voor documentatie
Documenteer het interfacecontract duidelijk: wanneer welke methoden worden aangeroepen, welke garanties voor gelijktijdigheid gelden en wat als fout versus fatale toestand geldt.
Korte controle
Waarom definieer je een stabiele Go-interface voor plugins in plaats van afzonderlijke functiesymbolen op te zoeken?
Samenvatting: Ontwerp van plugininterfaces
Belangrijkste punten:
- Definieer een stabiele interface die de plugin moet implementeren
- Exporteer een bekend symbool (var Plugin InterfaceType) uit de plugin
- Eén typeassertie tijdens het laden; alle aanroepen zijn typeveilig via de interface
- Voeg Version(), Init() en Close() toe voor levenscyclusbeheer
Leer Go met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 51
- Lessen
- 203
Veelgestelde vragen
Is de les “Een plugininterface ontwerpen” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “Een plugininterface ontwerpen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Go Academy bevat in totaal 4 lessen.
Wat leer ik in “Een plugininterface ontwerpen”?
Gedeelde interfacecontracten tussen host en plugin Je oefent met Go Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Go Academy te beginnen?
Ervaring vooraf is niet nodig. Go Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Een plugininterface ontwerpen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Go Academy?
Ja. Elke les over Go Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Basis van het Go-package plugin
- Een plugininterface ontwerpen
- Dynamisch laden en symbolen
- Alternatieven: HashiCorp go-plugin