# Go 反射完整指南

Go 中的反射库 reflect 提供了在运行时检查类型和值的能力。它允许程序在运行时获取变量的类型信息，并动态地调用方法或访问字段。

Go 中的反射是建立在类型系统之上的，它与空接口 interface{} 密切相关。反射库 reflect 提供了 Type 和 Value 两个核心类型，分别表示 Go 中的类型和值。

# 为什么需要反射

在以下场景中，反射非常有用：

编写通用代码：如 JSON 序列化 / 反序列化库，需要处理任意类型
ORM 框架：需要将结构体字段映射到数据库列
依赖注入：动态创建和注入对象
框架和库开发：如 Web 框架的路由处理、验证器等

# 核心概念：Type

reflect.Type 是一个接口，它定义了类型相关的操作。通过 reflect.TypeOf() 获取任意值的类型信息。

# Type 的主要方法

	package main

	import (
	"fmt"
	"reflect"
	)

	type Person struct {
	Name string `json:"name" validate:"required"`
	Age int `json:"age" validate:"min=0"`
	}

	func main() {
	p := Person{Name: "Alice", Age: 30}

	// 获取类型
	t := reflect.TypeOf(p)

	// 基本类型信息
	fmt.Println("类型名称:", t.Name()) // Person
	fmt.Println("类型种类:", t.Kind()) // struct
	fmt.Println("包路径:", t.PkgPath()) // main
	fmt.Println("类型大小:", t.Size(), "bytes") // 24 (取决于架构)

	// 遍历结构体字段
	fmt.Println("\n字段详情:")
	for i := 0; i < t.NumField(); i++ {
	field := t.Field(i)
	fmt.Printf("字段 %d:\n", i)
	fmt.Printf(" 名称: %s\n", field.Name)
	fmt.Printf(" 类型: %s\n", field.Type)
	fmt.Printf(" 标签: %s\n", field.Tag)
	fmt.Printf(" JSON标签: %s\n", field.Tag.Get("json"))
	fmt.Printf(" 偏移量: %d\n", field.Offset)
	}
	}

# Kind vs Type

重要区别： Kind() 返回底层类型种类， Type 返回具体类型。

	type MyInt int

	func main() {
	var x MyInt = 10
	t := reflect.TypeOf(x)

	fmt.Println(t.Name()) // MyInt (类型名称)
	fmt.Println(t.Kind()) //int (底层种类)

	// Kind 的所有可能值
	// Invalid, Bool, Int, Int8, Int16, Int32, Int64,
	// Uint, Uint8, ..., Float32, Float64,
	// Complex64, Complex128, Array, Chan, Func,
	// Interface, Map, Pointer, Slice, String, Struct, UnsafePointer
	}

# 核心概念：Value

reflect.Value 是一个结构体，表示 Go 中的值。它提供了读取、修改值以及调用方法的能力。

# Value 的主要方法

	package main

	import (
	"fmt"
	"reflect"
	)

	type Person struct {
	Name string
	Age int
	}

	func main() {
	p := Person{Name: "Alice", Age: 30}

	// 获取值
	v := reflect.ValueOf(p)

	// 基本值信息
	fmt.Println("值类型:", v.Type())
	fmt.Println("值种类:", v.Kind())
	fmt.Println("是否有效:", v.IsValid())
	fmt.Println("是否为零值:", v.IsZero())

	// 遍历字段值
	fmt.Println("\n字段值:")
	for i := 0; i < v.NumField(); i++ {
	field := v.Field(i)
	fieldType := v.Type().Field(i)
	fmt.Printf("%s: %v (类型: %s)\n",
	fieldType.Name,
	field.Interface(),
	field.Type())
	}
	}

# 修改值（可寻址性）

关键点：只有可寻址（addressable）的值才能被修改。

	package main

	import (
	"fmt"
	"reflect"
	)

	type Person struct {
	Name string
	Age int
	}

	func main() {
	// ❌ 错误示例：传递值
	p1 := Person{Name: "Alice", Age: 30}
	v1 := reflect.ValueOf(p1)
	fmt.Println("v1 可设置:", v1.CanSet()) // false
	//v1.FieldByName ("Name").SetString ("Bob") // 会 panic

	// ✅ 正确示例：传递指针
	p2 := Person{Name: "Alice", Age: 30}
	v2 := reflect.ValueOf(&p2) // 传递指针
	fmt.Println("v2 可设置:", v2.CanSet()) //false (指针本身不可设置)

	// 使用 Elem () 获取指针指向的值
	v2Elem := v2.Elem()
	fmt.Println("v2Elem 可设置:", v2Elem.CanSet()) // true

	// 修改字段
	nameField := v2Elem.FieldByName("Name")
	if nameField.CanSet() {
	nameField.SetString("Bob")
	fmt.Println("修改后:", p2) // {Bob 30}
	}

	// 也可以直接通过索引访问
	ageField := v2Elem.Field(1)
	if ageField.CanSet() {
	ageField.SetInt(35)
	fmt.Println("再次修改:", p2) // {Bob 35}
	}
	}

