Wie kann ich benutzerdefinierte Schnittstellen mit Go 1.8-Plugins verwenden?

Verwenden benutzerdefinierter Schnittstellen in Go 1.8-Plugins

In Go 1.8 können Plugins benutzerdefinierte Schnittstellen verwenden. Es sind jedoch einige Einschränkungen zu berücksichtigen.

Verwendung eines externen Pakets

Ein Ansatz besteht darin, die Schnittstelle in einem externen Paket zu definieren und es sowohl vom Plugin als auch von der Hauptanwendung importieren zu lassen.

Erstellen Sie beispielsweise eine Schnittstelle in einem Paket namens Filter:

package filter

type Filter interface {
    Name() string
    Age() int
}

Im Plugin importieren Sie das Filterpaket und implementieren es Schnittstelle:

package main

import (
    "fmt"
    "filter"
)

type plgFilter struct{}

func (plgFilter) Name() string { return "Bob" }
func (plgFilter) Age() int     { return 23 }

func GetFilter() (f filter.Filter, err error) {
    f = plgFilter{}
    fmt.Printf("[plugin GetFilter] Returning filter: %T %v\n", f, f)
    return
}

In der Hauptanwendung das Filterpaket importieren und das Plugin laden:

package main

import (
    "fmt"
    "filter"
    "plugin"
)

func main() {
    p, err := plugin.Open("pg/pg.so")
    if err != nil {
        panic(err)
    }

    GetFilter, err := p.Lookup("GetFilter")
    if err != nil {
        panic(err)
    }
    filter, err := GetFilter.(func() (filter.Filter, error))()
    fmt.Printf("GetFilter result: %T %v %v\n", filter, filter, err)
    fmt.Println("\tName:", filter.Name())
    fmt.Println("\tAge:", filter.Age())
}

Dieser Ansatz stellt sicher, dass das Plugin Zugriff auf die Schnittstellendefinition hat.

Rückgabe der Schnittstelle{}

Eine andere Option besteht darin, dass das Plugin einen Wert vom Typ Schnittstelle zurückgibt{}. Die Hauptanwendung kann dann die erwartete Schnittstelle definieren und die Typzusicherung für den zurückgegebenen Wert verwenden.

Zum Beispiel im Plugin:

package main

import (
    "fmt"
)

type plgFilter struct{}

func (plgFilter) Name() string { return "Bob" }
func (plgFilter) Age() int     { return 23 }

func GetFilterIface() (f interface{}, err error) {
    f = plgFilter{}
    fmt.Printf("[plugin GetFilterIface] Returning filter: %T %v\n", f, f)
    return
}

In der Hauptanwendung:

package main

import (
    "fmt"
    "plugin"
)

func main() {
    p, err := plugin.Open("pg/pg.so")
    if err != nil {
        panic(err)
    }

    GetFilterIface, err := p.Lookup("GetFilterIface")
    if err != nil {
        panic(err)
    }
    filterIface, err := GetFilterIface.(func() (interface{}, error))()
    fmt.Printf("GetFilterIface result: %T %v %v\n", filterIface, filterIface, err)
    myfilter := filterIface.(MyFilter)
    fmt.Println("\tName:", myfilter.Name())
    fmt.Println("\tAge:", myfilter.Age())
}

type MyFilter interface {
    Name() string
    Age() int
}

Dieser Ansatz bietet mehr Flexibilität, erfordert jedoch im Wesentlichen eine Typzusicherung Anwendung.

Einschränkungen

Beachten Sie, dass benutzerdefinierte Schnittstellen nur funktionieren, wenn die Schnittstelle außerhalb des Plugins definiert ist. Dies liegt daran, dass Go-Plugins eigenständige Module sind, die nicht auf in anderen Paketen definierte Typen zugreifen können.

Das obige ist der detaillierte Inhalt vonWie kann ich benutzerdefinierte Schnittstellen mit Go 1.8-Plugins verwenden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!