Question

我有一个包含4个部分的项目：

网关（gateway / gateway.go），它是一个软件包，它知道如何与应用程序服务器通信并打开此连接通道。
以运行程序（runner / runner.go）为主要运行程序（运行-o运行器/runnerrunner/runner.go），它加载并执行模块（使用反映我从模块运行功能）！
框架（framework / framework.go）实现了许多调用网关的功能。
模块（即Go中的插件）（modules / sample.go）（开始构建-buildmode插件-o modules / sample.so ./modules/sample.go）使用该框架，可以做到客户逻辑！初始化时，我导出struct的reflect.Value，然后runner可以运行该struct的方法。

我希望运行器实例化网关，并且框架获取该实例，而无需在运行器/框架之间建立依赖关系。

为什么？为避免出现Go错误，当运行程序加载模块时，“插件是用不同版本的软件包构建的” 如果我更新了运行器（更改了框架），则将使旧模块无效。

我已经使用2种我不喜欢的方式做到这一点：

使用上下文，但是模块和框架中的所有功能都需要接收参数上下文，然后框架提取网关。
只需让框架实例化网关，但是运行程序无法使用网关。

Answer 1

Go插件引起很多麻烦，特别是插件编译器版本必须与程序的编译器版本完全匹配。但是该示例有效。

runner / runner.go

package main

import (
  "context"
  "fmt"
  "os"
  "plugin"
  "reflect"

  "../gateway"
  "../dep"
)

var a *gateway.Gateway

func main() {
  myModule := os.Args[1]

  if _, err := plugin.Open(myModule); err != nil {
    os.Exit(1)
  }

  mod, err := dep.NewModule()
  if err != nil {
    os.Exit(1)
  }

  a = gateway.NewGW()
  ctx := context.WithValue(context.Background(), "gateway", a)

  modreflect, err := mod.Init(ctx, dep.Config{})
  if err != nil {
    os.Exit(1)
  }

  if !modreflect.IsValid() {
    os.Exit(1)
  }

  modnode, err := mod.Start(ctx)
  if err != nil {
    os.Exit(1002)
  }

  for {
    if len(modnode) <= 0 {
      break
    }

    modnoderefl := modreflect.MethodByName(modnode)
    if !modnoderefl.IsValid() {
      break
    }

    result := modnoderefl.Call([]reflect.Value{reflect.ValueOf(ctx)})
    if len(result) != 2 {
      break
    }

    modnode = result[0].String()
  }

  mod.End(ctx)
}

gateway / gateway.go

package gateway

type Gateway struct {}

fun NewGW() *Gateway {
  a := Gateway{}
  return &a
}

dep / dep.go

package dep

import (
  "errors"
  "context"
  "reflect"
)

// Config is a configuration provider.
type Config map[string]interface{}

// Module is the interface implementated by types that
// register themselves as modular plug-ins.
type Module interface {
  Init(ctx context.Context, config Config) (reflect.Value,error)
  Start(ctx context.Context) (string,error)
  End(ctx context.Context) error
}

var themod = []func() Module{}

func RegisterModule(ctor func() Module) {
  themod = append(themod, ctor)
}

func NewModule() (Module, error) {
  if len(themod) == 0 {
    return nil, errors.New("Module not registered")
  }
  return themod[0](), nil
}

framework / framework.go

package framework

import (
    "fmt"
  "context"
  "../gateway"
)

type PlayFileInput struct {
  Path string
}

func Play(ctx context.Context, p PlayFileInput) error {
  if a := ctx.Value("gateway"); a != nil {

    if a.(*gateway.Gateway) != nil {
      _, err := a.(*gateway.Gateway).Exec("Playback", p.Path)
      return err
    }
  }

  return nil
}

modules / sample.go

package main

import "C"

import (
    "context"
    "fmt"
    "os"
  "reflect"

  "../dep"
  "../framework"
)

type MyModuleImpl struct {}

func init() {
  dep.RegisterModule(func() dep.Module {
    return &MyModuleImpl{}
  })
}

func (m *MyModuleImpl) Init(ctx context.Context, config dep.Config) (reflect.Value, error) {
  return reflect.ValueOf(m), nil
}

func (m *MyModuleImpl) Start(ctx context.Context) (string,error) {
  return "Menu_1",nil
}
func (n *MyModuleImpl)Menu_1(ctx context.Context) (string, error) {
  framework.Play(ctx, framework.PlayFileInput{Path: "welcome.wav"})
  return "Menu_2",nil
}
func (n *MyModuleImpl)Menu_2(ctx context.Context) (string, error) {
  return "Menu_3", nil
}
// ....
// ....
func (m *MyModuleImpl) End(ctx context.Context) error {
  return nil
}

如何避免程序包依赖性

1 个答案: