Comment partager des types de données personnalisés entre les plugins Go et l'application principale ?

Partage de types de données personnalisés dans les plugins Go

Dans Go, vous pouvez définir des types de données personnalisés dans les plugins. Cependant, le partage de ces types de données entre un plugin et l'application principale nécessite un examen attentif.

Les limites de la recherche de symboles

Lorsque vous accédez aux symboles exportés à partir d'un plugin, vous pouvez tapez les affirmer dans une interface. Cependant, il n'est pas possible de les saisir directement dans une structure en utilisant uniquement la recherche de symboles.

Un type de données personnalisé comme exemple

Considérons l'exemple suivant :

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

type Person struct {
    Name string
}

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

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

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

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) // Panic: "Wrong symbol type"
}</code>

Dans cet exemple, le symbole P est une structure Personne. Cependant, l'assertion de type dans l'application principale échoue avec une erreur.

La solution : définition de type séparée

La clé pour partager des types de données personnalisés entre un plugin et le l'application principale est de définir le type séparément. De cette façon, le plugin et l'application principale peuvent faire référence à la même définition de type.

Exemple avec une définition de type séparée

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

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

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

import "play/filter"

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

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

<code class="go">// app.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) // Output: &{Name:Bob Age:21}
}</code>

En définissant le type de filtre dans un package séparé, le plugin et l'application principale peuvent tous deux l'importer et l'utiliser pour les assertions de type.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!