# 使用反射调用方法

	package main

	import (
	"fmt"
	"reflect"
	)

	type Person struct {
	Name string
	Age int
	}

	func (p Person) SayHello() {
	fmt.Printf("Hello, my name is %s\n", p.Name)
	}

	func (p Person) SayAge(prefix string) string {
	return fmt.Sprintf("%s: I am %d years old", prefix, p.Age)
	}

	func (p *Person) SetName(name string) {
	p.Name = name
	}

	func main() {
	p := Person{Name: "Alice", Age: 30}
	v := reflect.ValueOf(p)

	// 调用无参数方法
	m1 := v.MethodByName("SayHello")
	m1.Call(nil) // Hello, my name is Alice

	// 调用带参数的方法
	m2 := v.MethodByName("SayAge")
	args := []reflect.Value{reflect.ValueOf("Info")}
	results := m2.Call(args)
	fmt.Println(results[0].String()) // Info: I am 30 years old

	// 调用指针方法（需要传递指针）
	pv := reflect.ValueOf(&p)
	m3 := pv.MethodByName("SetName")
	m3.Call([]reflect.Value{reflect.ValueOf("Bob")})
	fmt.Println("修改后的名字:", p.Name) // Bob

	// 检查方法是否存在
	if m := v.MethodByName("NonExistent"); m.IsValid() {
	m.Call(nil)
	} else {
	fmt.Println("方法不存在")
	}
	}

# 反射三定律

Go 官方文章 laws-of-reflection 中，介绍了反射的三个定律：

# 第一定律：反射从接口值到反射对象

Reflection goes from interface value to reflection object

反射是用于检查存储在接口变量中的类型和值的机制。

	// TypeOf 用来动态获取输入参数接口中的值的类型
	func TypeOf(i any) Type {
	eface := (emptyInterface)(unsafe.Pointer(&i))
	return toType((*abi.Type)(noescape(unsafe.Pointer(eface.typ))))
	}

	// ValueOf 用来获取输入参数接口中的数据的值
	func ValueOf(i any) Value {
	if i == nil {
	return Value{}
	}
	return unpackEface(i)
	}

转换过程：

Go变量 → interface{} (any) → 反射对象 (Type/Value)

示例：

	var x float64 = 3.4
	t := reflect.TypeOf(x) // 类型: float64
	v := reflect.ValueOf(x) // 值: 3.4

	fmt.Println("type:", t)
	fmt.Println("value:", v)
	fmt.Println("kind:", v.Kind())

# 第二定律：反射从反射对象到接口值

Reflection goes from reflection object to interface value

给定一个 reflect.Value 对象，我们可以使用 Interface() 方法恢复接口值。

func (v Value) Interface() interface{}

示例：

	var x float64 = 3.4
	v := reflect.ValueOf(x)

	// 转换回接口值
	y := v.Interface().(float64) // 需要类型断言
	fmt.Println(y) // 3.4

	// 这实际上是 fmt.Println 的工作原理
	fmt.Println(v.Interface()) // 内部会调用 Interface ()

双向转换：

Go变量 → interface{} → 反射对象
         ↑              ↓
         └──────────────┘
            Interface()

# 第三定律：要修改反射对象，其值必须可设置

To modify a reflection object, the value must be settable

可设置性（Settability） 是 Value 的一个属性，但不是所有 Value 都具有这个属性。

	var x float64 = 3.4
	v := reflect.ValueOf(x)

	// ❌ 这会 panic
	// v.SetFloat(7.1) // panic: reflect: reflect.Value.SetFloat using unaddressable value

	fmt.Println("可设置:", v.CanSet()) // false

为什么不可设置？

因为 v 是 x 的一个副本，不是 x 本身。如果允许修改 v ，那么修改不会影响原始变量 x 。

