Go 语言 (*Type)(nil) 表达式：接口类型与依赖注入中的应用解析

func (inj *injector) MapTo(val interface{}, iface interface{}) reflect.Value

package main

import (
    "fmt"
    "net/http"
    "reflect"
)

// 模拟一个简单的依赖注入器
type MyInjector struct {
    mappings map[reflect.Type]reflect.Value
}

func NewMyInjector() *MyInjector {
    return &MyInjector{
        mappings: make(map[reflect.Type]reflect.Value),
    }
}

// MapTo 模拟 inject.MapTo，将一个值映射到一个接口类型
func (inj *MyInjector) MapTo(val interface{}, ifaceType interface{}) {
    // 获取 ifaceType 的反射类型
    // 这里的 ifaceType 通常是一个 (*SomeConcreteType)(nil) 或 (SomeInterface)(nil)
    typ := reflect.TypeOf(ifaceType)

    // 关键：如果 ifaceType 是一个指针类型，我们通常关心它所指向的元素类型
    // 例如，如果传入的是 (*http.ResponseWriter)(nil)，typ 是 *http.ResponseWriter
    // 我们可能想映射到 http.ResponseWriter 接口本身
    if typ.Kind() == reflect.Ptr {
        typ = typ.Elem() // 获取指针指向的元素类型
    }

    fmt.Printf("Mapping concrete type %v to interface type %v\n", reflect.TypeOf(val), typ)
    inj.mappings[typ] = reflect.ValueOf(val)
}

// Get 模拟获取一个接口的实现
func (inj *MyInjector) Get(ifaceType interface{}) (interface{}, bool) {
    typ := reflect.TypeOf(ifaceType)
    if typ.Kind() == reflect.Ptr {
        typ = typ.Elem()
    }

    if val, ok := inj.mappings[typ]; ok {
        return val.Interface(), true
    }
    return nil, false
}

// 模拟一个实现了 http.ResponseWriter 接口的结构体
type MockResponseWriter struct{}

func (m *MockResponseWriter) Header() http.Header { return nil }
func (m *MockResponseWriter) Write([]byte) (int, error) { return 0, nil }
func (m *MockResponseWriter) WriteHeader(statusCode int) {}

func main() {
    injector := NewMyInjector()

    // 假设我们有一个 MockResponseWriter 的实例
    mockWriter := &MockResponseWriter{}

    // 使用 (*http.ResponseWriter)(nil) 来获取 http.ResponseWriter 接口的类型信息
    // 这里的 (*http.ResponseWriter)(nil) 实际上是获取 *MockResponseWriter 类型的零值
    // 如果 http.ResponseWriter 是一个接口，那么 typ.Elem() 会得到这个接口类型
    // 如果 http.ResponseWriter 是一个具体类型，那么 typ.Elem() 会得到这个具体类型
    // 在 Go 的标准库中，http.ResponseWriter 是一个接口
    injector.MapTo(mockWriter, (*http.ResponseWriter)(nil))

    // 尝试获取 http.ResponseWriter 的实现
    ifaceVal, ok := injector.Get((*http.ResponseWriter)(nil))
    if ok {
        writer, assertOk := ifaceVal.(http.ResponseWriter)
        if assertOk {
            fmt.Printf("Successfully retrieved mapped writer: %T\n", writer)
        }
    }

    // 另一个例子：映射一个具体的结构体类型
    type MyService struct {
        Name string
    }
    myService := &MyService{Name: "TestService"}
    injector.MapTo(myService, (*MyService)(nil)) // 映射 MyService 的指针类型

    ifaceVal2, ok := injector.Get((*MyService)(nil))
    if ok {
        service, assertOk := ifaceVal2.(*MyService)
        if assertOk {
            fmt.Printf("Successfully retrieved mapped service: %+v\n", service)
        }
    }
}

Mapping concrete type *main.MockResponseWriter to interface type http.ResponseWriter
Successfully retrieved mapped writer: *main.MockResponseWriter
Mapping concrete type *main.MyService to interface type main.MyService
Successfully retrieved mapped service: &{Name:TestService}