Golang反射：异步返回零值并延迟.Set()操作

Golang反射：异步返回零值并延迟.Set()操作

大家好！

最近我开始编写一个IoC实现，并想到使用通道作为异步获取元素的方式。但这需要用户与容器重新同步（否则容器不知道客户端何时完成了对给定元素的业务处理）。

于是我想出的解决方案是编写一个通道包装器，并使用反射在值准备就绪时立即设置它。以下是我当前的代码：

```go
// 已移除一些繁琐的类型检查和错误检查
func (cont *IoCContainer) Get(i interface{}) interface{} {
    val := reflect.ValueOf(i)

    // 这里执行"隐藏魔法"，获取一个通道，该通道在容器初始化完成后会触发所需元素
    ch := cont.GetChannel(i)

    // 这里获取元素类型的新指针（这就是我们要返回的内容）
    ret := reflect.New(val.Type().Elem())

    go func() {
        // 等待容器完成其工作
        got := reflect.ValueOf(<-ch)

        // 调用辅助方法，将其"转换"为正确类型
        // （例如我们需要*MyStruct，但得到的是**MyStruct）
        wanted := getNormalizedValue(val.Type(), got)

        // 设置元素值，以便引用
        ret.Elem().Set(wanted.Elem())

        // 通知容器我们已完成必要操作，下一个通道可以被填充
        ch <- nil
    }()
    return ret.Interface()
}

这个方案运行得相当不错。当我使用可解析的（指针！）类型调用此函数时，它首先返回垃圾值，之后在调用IoCContainer.Init()后，它会发布到通道并设置值。

但有一个问题。立即返回的值不是nil指针，而是指向零值的指针。这意味着如果粗心的客户端在容器上调用Init之前就对返回值调用了函数，基本上无法区分容器返回的值恰好是零值，还是容器未初始化且函数调用过早。

最后，在所有这些冗长的说明之后（对此表示歉意），我的问题是：

如何返回一个nil指针，并在之后将其设置为实际值？

以下是我尝试过但失败的一些方法：

// 在初始化时
ret := reflect.New(val.Type())
// 在go协程中
ret.Elem().Set(wanted)
// 在返回语句中
return ret.Elem().Interface()
// 失败，因为即使在Init之后，获取的值仍然为nil


// 使用reflect.Zero而不是reflect.New
ret := reflect.Zero(val.Type())
ret.Set(wanted) // panic: reflect: reflect.Value.Set using unaddressable value
ret.Interface()

// 使用Zero配合ret.Elem()
ret := reflect.Zero(val.Type())
ret.Elem().Set(wanted.Elem()) // panic: reflect: call of reflect.Value.Set on zero Value
ret.Interface()

// 使用实际的interface{}而不是reflect值
// 初始化时
temp := reflect.New(val.Type()).Elem().Interface()
ret := &temp
// 在go协程中
*ret = wanted.Interface{} // 值未更新（保持为nil）
// 在返回语句中
return *ret

更多关于Golang反射：异步返回零值并延迟.Set()操作的实战教程也可以访问 https://www.itying.com/category-94-b0.html

5 回复

嗯，一个容器包含多个服务……

想想 Java 的 Spring 框架中的依赖注入和控制反转，这正是我想要在更小规模上模拟的功能。

更多关于Golang反射：异步返回零值并延迟.Set()操作的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


感谢您进一步解释这个场景。让 MustInit() 返回容器怎么样？

var fromContainer *MyService // nil

func main() {
	fromContainer = ioc.MustInit()
	fromContainer.SayHello()
}

我很好奇您最初为什么要使用空接口和反射。正如您所说，原始问题是客户端需要从某个容器异步接收元素，并在完成处理该元素时向容器发送信号。

我很确定这完全可以不使用空接口和反射来实现。

znert: 每当我使用可解析（指针！）类型调用此函数时，它首先返回垃圾数据，

如果您允许函数返回垃圾数据，那么请同时传递一个标志来指示返回值是否有效。Go语言中的"comma, ok"惯用法是实现这一点的标准方式，例如：

val, ok := getSomeValueThatMayBeInvalid()
if !ok {
    // 执行某些操作，例如等待一段时间或返回错误
}
// 此时val绝对是有效的

但由于客户端和容器是异步通信的，为什么不等到第一个有效值可用时再发送数据呢？

感谢您的回复，很高兴有人对这个话题感兴趣 🙂

使用"value, ok"方式初始化变量的问题在于获取实例会变得相当复杂。我想也许一个（可运行的）示例可以澄清一些事情（再次抱歉，这也会是一个很长的帖子…）

// MyService 是一个示例服务。
// 我们希望容器管理这个服务的实例。
type MyService struct {
	name string
}

// SayHello 将打印出 Hello World 消息。
func (m *MyService) SayHello() {
	fmt.Println("Hello World! May name is", m.name)
}

// 某个 .go 文件（提供者）必须将服务注册到 IoC 容器
var myService = ioc.MustRegister(&MyService{
	name: "Ada Lovelace",
}).(*MyService)

// 某个消费者希望将服务作为全局变量。
//
// 给出你想要获取类型的指针值。
var fromContainer = ioc.MustGet((*MyService)(nil)).(*MyService)

func main() {

	// go 的 init() 已完成。当前 fromContainer 是指向零值的指针（但我希望它是 nil）

	// 主线程调用 Init 函数
	ioc.MustInit()

	// fromContainer 现在不为 nil
	fromContainer.SayHello()

	// 输出：Hello World! May name is Ada Lovelace
}

明白我想要达到的目标了吗？

使用"value, ok"方式需要每个服务的消费者都需要某种初始化函数，然后为所有需要的值调用 get，执行某种工厂，设置所有值等等，这些都是我不希望客户端做的事情。相反，只需调用 ioc.Init()，然后你就可以立即做你的事情，我会为你处理一切 😉

在Go语言中，通过反射实现异步返回nil指针并在后续设置实际值是可行的。关键在于正确使用反射API来处理指针的间接层级。以下是解决方案：

func (cont *IoCContainer) Get(i interface{}) interface{} {
    val := reflect.ValueOf(i)
    
    // 检查输入类型是否为指针类型
    if val.Kind() != reflect.Ptr {
        panic("Get requires a pointer type as input")
    }
    
    ch := cont.GetChannel(i)
    
    // 创建目标类型的nil指针
    // 使用reflect.New创建指向该类型的指针，然后设置为nil
    ptrType := reflect.PtrTo(val.Type().Elem())
    ret := reflect.New(ptrType).Elem()
    ret.Set(reflect.Zero(ptrType))
    
    go func() {
        // 等待容器完成工作
        got := reflect.ValueOf(<-ch)
        
        // 规范化值到正确类型
        wanted := getNormalizedValue(val.Type(), got)
        
        // 只有当接收到有效值时才设置
        if !wanted.IsNil() {
            // 创建新的指针并设置值
            newPtr := reflect.New(val.Type().Elem())
            newPtr.Elem().Set(wanted.Elem())
            ret.Set(newPtr)
        }
        
        // 通知容器操作完成
        ch <- nil
    }()
    
    return ret.Interface()
}

更简洁的替代方案：

func (cont *IoCContainer) Get(i interface{}) interface{} {
    val := reflect.ValueOf(i)
    
    if val.Kind() != reflect.Ptr {
        panic("Get requires a pointer type as input")
    }
    
    ch := cont.GetChannel(i)
    elemType := val.Type().Elem()
    
    // 创建指向目标类型的指针的指针
    ret := reflect.New(reflect.PtrTo(elemType))
    ret.Elem().Set(reflect.Zero(reflect.PtrTo(elemType)))
    
    go func() {
        got := reflect.ValueOf(<-ch)
        wanted := getNormalizedValue(val.Type(), got)
        
        if !wanted.IsNil() {
            // 直接设置指针值
            ret.Elem().Set(wanted)
        }
        
        ch <- nil
    }()
    
    return ret.Elem().Interface()
}

使用示例：

type MyStruct struct {
    Data string
}

func (m *MyStruct) Process() string {
    if m == nil {
        return "nil pointer"
    }
    return m.Data
}

// 调用代码
var result *MyStruct
container.Get(&result)

// 此时result为nil
fmt.Println(result == nil) // 输出: true

// 容器初始化后，result会被设置为实际值

关键点：

  1. 使用reflect.Zero()创建对应指针类型的零值（nil）
  2. 正确处理指针的间接层级 - 需要返回指向指针的指针
  3. 在goroutine中通过Set()方法更新指针值
  4. 客户端可以通过简单的nil检查来区分容器是否已初始化

这种方法确保了初始返回值为nil指针，在容器初始化后会被正确设置为实际值。

回到顶部