正确做法：传递指针

	var x float64 = 3.4
	p := reflect.ValueOf(&x) // 注意这里传递的是 &x

	fmt.Println("指针可设置:", p.CanSet()) //false (指针本身不可设置)

	v := p.Elem() // 获取指针指向的值
	fmt.Println("指针指向的值可设置:", v.CanSet()) // true

	v.SetFloat(7.1)
	fmt.Println(x) // 7.1

为什么需要 Elem ()？

reflect.ValueOf(&x) 返回的是指针的 Value
我们需要修改的是指针指向的值，而不是指针本身
Elem() 方法获取指针、接口指向的元素

# 实战示例

# 1. 通用的结构体字段拷贝

	package main

	import (
	"fmt"
	"reflect"
	)

	// CopyFields 将 src 的字段值拷贝到 dst（字段名相同且类型兼容）
	func CopyFields(dst, src interface{}) error {
	dstVal := reflect.ValueOf(dst).Elem()
	srcVal := reflect.ValueOf(src).Elem()

	dstType := dstVal.Type()

	for i := 0; i < dstVal.NumField(); i++ {
	dstField := dstVal.Field(i)
	dstFieldName := dstType.Field(i).Name

	// 在源结构体中查找同名字段
	srcField := srcVal.FieldByName(dstFieldName)
	if !srcField.IsValid() {
	continue // 源结构体中没有该字段
	}

	// 检查类型是否匹配
	if dstField.Type() != srcField.Type() {
	continue // 类型不匹配，跳过
	}

	// 检查是否可设置
	if dstField.CanSet() {
	dstField.Set(srcField)
	}
	}

	return nil
	}

	type Source struct {
	Name string
	Age int
	Email string
	}

	type Destination struct {
	Name string
	Age int
	City string // 这个字段不会被拷贝
	}

	func main() {
	src := &Source{Name: "Alice", Age: 30, Email: "alice@example.com"}
	dst := &Destination{}

	CopyFields(dst, src)
	fmt.Printf("%+v\n", dst) // {Name:Alice Age:30 City:}
	}

# 2. 结构体标签验证器

	package main

	import (
	"fmt"
	"reflect"
	"strconv"
	"strings"
	)

	// Validate 验证结构体字段（简化版）
	func Validate(v interface{}) []string {
	var errors []string
	val := reflect.ValueOf(v)

	// 如果是指针，获取其指向的值
	if val.Kind() == reflect.Ptr {
	val = val.Elem()
	}

	typ := val.Type()

	for i := 0; i < val.NumField(); i++ {
	field := val.Field(i)
	fieldType := typ.Field(i)
	tag := fieldType.Tag.Get("validate")

	if tag == "" {
	continue
	}

	rules := strings.Split(tag, ",")
	for _, rule := range rules {
	if err := validateRule(field, fieldType.Name, rule); err != "" {
	errors = append(errors, err)
	}
	}
	}

	return errors
	}

	func validateRule(field reflect.Value, fieldName, rule string) string {
	if rule == "required" {
	if field.IsZero() {
	return fmt.Sprintf("%s is required", fieldName)
	}
	}

	if strings.HasPrefix(rule, "min=") {
	minStr := strings.TrimPrefix(rule, "min=")
	min, _ := strconv.Atoi(minStr)

	switch field.Kind() {
	case reflect.Int, reflect.Int64:
	if field.Int() < int64(min) {
	return fmt.Sprintf("%s must be >= %d", fieldName, min)
	}
	case reflect.String:
	if len(field.String()) < min {
	return fmt.Sprintf("%s length must be >= %d", fieldName, min)
	}
	}
	}

	return ""
	}

	type User struct {
	Name string `validate:"required,min=3"`
	Email string `validate:"required"`
	Age int `validate:"min=18"`
	}

	func main() {
	user1 := User{Name: "Al", Email: "", Age: 15}
	errors := Validate(user1)
	for _, err := range errors {
	fmt.Println("验证错误:", err)
	}
	// 输出:
	// 验证错误: Name length must be >= 3
	// 验证错误: Email is required
	// 验证错误: Age must be >= 18

	user2 := User{Name: "Alice", Email: "alice@example.com", Age: 25}
	errors = Validate(user2)
	if len(errors) == 0 {
	fmt.Println("验证通过")
	}
	}

