Go Academy · Lektion

Ein Plugin-Interface entwerfen

Gemeinsame Interface-Verträge zwischen Host und Plugin

Ein Plugin-Interface entwerfen ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Interface-basierte Plugins

Definieren Sie ein stabiles Go-Interface, das Plugins implementieren müssen. Der Host lädt das Plugin, ruft die Implementierung ab und verwendet sie über das Interface — dadurch sind nicht bei jeder Methode Typassertionen erforderlich.

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

Plugin-Einstiegspunkt

Jedes Plugin exportiert ein bekanntes Symbol (z. B. Plugin), das die Interface-Implementierung zurückgibt:

// 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
}

Über ein Interface laden

Laden Sie im Host das Symbol und führen Sie eine Typassertion auf das Interface durch:

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

Registry-Muster

Verwalten Sie eine Registry der geladenen Plugins nach Namen:

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
}

Interface-Versionierung

Fügen Sie dem Interface eine Methode Version() hinzu, damit der Host vor der Registrierung des Plugins die Kompatibilität überprüfen kann.

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

Kontext und Abbruch

Geben Sie den Kontext durch die Plugin-Methodenaufrufe weiter, damit der Host lang laufende Plugin-Operationen beim Herunterfahren oder nach Ablauf eines Anfrage-Timeouts abbrechen kann.

Vertrag für die Fehlerbehandlung

Definieren Sie, ob Plugins bei Fehlern Panics auslösen oder Fehler zurückgeben sollen. Das Zurückgeben von Fehlern ist sicherer — Panics in Plugins können möglicherweise nicht von der Recover-Middleware des Hosts abgefangen werden.

Konfiguration

Übergeben Sie Plugins ihre Konfiguration beim Laden über eine Methode Init(config map[string]string) error. Dadurch werden die Erstellung und die Konfiguration des Plugins voneinander getrennt.

Lebenszyklusverwaltung

Fügen Sie dem Interface Close() error für Plugins hinzu, die Ressourcen (Datenbankverbindungen, Goroutinen) halten, die beim Herunterfahren bereinigt werden müssen.

Plugins unabhängig testen

Testen Sie die Plugin-Implementierung direkt (als Go-Paket), ohne die .so-Binärdatei zu laden. Das Interface macht Mock-Tests unkompliziert.

Dokumentationsvertrag

Dokumentieren Sie den Interface-Vertrag eindeutig: welche Methoden wann aufgerufen werden, welche Threading-Garantien gelten und was als Fehler beziehungsweise als fataler Zustand gilt.

Schnelltest

Warum sollte für Plugins ein stabiles Go-Interface definiert werden, anstatt einzelne Funktionssymbole zu suchen?

Zusammenfassung: Plugin-Interface-Design

Wichtige Punkte:

Ein stabiles Interface definieren, das das Plugin implementieren muss
Ein bekanntes Symbol (var Plugin InterfaceType) aus dem Plugin exportieren
Eine einzige Typassertion beim Laden; alle Aufrufe sind über das Interface typsicher
Version(), Init() und Close() für die Lebenszyklusverwaltung hinzufügen

Häufig gestellte Fragen

Ist die Lektion „Ein Plugin-Interface entwerfen“ kostenlos?

Ja — der vollständige Text von „Ein Plugin-Interface entwerfen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Ein Plugin-Interface entwerfen“?

Gemeinsame Interface-Verträge zwischen Host und Plugin Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Ein Plugin-Interface entwerfen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy