Golang API 创建解释器及使用 Sand 插件库

Sand 是一个 Go 语言的插件系统，允许你动态加载和执行 Go 插件。下面我将介绍如何创建一个简单的 API 解释器以及如何使用 Sand 插件库。

1. 创建简单 API 解释器

首先，我们创建一个基本的 HTTP API 解释器：

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
)

// Command 表示解释器接收的命令结构
type Command struct {
	Action string                 `json:"action"`
	Params map[string]interface{} `json:"params"`
}

// Interpreter 是我们的解释器结构
type Interpreter struct {
	handlers map[string]func(params map[string]interface{}) (interface{}, error)
}

// NewInterpreter 创建新的解释器实例
func NewInterpreter() *Interpreter {
	return &Interpreter{
		handlers: make(map[string]func(params map[string]interface{}) (interface{}, error)),
	}
}

// RegisterHandler 注册命令处理器
func (i *Interpreter) RegisterHandler(action string, handler func(params map[string]interface{}) (interface{}, error)) {
	i.handlers[action] = handler
}

// Execute 执行命令
func (i *Interpreter) Execute(cmd Command) (interface{}, error) {
	handler, exists := i.handlers[cmd.Action]
	if !exists {
		return nil, fmt.Errorf("unknown action: %s", cmd.Action)
	}
	return handler(cmd.Params)
}

// APIHandler 处理 HTTP 请求
func (i *Interpreter) APIHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	var cmd Command
	if err := json.NewDecoder(r.Body).Decode(&cmd); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	result, err := i.Execute(cmd)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(result)
}

func main() {
	interpreter := NewInterpreter()

	// 注册一个示例处理器
	interpreter.RegisterHandler("echo", func(params map[string]interface{}) (interface{}, error) {
		return params["message"], nil
	})

	http.HandleFunc("/api", interpreter.APIHandler)
	log.Println("Server starting on :8080...")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

2. 使用 Sand 插件库

Sand 是一个 Go 插件系统，允许动态加载和执行 Go 插件。以下是使用 Sand 的示例：

首先安装 Sand:

go get github.com/grafana/sand

然后创建一个插件系统：

package main

import (
	"fmt"
	"log"

	"github.com/grafana/sand"
)

// PluginInterface 定义插件必须实现的接口
type PluginInterface interface {
	Execute(params map[string]interface{}) (interface{}, error)
	Name() string
}

func main() {
	// 创建 Sand 管理器
	manager := sand.NewManager()

	// 加载插件
	plugin, err := manager.Load("./plugins/example.so")
	if err != nil {
		log.Fatalf("Failed to load plugin: %v", err)
	}

	// 获取插件实例
	instance, err := plugin.Instance()
	if err != nil {
		log.Fatalf("Failed to get plugin instance: %v", err)
	}

	// 类型断言确保插件实现了我们的接口
	if pluginImpl, ok := instance.(PluginInterface); ok {
		fmt.Printf("Loaded plugin: %s\n", pluginImpl.Name())
		
		// 执行插件功能
		result, err := pluginImpl.Execute(map[string]interface{}{
			"input": "test data",
		})
		if err != nil {
			log.Printf("Plugin execution error: %v", err)
		} else {
			fmt.Printf("Plugin result: %v\n", result)
		}
	} else {
		log.Fatal("Plugin does not implement the required interface")
	}
}

3. 创建示例插件

创建一个简单的插件：

// go build -buildmode=plugin -o plugins/example.so plugins/example.go
package main

import "fmt"

// ExamplePlugin 实现我们的插件接口
type ExamplePlugin struct{}

func (p *ExamplePlugin) Execute(params map[string]interface{}) (interface{}, error) {
	return fmt.Sprintf("Processed: %v", params["input"]), nil
}

func (p *ExamplePlugin) Name() string {
	return "ExamplePlugin"
}

// Export 的变量名必须为 Plugin
var Plugin ExamplePlugin

4. 结合 API 解释器和 Sand 插件

将两者结合，创建一个支持动态插件的 API 解释器：

func main() {
	interpreter := NewInterpreter()
	manager := sand.NewManager()

	// 加载所有插件
	plugins, err := filepath.Glob("./plugins/*.so")
	if err != nil {
		log.Fatal(err)
	}

	for _, pluginPath := range plugins {
		plugin, err := manager.Load(pluginPath)
		if err != nil {
			log.Printf("Failed to load plugin %s: %v", pluginPath, err)
			continue
		}

		instance, err := plugin.Instance()
		if err != nil {
			log.Printf("Failed to get plugin instance %s: %v", pluginPath, err)
			continue
		}

		if pluginImpl, ok := instance.(PluginInterface); ok {
			interpreter.RegisterHandler(pluginImpl.Name(), pluginImpl.Execute)
			log.Printf("Registered plugin: %s", pluginImpl.Name())
		}
	}

	http.HandleFunc("/api", interpreter.APIHandler)
	log.Println("Server starting on :8080...")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

总结

1. 我们创建了一个基本的 API 解释器，可以处理 JSON 格式的命令
2. 使用 Sand 插件系统动态加载 Go 插件
3. 展示了如何创建兼容的插件
4. 将两者结合，实现了一个支持动态插件的 API 服务

这种方法允许你在不重启服务的情况下，通过添加新的 .so 插件文件来扩展系统功能。Sand 提供了比 Go 标准库 plugin 包更友好的接口和更好的错误处理。