使用反射在运行时根据结构体名称动态创建实例 - Golang实现

感谢。

使用标准库的插件功能已经非常接近了。

唯一的问题是，供应商很容易忘记使用 go build -buildmode=plugin 选项将他们的代码构建为插件，这导致他们的二进制文件无法用于获取符号。

实际上，plugin.Open() 内部实现的功能正是 Go 语言反射所缺失的。

为什么 Go 语言不能将其实现 plugin.Open 的方式作为公共方法公开，以便任何人都可以加载任何二进制文件来查找其中的符号（而不仅仅局限于使用 -buildmode=plugin 选项构建的二进制文件）？

在Go中，reflect.TypeOf() 返回的是值的运行时类型，而不是根据字符串名称查找类型。你的代码中 reflect.TypeOf(name) 实际上返回的是字符串 "external.LocalUserPlugin" 的类型，而不是该名称对应的结构体类型。

要实现根据类型名称动态创建实例，需要使用Go的插件系统（plugin package）或类型注册机制。以下是两种解决方案：

方案1：使用全局注册表（推荐）

package external

import "reflect"

type AuthService interface {
    Auth()
}

// 创建类型注册表
var typeRegistry = make(map[string]reflect.Type)

func init() {
    typeRegistry["LocalUserPlugin"] = reflect.TypeOf(LocalUserPlugin{})
    typeRegistry["RemotePluginStub"] = reflect.TypeOf(RemotePluginStub{})
}

// 注册函数
func RegisterType(name string, typ reflect.Type) {
    typeRegistry[name] = typ
}

// 创建实例函数
func CreateInstance(typeName string) (interface{}, error) {
    if typ, ok := typeRegistry[typeName]; ok {
        return reflect.New(typ).Interface(), nil
    }
    return nil, fmt.Errorf("type not found: %s", typeName)
}

type LocalUserPlugin struct{}

func (p *LocalUserPlugin) Auth() {
    println("Auth from local user plugin")
}

type RemotePluginStub struct{}

func (p *RemotePluginStub) Auth() {
    println("Auth from remote plugin stub")
}

宿主代码：

package main

import (
    "external"
    "fmt"
)

func main() {
    names := []string{"LocalUserPlugin", "RemotePluginStub"}
    
    for _, name := range names {
        instance, err := external.CreateInstance(name)
        if err != nil {
            fmt.Printf("Error creating %s: %v\n", name, err)
            continue
        }
        
        if s, ok := instance.(external.AuthService); ok {
            s.Auth()
        } else {
            fmt.Printf("bad type: %s\n", name)
        }
    }
}

方案2：使用Go插件（plugin package）

插件代码：

// plugin.go
package main

import "external"

type LocalUserPlugin struct{}

func (p *LocalUserPlugin) Auth() {
    println("Auth from local user plugin")
}

// 导出变量
var Plugin external.AuthService = &LocalUserPlugin{}

编译插件：

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

宿主代码：

package main

import (
    "external"
    "plugin"
)

func main() {
    pluginPaths := []string{"./plugin.so"}
    
    for _, path := range pluginPaths {
        p, err := plugin.Open(path)
        if err != nil {
            println("Error loading plugin:", err.Error())
            continue
        }
        
        symbol, err := p.Lookup("Plugin")
        if err != nil {
            println("Error looking up symbol:", err.Error())
            continue
        }
        
        if s, ok := symbol.(external.AuthService); ok {
            s.Auth()
        } else {
            println("bad type")
        }
    }
}

方案3：使用反射和包路径（需要导入包）

package main

import (
    "external"
    "reflect"
    "strings"
)

func createInstance(typeName string) (interface{}, error) {
    parts := strings.Split(typeName, ".")
    if len(parts) != 2 {
        return nil, fmt.Errorf("invalid type name format")
    }
    
    // 需要确保包已经被导入
    switch parts[0] {
    case "external":
        switch parts[1] {
        case "LocalUserPlugin":
            return &external.LocalUserPlugin{}, nil
        case "RemotePluginStub":
            return &external.RemotePluginStub{}, nil
        }
    }
    
    return nil, fmt.Errorf("type not found: %s", typeName)
}

func main() {
    names := []string{"external.LocalUserPlugin", "external.RemotePluginStub"}
    
    for _, name := range names {
        instance, err := createInstance(name)
        if err != nil {
            println("Error:", err.Error())
            continue
        }
        
        if s, ok := instance.(external.AuthService); ok {
            s.Auth()
        } else {
            println("bad type")
        }
    }
}

第一种方案（全局注册表）是最常用且灵活的方式，它允许插件在初始化时自行注册，而不需要宿主预先知道所有类型。