如何在Golang中通过反射实现插件机制

type Plugin interface {
    Name() string
    Execute(data interface{}) error
}

package main

import "yourproject/plugins"

type HelloPlugin struct{}

func (h *HelloPlugin) Name() string {
    return "hello"
}

func (h *HelloPlugin) Execute(data interface{}) error {
    println("Hello from plugin!")
    return nil
}

var Plugin plugins.Plugin = &HelloPlugin{}

go build -buildmode=plugin -o hello_plugin.so hello_plugin.go

import (
    "plugin"
    "reflect"
)

func loadPlugin(path string) (Plugin, error) {
    // 打开插件
    plug, err := plugin.Open(path)
    if err != nil {
        return nil, err
    }

    // 查找名为 Plugin 的符号
    sym, err := plug.Lookup("Plugin")
    if err != nil {
        return nil, err
    }

    // 检查符号是否实现了 Plugin 接口
    if instance, ok := sym.(interface{ Plugin }); ok {
        return instance.(Plugin), nil
    }

    // 使用反射判断类型是否匹配
    v := reflect.ValueOf(sym)
    if v.Kind() == reflect.Ptr {
        elem := v.Elem()
        if elem.CanInterface() {
            if _, ok := elem.Interface().(Plugin); ok {
                return elem.Interface().(Plugin), nil
            }
        }
    }

    return nil, fmt.Errorf("symbol does not implement Plugin interface")
}

p, err := loadPlugin("./hello_plugin.so")
if err != nil {
    log.Fatal(err)
}
p.Execute(nil)