golang插件可以用于工厂功能吗?

Question

我在golang插件模块中有以下代码：

即插即用

package main
import "fmt"
var (
    Thing        = New("first thing")
    ThingFactory = thingFactory{}
)
type thing struct {
    i int
    s string
}
func New(s string) thing {
    return thing{s: s}
}
func (t *thing) Say() string {
    t.i++
    return fmt.Sprintf("%s - %d", t.s, t.i)
}
type thingFactory struct{}
func (t thingFactory) Make(s string) thing {
    return New(s)
}

它被编译为.so对象并在另一个程序中使用：

主去

package main
import (
    "fmt"
    "plugin"
)
func main() {
    p, err := plugin.Open("../plug/plug.so")
    if err != nil {
        panic(err)
    }
    symbol, err := p.Lookup("Thing")
    if err != nil {
        panic(err)
    }
    thing := symbol.(Sayer)
    fmt.Println(thing.Say())
    symbol, err = p.Lookup("ThingFactory") // <-problems start here
    if err != nil {
        panic(err)
    }
    factory := symbol.(GetSayer)
    madeThing := factory.Make("how about me?")
    fmt.Println(madeThing.Say())
    fmt.Println(madeThing.Say())
}
type Sayer interface {
    Say() string
}
type GetSayer interface {
    Make(string) Sayer
}

我能够查找Thing，并在其上调用Say()，但是第二个接口转换出现恐慌：

first thing - 1 panic: interface conversion: *main.thingFactory is not main.GetSayer: missing method Make

即使运行时将第一个符号识别为Sayer，它也无法识别thingFactory显然有一个 Make（） 方法，该方法应该返回同样是 Sayer 的东西。

我在这里错过了一些明显的东西吗？

Answer 1

第一个问题是，在您的插件中thingFactory（更确切地说是*thingfactory）没有在主应用程序的GetSayer界面中描述的方法：

Make(string) Sayer

你有：

Make(string) thing

所以（首先）你必须thingFactory.Make()改成这样：

type Sayer interface {
    Say() string
}
func (t thingFactory) Make(s string) Sayer {
    th := New(s)
    return &th
}

在此之后，它仍然不起作用。这样做的原因是插件的Sayer类型与主应用程序的Sayer类型不同。但它们必须相同才能实现主应用程序的GetSayer界面。

一种解决方案是将Sayer接口"外包"到自己的包中，并在插件和主应用程序中使用这个通用的共享包。

让我们创建一个新包，称之为subplay：

package subplay
type Sayer interface {
    Say() string
}

导入此包并在插件中使用它：

package main
import (
    "fmt"
    "path/to/subplay"
)
var (
    Thing        = New("first thing")
    ThingFactory = thingFactory{}
)
type thing struct {
    i int
    s string
}
func New(s string) thing {
    return thing{s: s}
}
func (t *thing) Say() string {
    t.i++
    return fmt.Sprintf("%s - %d", t.s, t.i)
}
type thingFactory struct{}
func (t thingFactory) Make(s string) subplay.Sayer {
    th := New(s)
    return &th
}

并在主应用程序中导入和使用它：

package main
import (
    "fmt"
    "path/to/subplay"
    "plugin"
)
func main() {
    p, err := plugin.Open("../plug/plug.so")
    if err != nil {
        panic(err)
    }
    symbol, err := p.Lookup("Thing")
    if err != nil {
        panic(err)
    }
    thing := symbol.(subplay.Sayer)
    fmt.Println(thing.Say())
    symbol, err = p.Lookup("ThingFactory")
    if err != nil {
        panic(err)
    }
    factory := symbol.(GetSayer)
    madeThing := factory.Make("how about me?")
    fmt.Println(madeThing.Say())
    fmt.Println(madeThing.Say())
}
type GetSayer interface {
    Make(string) subplay.Sayer
}

现在它将工作，输出将是：

first thing - 1
how about me? - 1
how about me? - 2

请参阅相关问题：

Go 1.8 插件使用自定义界面

Go 插件依赖项如何工作？

Answer 2

你的插件 Make 方法应该返回一个 Sayer 对象而不是东西

type Sayer interface {
    Say() string
}
func (t *thingFactory) Make(s string) Sayer {
    return New(s)
}