Golang如何使用reflect创建实例_Golang reflect实例创建实践

package main

import (
    "fmt"
    "reflect"
)

type MyStruct struct {
    Name string
    Age  int
}

func main() {
    // 1. 获取目标类型的 reflect.Type
    // 我们可以通过一个已存在的实例或者直接通过类型本身获取
    // 方式一：通过一个实例获取其类型
    var s MyStruct
    typeOfMyStruct := reflect.TypeOf(s)
    fmt.Printf("通过实例获取的类型: %v\n", typeOfMyStruct) // main.MyStruct

    // 方式二：直接通过类型字面量获取 (更常用，尤其是在不知道具体实例时)
    typeOfMyStructPtr := reflect.TypeOf(&MyStruct{}) // 注意这里获取的是指针类型 *MyStruct
    fmt.Printf("通过指针实例获取的类型: %v\n", typeOfMyStructPtr) // *main.MyStruct

    // 如果我们想创建的是 MyStruct 而不是 *MyStruct，需要先获取其元素类型
    typeOfMyStructElem := typeOfMyStructPtr.Elem()
    fmt.Printf("获取的元素类型: %v\n", typeOfMyStructElem) // main.MyStruct

    // 2. 使用 reflect.New 创建实例
    // reflect.New 接受一个 reflect.Type，返回一个 reflect.Value，
    // 这个 Value 代表一个指向新分配的零值的指针。
    // 例如，如果 typeOfMyStructElem 是 MyStruct，那么 newStructPtrValue 将是 *MyStruct
    newStructPtrValue := reflect.New(typeOfMyStructElem)
    fmt.Printf("新创建的实例指针类型: %v, 值: %v\n", newStructPtrValue.Type(), newStructPtrValue)
    // 输出: 新创建的实例指针类型: *main.MyStruct, 值: <*main.MyStruct Value>

    // 3. 将 reflect.Value 转换为实际的 Go 接口或类型
    // 使用 Interface() 方法获取其底层接口值，然后进行类型断言
    // 记住 newStructPtrValue 是一个指针，所以断言时也要断言为指针类型
    if actualStructPtr, ok := newStructPtrValue.Interface().(*MyStruct); ok {
        actualStructPtr.Name = "Reflect Created"
        actualStructPtr.Age = 30
        fmt.Printf("通过反射创建并赋值后的实例: %+v\n", *actualStructPtr)
    } else {
        fmt.Println("类型断言失败")
    }

    // 另一种常见场景是，我们可能只有类型名字符串，需要通过注册机制来获取 reflect.Type
    // 假设我们有一个类型注册表
    typeRegistry := make(map[string]reflect.Type)
    typeRegistry["MyStruct"] = reflect.TypeOf(MyStruct{})

    if t, found := typeRegistry["MyStruct"]; found {
        // 注意这里 t 是 MyStruct 类型， reflect.New(t) 返回的是 *MyStruct
        dynamicNewPtrValue := reflect.New(t)
        if dynamicInstance, ok := dynamicNewPtrValue.Interface().(*MyStruct); ok {
            dynamicInstance.Name = "Dynamic Instance"
            dynamicInstance.Age = 25
            fmt.Printf("通过注册表动态创建的实例: %+v\n", *dynamicInstance)
        }
    }
}

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name    string // 导出字段
    age     int    // 未导出字段
    Address string
}

func main() {
    userType := reflect.TypeOf(User{})
    newUserPtrValue := reflect.New(userType) // newUserPtrValue 是 *User 的 reflect.Value

    // 获取 newUserPtrValue 所指向的实际 User 结构体的值
    // 只有通过 Elem() 获取到的 reflect.Value 才能修改其内部字段
    newUserValue := newUserPtrValue.Elem() // newUserValue 是 User 的 reflect.Value

    // 检查 newUserValue 是否可设置
    fmt.Printf("newUserValue 可设置吗？ %v\n", newUserValue.CanSet()) // 通常是 true

    // 通过字段名获取字段的 reflect.Value
    nameField := newUserValue.FieldByName("Name")
    if nameField.IsValid() && nameField.CanSet() {
        nameField.SetString("Alice")
        fmt.Println("Name 字段设置成功。")
    } else {
        fmt.Println("Name 字段无法设置或不存在。")
    }

    ageField := newUserValue.FieldByName("age") // 尝试获取未导出字段
    if ageField.IsValid() && ageField.CanSet() {
        // 这里的 ageField.CanSet() 会是 false，因为 age 是未导出字段
        ageField.SetInt(30) // 这一行会导致 panic
        fmt.Println("Age 字段设置成功。")
    } else {
        fmt.Printf("Age 字段无法设置或不存在。CanSet() 返回: %v\n", ageField.CanSet())
    }

    addressField := newUserValue.FieldByName("Address")
    if addressField.IsValid() && addressField.CanSet() {
        addressField.SetString("123 Main St")
    }

    // 打印最终的实例
    if actualUser, ok := newUserPtrValue.Interface().(*User); ok {
        fmt.Printf("最终用户实例: %+v\n", *actualUser)
    }
}