# 3. 动态调用函数

	package main

	import (
	"fmt"
	"reflect"
	)

	// CallFunc 动态调用函数
	func CallFunc(fn interface{}, args ...interface{}) []interface{} {
	fnVal := reflect.ValueOf(fn)

	// 检查是否是函数
	if fnVal.Kind() != reflect.Func {
	panic("not a function")
	}

	// 转换参数
	in := make([]reflect.Value, len(args))
	for i, arg := range args {
	in[i] = reflect.ValueOf(arg)
	}

	// 调用函数
	results := fnVal.Call(in)

	// 转换返回值
	out := make([]interface{}, len(results))
	for i, result := range results {
	out[i] = result.Interface()
	}

	return out
	}

	func Add(a, b int) int {
	return a + b
	}

	func Greet(name string) string {
	return "Hello, " + name
	}

	func main() {
	// 调用 Add 函数
	results := CallFunc(Add, 10, 20)
	fmt.Println("Add result:", results[0]) // 30

	// 调用 Greet 函数
	results = CallFunc(Greet, "Alice")
	fmt.Println("Greet result:", results[0]) // Hello, Alice
	}

# 性能考虑

反射是一个强大但代价高昂的特性：

性能损失：反射操作比直接访问慢 10-100 倍
编译时检查缺失：类型错误只能在运行时发现
代码可读性：反射代码通常更难理解和维护

# 性能对比

	package main

	import (
	"reflect"
	"testing"
	)

	type Data struct {
	Value int
	}

	// 直接访问
	func BenchmarkDirect(b *testing.B) {
	d := Data{Value: 42}
	for i := 0; i < b.N; i++ {
	_ = d.Value
	}
	}

	// 反射访问
	func BenchmarkReflect(b *testing.B) {
	d := Data{Value: 42}
	v := reflect.ValueOf(d)
	for i := 0; i < b.N; i++ {
	_ = v.FieldByName("Value").Int()
	}
	}

	// 运行结果示例（相对值）：
	// BenchmarkDirect 1000000000 0.25 ns/op
	// BenchmarkReflect 50000000 30.00 ns/op
	// 反射慢约 120 倍

# 何时使用反射

✅ 应该使用：

编写通用库和框架
JSON/XML 等序列化库
ORM 和数据库映射
依赖注入容器
插件系统

❌ 应该避免：

常规业务逻辑
性能敏感的代码
可以用泛型或接口解决的问题

# 常见陷阱

# 1. 未导出字段不可访问

	type Person struct {
	name string // 小写，未导出
	Age int // 大写，已导出
	}

	p := Person{name: "Alice", Age: 30}
	v := reflect.ValueOf(&p).Elem()

	// ✅ 可以读取未导出字段的值
	name := v.FieldByName("name")
	fmt.Println(name.String()) // Alice

	// ❌ 不能设置未导出字段
	// name.SetString("Bob") // panic

# 2. nil 和零值的区别

	var p *Person = nil
	v := reflect.ValueOf(p)

	fmt.Println(v.IsValid()) //true (Value 是有效的)
	fmt.Println(v.IsNil()) //true (指针是 nil)
	fmt.Println(v.IsZero()) //true (零值)

	// ❌ 不能对 nil 指针调用 Elem ()
	// v.Elem() // panic

# 3. Kind vs Type

	type MyInt int

	var x MyInt = 10
	v := reflect.ValueOf(x)

	// Kind 是底层类型
	fmt.Println(v.Kind() == reflect.Int) // true

	// Type 是具体类型
	fmt.Println(v.Type().Name() == "int") // false
	fmt.Println(v.Type().Name() == "MyInt") // true

# 总结

反射是 Go 语言中一个非常强大的特性，它提供了：

运行时类型检查：通过 reflect.TypeOf() 获取类型信息
动态值操作：通过 reflect.ValueOf() 读取和修改值
方法调用：动态调用结构体方法
结构体标签：访问字段标签进行元编程

使用原则：

反射应该作为最后手段，优先考虑接口、泛型等方案
只在确实需要通用性和动态性的场景使用
注意性能影响，避免在热路径中使用
充分测试反射代码，因为编译器无法帮你检查类型错误

三定律口诀：

变量 → 反射对象（TypeOf / ValueOf）
反射对象 → 变量（Interface ()）
修改值需指针 + Elem ()

# 参考资料

The Laws of Reflection
reflect 包文档
Go 语言设计与实现 - 反射

reflect