2.5 反射：夜班证件扫描仪

2.5 反射：夜班证件扫描仪

本节摘要：反射让程序在运行时读取乃至改写变量的类型信息与值，是序列化、配置绑定、依赖注入等框架能力的底层机制。本节讲 Type 与 Value 两把钥匙、结构体标签的读取，以及反射的代价与使用边界。学完本节，你能读懂主流库的反射代码，也能判断自己的代码何时该绕开它。

前面四节讲的都是编译期确定的类型，本节反着问一个问题：如果值的类型要到运行时才知道，程序还能检查它、遍历它、甚至修改它吗？能，工具就是反射。它像值班室门口的证件扫描仪——不看你的工牌名字，直接扫证件本身。本章到此收口，反射也是全章难度最高、最该克制使用的一节。

两把钥匙：Type 与 Value

package main

import (
	"fmt"
	"reflect"
)

type Task struct {
	ID    int
	Title string
}

func inspect(v any) {
	t := reflect.TypeOf(v)    // 钥匙一：静态类型信息
	val := reflect.ValueOf(v) // 钥匙二：值及其可操作性

	fmt.Println("类型名:", t.Name(), "种类:", t.Kind())
	fmt.Println("字段数:", t.NumField())
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		fmt.Printf("  字段 %s 类型 %s 值 %v\n", f.Name, f.Type, val.Field(i))
	}
}

func main() {
	inspect(Task{ID: 7, Title: "巡检机房"})
	inspect(3.14)
}
// 运行输出:
// 类型名: Task 种类: struct
// 字段数: 2
//   字段 ID 类型 int 值 7
//   字段 Title 类型 string 值 巡检机房
// 类型名:  种类: float64
​

Type 回答"你是什么类型"，Value 回答"你的值是多少、能不能改"。注意 Name 与 Kind 的区别：Name 是具体类型名（Task），Kind 是底层种类（struct）；匿名结构体的 Name 为空，Kind 永远有值。框架代码判断"是不是切片、是不是映射"时看的都是 Kind。

字段标签：反射最成功的应用

结构体标签是跟在字段后面的元数据字符串，JSON 序列化、ORM 表列映射全靠它。自己遍历标签，就能看懂那些框架的魔法：

package main

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

type Order struct {
	ID    int    `json:"id" db:"order_id"`
	Items string `json:"items" db:"-"`
}

func tagTable(v any) {
	t := reflect.TypeOf(v)
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		jsonTag := f.Tag.Get("json")
		dbTag := f.Tag.Get("db")
		fmt.Printf("%s -> json:%s db:%s\n", f.Name, jsonTag, dbTag)
	}
}

func main() {
	tagTable(Order{})
}
// 运行输出:
// ID -> json:id db:order_id
// Items -> json:items db:-
​

标签格式是键值对列表，Get 方法按键取值；短横线是社区惯例，表示"序列化或映射时跳过该字段"。看懂这一段，再看序列化库把结构体转成 JSON 的过程，就是"反射遍历字段加读标签加按标签输出"三步曲，没有玄学。

代价与边界：扫描仪很慢，别拿它值流水线

反射绕过了编译期的类型检查与内联优化，基准测试里通常比直接访问慢一个数量级以上；反射出来的接口值还可能触发内存逃逸。三条边界请记牢：

• 热路径不用反射：每秒百万次的解析循环里，反射的开销会直接写进延迟曲线。序列化库为速度都提供代码生成方案，就是这个原因。
• 修改值先判 CanSet：反射修改变量要求传入可寻址的值（传指针再取元素），CanSet 为 false 时强行 Set 会 panic。
• 能接口就别反射：如果能力可以用接口方法表达，接口的分派成本远低于反射；反射留给"类型集合无法穷举"的场景，如通用配置绑定。

完整案例：迷你配置绑定器

背景：服务配置从环境变量读入，字段有十几个，逐字段手写赋值冗长且容易漏。

操作：写一个 bind 函数：反射遍历配置结构体的字段，读 env 标签拿到环境变量名，从环境中读值后按字段类型填入。这正是各类配置库的核心逻辑，规模缩小版。

package main

import (
	"fmt"
	"os"
	"reflect"
	"strconv"
)

type AppConfig struct {
	Workers int    `env:"APP_WORKERS"`
	Region  string `env:"APP_REGION"`
	Debug   bool   `env:"APP_DEBUG"`
}

func bind(cfg any) error {
	t := reflect.TypeOf(cfg).Elem() // Elem 解开指针拿到结构体类型
	v := reflect.ValueOf(cfg).Elem()

	for i := 0; i < t.NumField(); i++ {
		key := t.Field(i).Tag.Get("env")
		raw, ok := os.LookupEnv(key)
		if !ok {
			continue // 未设置的环境变量，保留零值
		}
		switch t.Field(i).Type.Kind() {
		case reflect.Int:
			n, err := strconv.Atoi(raw)
			if err != nil {
				return fmt.Errorf("%s 不是整数: %w", key, err)
			}
			v.Field(i).SetInt(int64(n))
		case reflect.String:
			v.Field(i).SetString(raw)
		case reflect.Bool:
			b, err := strconv.ParseBool(raw)
			if err != nil {
				return fmt.Errorf("%s 不是布尔值: %w", key, err)
			}
			v.Field(i).SetBool(b)
		}
	}
	return nil
}

func main() {
	os.Setenv("APP_WORKERS", "8")
	os.Setenv("APP_REGION", "cn-north")
	var cfg AppConfig
	if err := bind(&cfg); err != nil { // 必须传指针，否则不可寻址
		fmt.Println("绑定失败:", err)
		return
	}
	fmt.Printf("%+v\n", cfg)
}
// 运行输出:
// {Workers:8 Region:cn-north Debug:false}
​

结果：三个字段自动填充，未设置的 Debug 保持零值 false，全函数与具体配置类型零耦合。

解读：代码里有三个教科书细节——传指针否则不可寻址；Elem 解开指针层；Set 前按 Kind 分派并校验转换错误。错误处理沿用了第 1 章的包装惯例，反射代码照样规规矩矩走 error 路线。生产级配置库还会叠加默认值、校验器、嵌套结构体递归，骨架与此完全一致。

变式：给 bind 增加对 default 标签的支持：环境变量未设置时回填默认值。实现只需在 continue 前多读一个标签——动手五分钟，你对"框架不过是把通用逻辑反射化"这句话会有体感。

收班要点

• TypeOf 管类型、ValueOf 管值，Kind 表达底层种类，判断形状用 Kind。
• 结构体标签是框架元数据的标准载体，遍历字段加 Get 标签即可看懂序列化与 ORM 的原理。
• 反射慢、绕过编译期检查，热路径禁用，能力抽象优先接口。
• 可写性要求可寻址：传指针再 Elem，改值前看 CanSet。
• 配置绑定是反射的最佳练习场，本节案例可直接扩展进自己的工具箱。

类型系统整章完毕。从下一章起，我们把目光从"数据怎么组织"转向"任务怎么并行"——夜班，正式开工。