Golang反射与闭包结合使用技巧

package main

import (
    "fmt"
    "reflect"
)

// Service 模拟一个可能需要被注入到动态调用中的服务或上下文
type Service struct {
    Name string
}

// Log 模拟服务提供的日志功能
func (s *Service) Log(msg string) {
    fmt.Printf("[%s Service] %s\n", s.Name, msg)
}

// Plugin 模拟一个插件结构体，包含一些方法
type Plugin struct {
    ID string
}

// ProcessData 插件的一个方法，处理字符串数据
func (p *Plugin) ProcessData(data string) string {
    return fmt.Sprintf("Plugin %s processed: %s", p.ID, data)
}

// AnotherAction 插件的另一个方法，处理整数数据
func (p *Plugin) AnotherAction(value int) int {
    return value * 2
}

// DynamicCaller 结合反射与闭包，创建一个动态调用器。
// 它接收一个实例、方法名和一个Service，返回一个函数（闭包）。
// 这个闭包封装了反射调用逻辑，并利用捕获的Service进行前置/后置处理。
func DynamicCaller(instance interface{}, methodName string, service *Service) func([]reflect.Value) []reflect.Value {
    // 获取实例的反射值
    val := reflect.ValueOf(instance)
    // 获取指定方法
    method := val.MethodByName(methodName)

    if !method.IsValid() {
        // 如果方法不存在，返回一个错误处理闭包
        return func([]reflect.Value) []reflect.Value {
            service.Log(fmt.Sprintf("ERROR: Method '%s' not found on %T", methodName, instance))
            return nil
        }
    }

    // 返回一个闭包。这个闭包捕获了 'method' 和 'service'。
    // 每次调用返回的这个函数时，它都会使用捕获的 'method' 进行反射调用，
    // 并使用捕获的 'service' 进行日志记录。
    return func(args []reflect.Value) []reflect.Value {
        // 前置处理：使用捕获的service记录日志
        service.Log(fmt.Sprintf("准备调用方法 '%s' on %T，参数: %v", methodName, instance, args))

        // 使用反射实际调用方法
        results := method.Call(args)

        // 后置处理：使用捕获的service记录结果
        service.Log(fmt.Sprintf("方法 '%s' on %T 调用完成，结果: %v", methodName, instance, results))
        return results
    }
}

func main() {
    // 初始化一个共享服务
    myService := &Service{Name: "CoreLogger"}

    // 初始化两个插件实例
    pluginA := &Plugin{ID: "A"}
    pluginB := &Plugin{ID: "B"}

    // 为Plugin A的ProcessData方法创建动态调用器
    // 这个调用器是一个闭包，它捕获了 pluginA.ProcessData 的反射值和 myService 实例
    processA := DynamicCaller(pluginA, "ProcessData", myService)

    // 为Plugin B的AnotherAction方法创建动态调用器
    // 同样，这个调用器是一个闭包，捕获了 pluginB.AnotherAction 的反射值和 myService 实例
    actionB := DynamicCaller(pluginB, "AnotherAction", myService)

    // 调用 Plugin A 的 ProcessData 方法
    fmt.Println("\n--- 调用 Plugin A 的 ProcessData 方法 ---")
    // 注意：这里需要将参数转换为 reflect.Value 类型
    resA := processA([]reflect.Value{reflect.ValueOf("一些输入数据")})
    if len(resA) > 0 {
        fmt.Printf("Plugin A 返回结果: %s\n", resA[0].String())
    }

    // 调用 Plugin B 的 AnotherAction 方法
    fmt.Println("\n--- 调用 Plugin B 的 AnotherAction 方法 ---")
    resB := actionB([]reflect.Value{reflect.ValueOf(20)})
    if len(resB) > 0 {
        fmt.Printf("Plugin B 返回结果: %d\n", resB[0].Int())
    }

    // 尝试调用一个不存在的方法
    fmt.Println("\n--- 尝试调用一个不存在的方法 ---")
    nonExistent := DynamicCaller(pluginA, "NonExistentMethod", myService)
    nonExistent(nil) // 这里传入 nil 是因为我们知道方法不存在，参数无关紧要
}

DynamicCaller

instance

Service

instance

method

Service

Service

method.Call(args)

Service

myService