Go语言插件系统设计：扩展程序功能的艺术

package plugin

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

package main

import (
    "fmt"
    "plugin"
)

func main() {
    p, err := plugin.Open("myplugin.so")
    if err != nil {
        panic(err)
    }

    symbol, err := p.Lookup("MyPlugin")
    if err != nil {
        panic(err)
    }

    myPlugin, ok := symbol.(plugin.Plugin)
    if !ok {
        panic("unexpected type from module symbol")
    }

    fmt.Println("Plugin Name:", myPlugin.Name())
    result := myPlugin.Execute("some data")
    fmt.Println("Plugin Result:", result)
}

// myplugin.go
package main

import "fmt"

type MyPlugin struct{}

func (p *MyPlugin) Name() string {
    return "My Awesome Plugin"
}

func (p *MyPlugin) Execute(data interface{}) interface{} {
    fmt.Println("Plugin received data:", data)
    return "Plugin processed data successfully!"
}

var MyPlugin MyPlugin // 必须导出这个符号

func main() {} // 必须包含一个空的main函数

package pluginmanager

import (
    "fmt"
    "plugin"
    "sync"
)

type Plugin interface {
    Name() string
    Execute(data interface{}) interface{}
    Dependencies() []string // 声明依赖
    Init(manager *PluginManager) error // 初始化，注入依赖
}

type PluginManager struct {
    plugins   map[string]Plugin
    loaded    map[string]bool
    pluginDir string
    mu        sync.Mutex
}

func NewPluginManager(pluginDir string) *PluginManager {
    return &PluginManager{
        plugins:   make(map[string]Plugin),
        loaded:    make(map[string]bool),
        pluginDir: pluginDir,
    }
}

func (m *PluginManager) LoadPlugin(pluginName string) error {
    m.mu.Lock()
    defer m.mu.Unlock()

    if m.loaded[pluginName] {
        return nil // 已经加载
    }

    // 1. 加载依赖
    p, err := plugin.Open(m.pluginDir + "/" + pluginName + ".so")
    if err != nil {
        return fmt.Errorf("failed to open plugin %s: %v", pluginName, err)
    }

    symbol, err := p.Lookup("MyPlugin") // 假设所有插件都导出MyPlugin
    if err != nil {
        return fmt.Errorf("failed to lookup symbol in plugin %s: %v", pluginName, err)
    }

    pl, ok := symbol.(Plugin)
    if !ok {
        return fmt.Errorf("unexpected type from module symbol in plugin %s", pluginName)
    }

    // 2. 递归加载依赖
    for _, dep := range pl.Dependencies() {
        if err := m.LoadPlugin(dep); err != nil {
            return fmt.Errorf("failed to load dependency %s of plugin %s: %v", dep, pluginName, err)
        }
    }

    // 3. 初始化插件，注入依赖
    if err := pl.Init(m); err != nil {
        return fmt.Errorf("failed to initialize plugin %s: %v", pluginName, err)
    }

    m.plugins[pluginName] = pl
    m.loaded[pluginName] = true
    fmt.Printf("Plugin %s loaded successfully\n", pluginName)

    return nil
}

func (m *PluginManager) GetPlugin(name string) Plugin {
    return m.plugins[name]
}

// 示例插件，声明依赖
// package main
// type MyPlugin struct {
//  DependencyPlugin DependencyPlugin // 依赖
// }
//
// func (p *MyPlugin) Dependencies() []string {
//  return []string{"dependencyplugin"}
// }
//
// func (p *MyPlugin) Init(manager *PluginManager) error {
//  dep := manager.GetPlugin("dependencyplugin")
//  if dep == nil {
//   return fmt.Errorf("dependency plugin 'dependencyplugin' not found")
//  }
//  p.DependencyPlugin = dep.(DependencyPlugin)
//  return nil
// }

package plugin

type Plugin interface {
    Name() string
    Version() string // 版本号
    Execute(data interface{}) interface{}
}

package main

import (
    "fmt"
    "log"
    "os"
    "path/filepath"
    "time"

    "github.com/fsnotify/fsnotify"
)

func watchPlugins(pluginDir string, reload func(string)) {
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        log.Fatal(err)
    }
    defer watcher.Close()

    done := make(chan bool)
    go func() {
        for {
            select {
            case event, ok := <-watcher.Events:
                if !ok {
                    return
                }
                if event.Op&fsnotify.Write == fsnotify.Write {
                    fmt.Println("modified file:", event.Name)
                    // 简单起见，延迟一段时间再重新加载
                    time.Sleep(time.Second * 2)
                    reload(event.Name)
                }
            case err, ok := <-watcher.Errors:
                if !ok {
                    return
                }
                log.Println("error:", err)
            case <-done:
                return
            }
        }
    }()

    err = filepath.Walk(pluginDir, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        if info.IsDir() {
            return watcher.Add(path)
        }
        return nil
    })

    if err != nil {
        log.Fatal(err)
    }
    <-done
}

// 示例用法
// watchPlugins("./plugins", func(filename string) {
//  fmt.Println("Reloading plugin:", filename)
//  // 这里调用你的插件加载逻辑
// })