Go语言中动态实例化接口类型的策略与实践

type Handler interface {
    Handle()
}

type MyHandler struct {
    // ...
}

func (this *MyHandler) Handle() {
    // ... 具体处理逻辑
}

type Routing map[string]Handler // 这是一个存储Handler接口实例的map

// 假设我们希望这样初始化并使用，但这是不正确的：
// routes := Routing {
//     "/route/here": MyHandler, // 错误：MyHandler是一个类型，不是Handler接口的实例
// }
//
// new(routes["/route/here"]).Handle() // 错误：routes["/route/here"]不是一个类型

package main

import "fmt"

// 定义Handler接口
type Handler interface {
    Handle()
}

// 定义MyHandler类型，它实现了Handler接口
type MyHandler struct {
    ID int
}

func (h *MyHandler) Handle() {
    fmt.Printf("Handling request with MyHandler instance ID: %d\n", h.ID)
}

// 定义Routing类型，现在它存储的是工厂函数
type Routing map[string]func() Handler

func main() {
    // 初始化路由表，每个键对应一个工厂函数
    // 工厂函数负责创建并返回MyHandler的新实例
    // 注意：这里返回的是指针&MyHandler{}，因为Handle方法接收者是*MyHandler
    var instanceCounter int
    routes := Routing{
        "/route/here": func() Handler {
            instanceCounter++
            return &MyHandler{ID: instanceCounter} // 每次调用都返回一个新的MyHandler实例
        },
        "/another/route": func() Handler {
            // 可以为其他路由定义不同的Handler实现
            return &MyHandler{ID: 999}
        },
    }

    // 动态创建并使用Handler实例
    fmt.Println("--- 第一次调用 ---")
    routes["/route/here"]().Handle() // 调用工厂函数，获取新实例，然后调用Handle
    routes["/route/here"]().Handle() // 再次调用，获取另一个新实例
    routes["/another/route"]().Handle()

    fmt.Println("\n--- 第二次调用 ---")
    handlerInstance1 := routes["/route/here"]() // 获取一个新实例
    handlerInstance1.Handle()

    handlerInstance2 := routes["/route/here"]() // 获取另一个新实例
    handlerInstance2.Handle()

    // 验证实例是否不同
    fmt.Printf("Instance 1 ID: %d, Instance 2 ID: %d\n", handlerInstance1.(*MyHandler).ID, handlerInstance2.(*MyHandler).ID)
}

package main

import (
    "fmt"
    "reflect"
)

// 定义Handler接口
type Handler interface {
    Handle()
}

// 定义MyHandler类型
type MyHandler struct {
    ID int
}

func (h *MyHandler) Handle() {
    fmt.Printf("Handling request with MyHandler instance ID: %d (via reflect)\n", h.ID)
}

// 定义Routing类型，现在它存储的是reflect.Type
type Routing map[string]reflect.Type

func main() {
    // 初始化路由表，存储MyHandler的reflect.Type
    // 注意：reflect.TypeOf(MyHandler{}) 获取的是MyHandler的值类型
    routes := Routing{
        "/route/here": reflect.TypeOf(MyHandler{}),
    }

    // 动态创建并使用Handler实例
    fmt.Println("--- 第一次调用 (反射) ---")
    // 1. 使用reflect.New创建MyHandler的指针类型实例（reflect.Value）
    //    reflect.New(routes["/route/here"]) 返回 *MyHandler 的 reflect.Value
    // 2. .Interface() 将 reflect.Value 转换为 interface{}
    // 3. .(Handler) 进行类型断言，将其转换为 Handler 接口
    instance1 := reflect.New(routes["/route/here"]).Interface().(Handler)
    instance1.(*MyHandler).ID = 1 // 设置ID
    instance1.Handle()

    instance2 := reflect.New(routes["/route/here"]).Interface().(Handler)
    instance2.(*MyHandler).ID = 2 // 设置ID
    instance2.Handle()

    // 验证实例是否不同
    fmt.Printf("Instance 1 ID: %d, Instance 2 ID: %d\n", instance1.(*MyHandler).ID, instance2.(*MyHandler).ID)

    // 警告：如果MyHandler不实现Handler接口，此行会引发运行时panic
    // var BadHandler reflect.Type = reflect.TypeOf(struct{}{})
    // reflect.New(BadHandler).Interface().(Handler).Handle()
}