go-micro 框架支持动态加载插件,无需修改代码。
源码分析
启动服务前,设定 MICRO_PLUGIN
环境变量指定动态库 .so 文件路径,支持多个插件,逗号分割。程序启动前会读取 MICRO_PLUGIN
环境变量,并完成插件设定。
下面是其内部实现:
go-micro/service.go
func (s *service) Init(opts ...Option) {
...
// setup the plugins
for _, p := range strings.Split(os.Getenv("MICRO_PLUGIN"), ",") {
if len(p) == 0 {
continue
}
// 加载 .so 文件
c, err := plugin.Load(p)
if err != nil {
logger.Fatal(err)
}
// go-micro 初始化插件
if err := plugin.Init(c); err != nil {
logger.Fatal(err)
}
}
从上面的代码可以看出,service 初始化化的时候,读取 MICRO_PLUGIN
环境变量中指定的 .so 文件路径。并且调用 plugin
包,逐个 Init
。
下面我们看下 plugin
包的实现:
plugin
├── default.go
├── plugin.go
└── template.go
0 directories, 3 files
plugin 包的实现非常简单,只有三个文件。
go-micro/plugin/plugin.go
// Plugin is a plugin loaded from a file
type Plugin interface {
// Initialise a plugin with the config
Init(c *Config) error
// Load loads a .so plugin at the given path
Load(path string) (*Config, error)
// Build a .so plugin with config at the path specified
Build(path string, c *Config) error
}
plugin 包定义了这样一个接口
Init(c *Config) error
方法用来注册插件;Load(path string) (*Config, error)
用来加载一个 .so 文件,并返回一个 Config ;Build(path string, c *Config) error
用来根据指定的 Config 变量生成一个 .so 文件。
go-micro 提供了一个默认的实现,在 go-micro/plugin/default.go 。
先来看一下默认实现的 Load 方法:
import (
//...
pg "plugin"
//...
)
// Load loads a plugin created with `go build -buildmode=plugin`
func (p *plugin) Load(path string) (*Config, error) {
// 调用标准库打开 .so 文件
plugin, err := pg.Open(path)
if err != nil {
return nil, err
}
// 在加载成功的动态库文件中寻找 Plugin 变量/函数
s, err := plugin.Lookup("Plugin")
if err != nil {
return nil, err
}
// 类型转换成 go-micro 定义的 Config 类型指针
pl, ok := s.(*Config)
if !ok {
return nil, errors.New("could not cast Plugin object")
}
return pl, nil
}
Load 方法主要就是调用标准库 plugin
open 一个 .so 文件,然后寻找 Plugin
这个变量,并通过类型断言它转换成 *Config
。Config 是 go-micro 定义的一个类型:
// Config is the plugin config
type Config struct {
// Name of the plugin e.g rabbitmq
Name string
// Type of the plugin e.g broker
Type string
// Path specifies the import path
Path string
// NewFunc creates an instance of the plugin
NewFunc interface{}
}
关于标准库 plugin
的用法,这里不再描述可以查看源码文件,里面有用法说明。需要特别说明的一点是,标准库 plugin
的 Lookup 方法返回 Symbol
类型,它可以类型转换成一个函数或者指向变量的指针。
我们继续看 go-micro 的 Init
方法实现:
// Init sets up the plugin
func (p *plugin) Init(c *Config) error {
switch c.Type {
case "broker":
pg, ok := c.NewFunc.(func(...broker.Option) broker.Broker)
if !ok {
return fmt.Errorf("Invalid plugin %s", c.Name)
}
cmd.DefaultBrokers[c.Name] = pg
case "client":
pg, ok := c.NewFunc.(func(...client.Option) client.Client)
if !ok {
return fmt.Errorf("Invalid plugin %s", c.Name)
}
cmd.DefaultClients[c.Name] = pg
case "registry":
pg, ok := c.NewFunc.(func(...registry.Option) registry.Registry)
if !ok {
return fmt.Errorf("Invalid plugin %s", c.Name)
}
cmd.DefaultRegistries[c.Name] = pg
// .... 省略一些 case
default:
return fmt.Errorf("Unknown plugin type: %s for %s", c.Type, c.Name)
}
return nil
}
这个函数是 micro 实现动态加载的重点,Init
函数通过 Load
方法返回的 Config
变量进行选择,然后通过类型转换得到 对应的构建函数赋值给 go-micro 的 cmd
包里的全局变量 DefaultXXXs
。
go-micro/config/cmd/cmd.go
DefaultBrokers = map[string]func(...broker.Option) broker.Broker{
"service": brokerSrv.NewBroker,
"memory": memory.NewBroker,
"nats": nats.NewBroker,
}
DefaultClients = map[string]func(...client.Option) client.Client{
"mucp": cmucp.NewClient,
"grpc": cgrpc.NewClient,
}
以 DefaultClients
为例,假设我们实现了一个 client
插件(需要实现 go-micro 的 client.Client 接口) 并实现了自己的创建函数 xrpc.NewClient
。那加载插件成功后, DefaultClients
变量就是
map[string]func(...client.Option) client.Client{
"mucp": cmucp.NewClient,
"grpc": cgrpc.NewClient,
"xrpc": xrpc.NewClient,
}
在 cmd 对象的 Before 方法中会根据程序启动时传入的参数来选择对应的插件。
go-micro/config/cmd/cmd.go
// Set the client
if name := ctx.String("client"); len(name) > 0 {
// only change if we have the client and type differs
if cl, ok := c.opts.Clients[name]; ok && (*c.opts.Client).String() != name {
*c.opts.Client = cl()
}
}
GLOBAL OPTIONS:
--client value Client for go-micro; rpc [$MICRO_CLIENT]
如果启动程序时设定了 client=xrpc ,必须记得设定 MICRO_PLUGIN
环境变量指定动态库。这里设定的 c.opts.Client
会被 micro 服务所使用,可以一步一步向上追溯,这里就不追踪了。
上面的源码分析中,我们没有看 go-micro plugin
包的 Build
方法默认实现,现在我们来看一下:
// Build generates a dso plugin using the go command `go build -buildmode=plugin`
func (p *plugin) Build(path string, c *Config) error {
path = strings.TrimSuffix(path, ".so")
// 在 tmp 目录创建一个临时go源码文件
temp := os.TempDir()
base := filepath.Base(path)
goFile := filepath.Join(temp, base+".go")
// 根据模版生成 go 代码到文件中
if err := p.Generate(goFile, c); err != nil {
return err
}
// defer 函数执行完成时候删除这个临时go源码文件
defer os.Remove(goFile)
if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil && !os.IsExist(err) {
return fmt.Errorf("Failed to create dir %s: %v", filepath.Dir(path), err)
}
// 将这个文件编译成动态库
cmd := exec.Command("go", "build", "-buildmode=plugin", "-o", path+".so", goFile)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
}
可以看出,主要就是更具传入的文件路径,创建目录,创建一个临时的 go 文件,然后调用 go build -buildmode=plugin
生成动态库。
这里调用的一个 Generate
方法,这个方法通过 go 模版生成 go 文件。
// Generate creates a go file at the specified path.
// You must use `go build -buildmode=plugin`to build it.
func (p *plugin) Generate(path string, c *Config) error {
f, err := os.Create(path)
if err != nil {
return err
}
defer f.Close()
t, err := template.New(c.Name).Parse(tmpl)
if err != nil {
return err
}
return t.Execute(f, c)
}
// ...
var (
tmpl = `
package main
import (
"github.com/micro/go-micro/v2/plugin"
"{{.Path}}"
)
var Plugin = plugin.Config{
Name: "{{.Name}}",
Type: "{{.Type}}",
Path: "{{.Path}}",
NewFunc: {{.Name}}.{{.NewFunc}},
}
`
)
根据模版生成 go 文件中会有一个全局变量 Plugin
,这也印证了 Load
方法中的 plugin.Lookup("Plugin")
。
简单使用
package main
import (
"fmt"
"github.com/micro/go-micro/v2/plugin"
)
func main() {
p := plugin.NewPlugin()
if err := p.Build("/tmp/test.so", &plugin.Config{
Name: "client",
Type: "client",
Path: "github.com/micro/go-micro/v2/client",
NewFunc: "NewClient",
}); err != nil {
panic(err)
}
c, err := plugin.Load("/tmp/test.so")
if err != nil {
panic(err)
}
fmt.Println(c.Name, c.Type, c.Path, c.NewFunc)
}
上面的例子,主要是使用了 go-micro 的 plugin 包。先生成了 /tmp/test.so
,然后在 Load
这个动态库,打印 config 的内容。
当然也可以,不通过 plugin.Build 生成动态库,直接手写一个 go 文件,手动编译成动态库。
test.go
package main
import (
"github.com/micro/go-micro/v2/client"
"github.com/micro/go-micro/v2/plugin"
)
var Plugin = plugin.Config{
Name: "test",
Type: "client",
Path: "github.com/micro/go-micro/v2/client",
NewFunc: client.NewClient,
}
go build -buildmode=plugin -o ./test.so test.go
go-micro 动态加载的主要场景
假设我们的 micro 服务 client 使用的是 grpc 的形式,现在希望改成 brpc 的形式。go-micro 支持的 client 插件中并不包含 brpc,我们自己使用 brpc 实现一个 client 插件,然后将其编译成动态库。
在运行环境 MICRO_PLUGIN
变量指定动态库路径,并且修改程序的启动命令,指定 client=brpc
。这样就可以做到无需重新编译二进制,替换自己想要的插件。
当然,自己在代码中重新 import
自己实现的插件库,显示指定 client 也是可以的。这样还可以将变更纳入版本管理,也是极好的。
欢迎来到这里!
我们正在构建一个小众社区,大家在这里相互信任,以平等 • 自由 • 奔放的价值观进行分享交流。最终,希望大家能够找到与自己志同道合的伙伴,共同成长。
注册 关于