## Können Sie in Go-Plugins benutzerdefinierte Assert-Datenstrukturen eingeben?

Benutzerdefinierte Datentypfreigabe zwischen Go-Plugin und Anwendung

In Go ist es möglich, Daten zwischen einem Plugin und einer Anwendung auszutauschen. Es stellt sich jedoch die Frage, ob es möglich ist, „assertion“ in eine benutzerdefinierte Datenstruktur und nicht in eine Schnittstelle einzugeben.

Assertion mit benutzerdefinierten Strukturen eingeben

Stellen Sie sich dieses Szenario vor:

<code class="go">// plugin.go
package main

type Person struct {
    Name string
}

var (
    P = Person{
        Name: "Emma",
    }
)</code>

<code class="go">// app.go
package main

import (
    "fmt"
    "plugin"
    "os"
)

func main() {
    plug, err := plugin.Open("./plugin.so")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    sym, err := plug.Lookup("P")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    var p Person
    p, ok := sym.(Person)
    if !ok {
        fmt.Println("Wrong symbol type")
        os.Exit(1)
    }

    fmt.Println(p.Name)
}</code>

Beim Versuch, das Symbol „P to a Person“ in der app.go-Datei einzugeben, tritt bei der Ausführung ein Fehler auf: „Falscher Symboltyp.“

Lösung: Common Type Package

Um diese Einschränkung zu überwinden, definieren Sie den benutzerdefinierten Datentyp in einem separaten Paket und verwenden Sie ihn sowohl im Plugin als auch in der Hauptanwendung.

<code class="go">// filter/filter.go
package filter

type Filter struct {
    Name string
    Age  int
}</code>

<code class="go">// plugin/main.go
package main

import (
    "play/filter"
)

var MyFilter = filter.Filter{
    Name: "Bob",
    Age:  21,
}

func CreateFilter() filter.Filter {
    return filter.Filter{
        Name: "Bob",
        Age:  21,
    }
}</code>

<code class="go">// app/main.go
package main

import (
    "fmt"
    "log"
    "os"
    "play/filter"
    "plugin"
)

func main() {
    p, err := plugin.Open("plugin.so")
    if err != nil {
        log.Fatal(err)
    }
    mf, err := p.Lookup("MyFilter")
    if err != nil {
        log.Fatal(err)
    }
    f, ok := mf.(*filter.Filter)
    if !ok {
        log.Fatal("Wrong symbol type")
    }

    fmt.Printf("%+v\n", f)
}</code>

In diesem Beispiel wird der Filtertyp in einem separaten Paket definiert, sodass er sowohl für das Plugin als auch für die Hauptanwendung zugänglich ist. Infolgedessen ist die Typzusicherung vom Symbol des Plugins zu einem *filter.Filter erfolgreich.

Beachten Sie Folgendes:

• Variablen, die im Hauptpaket definiert sind, können nicht von anderen Paketen aus referenziert werden. Vermeiden Sie daher die direkte Verwendung desselben Typs im Plugin und in der Hauptanwendung.
• Symbole, die Variablen darstellen, werden als Zeiger zurückgegeben, sodass Sie ihre Werte ändern können.
• Funktionen, die Werte vom Nicht-Zeiger-Typ zurückgeben kann mit einem Funktionszeiger nachgeschlagen werden.
• Das Ändern des Common-Type-Pakets erfordert einen Neuaufbau des Plugins.

Das obige ist der detaillierte Inhalt von## Können Sie in Go-Plugins benutzerdefinierte Assert-Datenstrukturen eingeben?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!