本文详解如何通过反射将已注册的服务实例（如 *Concrete）正确赋值给目标变量（如 *Concrete 或 Doer 接口），解决常见的 reflect.Value.Set using unaddressable value panic 问题。

本文详解如何通过反射将已注册的服务实例（如 `*concrete`）正确赋值给目标变量（如 `*concrete` 或 `doer` 接口），解决常见的 `reflect.value.set using unaddressable value` panic 问题。

在 Go 的反射编程中，为指针或接口变量赋值需严格满足「可寻址性（addressable）」和「可设置性（settable）」两个前提。核心原则是：*只有 reflect.Value 表示一个可寻址的变量时，才能调用 .Set() 方法；而传入 Get 函数的参数若为值类型（如 `y Concrete），其反射值默认不可寻址——必须传入其地址（如&y`）才能修改原变量。**

以下为关键实践要点与修正后的完整服务定位器实现：

✅ 正确赋值的两种典型场景

1. 向接口变量赋值（如 Doer）

接口变量本身可寻址，且 reflect.ValueOf(&x).Elem() 是可设置的：

var x Doer
l.Get(&x) // 注意：传 &x，而非 x
if x != nil {
    x.Do() // 成功调用
}

2. 向结构体指针变量赋值（如 *Concrete）

必须传入该指针变量的地址（即 **Concrete），再通过 .Elem().Set() 设置其值：

var y *Concrete
l.Get(&y) // 关键：传 &y，使反射能定位到 y 的内存位置
if y != nil {
    fmt.Println("by struct pointer ok")
}

? 修正后的 Get 方法逻辑（关键修复点）

func (s *ServiceLocator) Get(dst interface{}) bool {
    dstVal := reflect.ValueOf(dst)
    if dstVal.Kind() != reflect.Ptr || dstVal.IsNil() {
        return false
    }

    elem := dstVal.Elem() // 获取目标变量（如 *Concrete 或 Doer）本身
    if !elem.CanSet() {
        return false
    }

    dstType := elem.Type()
    for i, regType := range s.types {
        switch elem.Kind() {
        case reflect.Interface:
            // 目标是接口：检查注册值是否实现该接口
            if regType.Implements(dstType) {
                elem.Set(s.values[i])
                return true
            }
        case reflect.Ptr:
            // 目标是结构体指针：检查注册值是否为同类型指针且可赋值
            if regType.Kind() == reflect.Ptr && 
               dstType.Elem().AssignableTo(regType.Elem()) {
                elem.Set(s.values[i])
                return true
            }
        }
    }
    return false
}

⚠️ 注意事项：

• reflect.ValueOf(dst).Elem() 必须可设置（.CanSet() 返回 true），这要求 dst 是指向变量的指针（非 nil），且该变量本身未被“冻结”（如字面量、函数返回值等不可寻址）。
• 不要直接对 reflect.ValueOf(y)（其中 y 是 *Concrete）调用 .Set() —— 它表示的是指针值本身，不可设置；应使用 reflect.ValueOf(&y).Elem().Set(...)。
• Register 应统一存储 reflect.Value 而非原始接口，避免后续类型擦除；同时确保注册值为指针（如 &Concrete{}），以支持接口赋值。

✅ 完整可运行示例（精简版）

package main

import (
    "fmt"
    "reflect"
)

type Concrete struct{}
func (*Concrete) Do() { fmt.Println("Concrete.Do") }

type Doer interface { Do() }

type ServiceLocator struct {
    values []reflect.Value
}

func (s *ServiceLocator) Register(v interface{}) {
    s.values = append(s.values, reflect.ValueOf(v))
}

func (s *ServiceLocator) Get(dst interface{}) bool {
    dstVal := reflect.ValueOf(dst)
    if dstVal.Kind() != reflect.Ptr || dstVal.IsNil() {
        return false
    }
    elem := dstVal.Elem()
    if !elem.CanSet() {
        return false
    }

    for _, v := range s.values {
        if elem.Kind() == reflect.Interface {
            if v.Type().Implements(elem.Type()) {
                elem.Set(v)
                return true
            }
        } else if elem.Kind() == reflect.Ptr && 
                   v.Type().AssignableTo(elem.Type()) {
            elem.Set(v)
            return true
        }
    }
    return false
}

func main() {
    l := ServiceLocator{}
    l.Register(&Concrete{})

    var x Doer
    if l.Get(&x) {
        x.Do() // 输出: Concrete.Do
    }

    var y *Concrete
    if l.Get(&y) {
        fmt.Println("y is set:", y != nil) // 输出: y is set: true
    }
}

总结：Go 反射赋值的核心在于 明确目标变量的可寻址路径 —— 始终传递变量地址（&var），通过 .Elem() 获取其值，并验证 .CanSet() 后再执行 .Set()。忽略这一层间接性，是导致 unaddressable value panic 的根本原因。