Go 语言反射机制详解：从类型获取到结构体操作

山间有风

发布时间：2026-10-16| 3人浏览过

原创

Go 语言中的反射允许程序在运行时动态检查变量的类型和结构。本文将结合 reflect 包的核心方法 TypeOf、ValueOf、Set 等，演示如何获取变量信息、处理结构体字段、解析标签（Tag）以及进行函数的动态调用。

什么是 Go 语言的反射

反射是在运行时动态地获取变量的相关信息（如类型、值、长度、方法等）的一种机制。在 Go 中，任何接口变量内部都保存了两个信息：类型（Type）和具体值（Value/Kind）。理解这一点是使用反射的前提：

Type：代表变量的静态类型（如 string, int）。它属于常量范畴。
Kind：代表变量的底层类别（如 reflect.String, reflect.Int）。虽然 Kind 在 reflect 包中表现为常量，但在逻辑上我们习惯称其为获取变量的“类别”。

第一步：使用 TypeOf 和 ValueOf 获取变量信息

这是使用反射最基础的入口。reflect.TypeOf(i) 获取变量的类型信息（返回 reflect.Type），而 reflect.ValueOf(i) 获取变量的值及其相关操作的句柄（返回 reflect.Value）。

第1步：打印基本类型的类型与值

目的：掌握如何将任意接口数据转换为可观测的字符串。

代码实现：

package main

import (
	"fmt"
	"reflect"
)

func Test(i interface{}) {
	// 获取类型 (reflect.Type)
	t := reflect.TypeOf(i)
	fmt.Println("类型是", t)

	// 获取值 (reflect.Value)
	v := reflect.ValueOf(i)
	fmt.Println("值是", v)
}

func main() {
	a := "hello"
	Test(a)
}

预期输出：
类型是 string
值是 hello

第2步：查看结构体的类型与 Kind

目的：验证传入的是结构体还是其他基础类型，并区分 Type 与 Kind 的不同。Kind 常用于 if 判断中，而 Type 用于更精确的类型匹配。

package main

import (
	"fmt"
	"reflect"
)

type Student struct {
	Name  string
	Age   int
	Score float32
}

func Test(i interface{}) {
	t := reflect.TypeOf(i)
	fmt.Println("类型是", t)

	v := reflect.ValueOf(i)
	c := v.Kind()
	fmt.Println("类别是", c)
}

func main() {
	var stu Student = Student{Name: "张三", Age: 18, Score: 80}
	Test(stu)

	fmt.Println("-------------")
	var num int = 10
	Test(num)
}

预期输出：
类型是 main.Student
类别是 struct
-------------
类型是 int
类别是 int

第二步：断言处理与类型转换

通过 v.Interface() 将反射对象还原为接口类型，通常配合类型断言提取具体的结构体实例，以便后续直接访问或进一步操作。

package main

import (
	"fmt"
	"reflect"
)

type Student struct { Name string; Age int }

func Test(i interface{}) {
	v := reflect.ValueOf(i)
	iv := v.Interface()
	
	// 执行断言
	stu_iv, ok := iv.(Student)
	if ok {
		fmt.Printf("成功断言，类型: %T\n", stu_iv)
	} else {
		fmt.Println("断言失败")
	}
}

func main() {
	var stu Student = Student{Name: "张三", Age: 18}
	Test(stu)
}

第三步：Value 获取原始数值

reflect.Value 提供了一系列后缀带有数据类型的方法来获取底层的原生值，例如 .Float()、.Int()、.String() 等。需要注意的是，这些方法通常会将其转换为特定的标准类型（如 float64, int64）。

package main

import (
	"fmt"
	"reflect"
)

func Test(i interface{}) {
	v := reflect.ValueOf(i)
	
	// 如果 i 不是数值类型，调用 Int() 会 panic
	t := v.Int()
	fmt.Printf("t 的类型是 %T\n", t) // 通常是 int64
}

func main() {
	var num int = 100
	Test(num)
}

第四步：通过反射设置变量值

风险提醒：在 Go 中，如果你传递的是一个非地址的值（普通变量），反射拿到的副本是不可写修改源数据的。要想修改外部变量的值，必须传入**指针**。

第1步：修改整型值

关键参数：传入指针 &num，并使用 v.Elem() 解引用指向原值。

package main

import (
	"fmt"
	"reflect"
)

func Test(i interface{}) {
	v := reflect.ValueOf(i)
	// v.Elem() 获取指针指向的真实值，随后 SetInt 才能真正修改原始内存
	v.Elem().SetInt(100)
	result := v.Elem().Int()
	fmt.Printf("result类型为 %T, 值为 %d\n", result, result)
}

func main() {
	var num int = 10
	Test(&num)
}

第五步：结构体的高级反射操作

第1步：统计字段与方法数量

使用 v.NumField() 和 v.NumMethod()。注意：方法数通常只在 reflect.Value 对应指针时较为准确，或者需要手动注册方法集。

package main

import (
	"fmt"
	"reflect"
)

type Student struct { Name string; Age int; Score float32 }
func (s Student) Run() {}
func (s Student) Sleep() {}

func Test(i interface{}) {
	v := reflect.ValueOf(i)
	if v.Kind() != reflect.Struct {
		return
	}
	fmt.Printf("字段数量: %d\n", v.NumField())
	fmt.Printf("方法数量: %d\n", v.NumMethod())
}

func main() {
	Test(Student{Name: "张三", Age: 18})
}

第2步：遍历并获取结构体属性

利用循环遍历所有字段，可以通过 v.Field(i) 获取每个字段的 reflect.Value，进而读取其 Kind() 或 Interface()。

package main

import (
	"fmt"
	"reflect"
)

type Student struct {
	Name  string
	Age   int
	Score float32
}

func Test(i interface{}) {
	v := reflect.ValueOf(i)
	for i := 0; i < v.NumField(); i++ {
		field := v.Field(i)
		fmt.Printf("索引 %d, 值: %v, 类型(Kind): %v\n", i, field.Interface(), field.Kind())
	}
}

func main() {
	Test(Student{Name: "张三", Age: 18, Score: 88})
}

第3步：修改结构体属性值

重要条件：要修改结构体内部属性，必须传入结构体指针 &stu。接收后需检查是否为指针且指向结构体，然后通过 Elem() 获取实体再操作。

package main

import (
	"fmt"
	"reflect"
)

type Student struct { Name string; Age int; Score float32 }

func Test(i interface{}, name string) {
	v := reflect.ValueOf(i)
	
	// 确保是指针并且能解引用出结构体
	if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
		fmt.Println("expect struct pointer")
		return
	}
	
	// 修改第一个字段 (Name)
	v.Elem().Field(0).SetString(name)
	
	// 验证结果
	for i := 0; i < v.Elem().NumField(); i++ {
		fmt.Printf("索引 %d, 值: %v, 类型: %v\n", i, v.Elem().Field(i), v.Elem().Field(i).Kind())
	}
}

func main() {
	var stu Student = Student{Name: "张三", Age: 18, Score: 88}
	Test(&stu, "李四")
}

第4步：处理结构体 Tag（原信息）

在定义结构体时可以使用 `` `json:"..."` `` 等标签。通过反射获取字段的 StructField，再调用 Tag.Get("key") 即可解析。

package main

import (
	"encoding/json"
	"fmt"
	"reflect"
)

type Student struct {
	Name  string `json:"stu_name"`
	Age   int
	Score float32
}

func main() {
	stu := Student{Name: "李四", Age: 18, Score: 88}
	
	// 1. 使用 json 库观察 Tag 的效果
	result, _ := json.Marshal(stu)
	fmt.Println("JSON 序列化结果:", string(result))
	
	// 2. 使用反射直接提取 Tag 信息
	st := reflect.TypeOf(stu)
	field := st.Field(0) // Name 字段
	tagVal := field.Tag.Get("json")
	fmt.Printf("获取到的 JSON tag 名称: %s\n", tagVal)
}

第六步：函数的反射与调用

Go 语言中函数是一等公民，也可以放入 interface{}。反射同样支持检测函数类型并进行调用。

第1步：无参函数的调用

使用 v.Call(nil) 执行。前提是 Kind() 必须为 reflect.Func。

package main

import (
	"fmt"
	"reflect"
)

func hello() {
	fmt.Println("Hello World")
}

func main() {
	v := reflect.ValueOf(hello)
	if v.Kind() == reflect.Func {
		v.Call(nil) // 无参函数传入 nil 切片
	}
}

第2步：带参且有返回值的函数

操作顺序：
1. 构造参数切片： []reflect.Value{reflect.ValueOf(arg1), ...}
2. 执行调用： v.Call(params) 返回一个 []reflect.Value 切片
3. 提取返回值：通过切片索引获取，并使用 .Interface().(目标类型) 强转回原生类型。

package main

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

func ProcessNumber(i int) string {
	return strconv.Itoa(i)
}

func main() {
	v := reflect.ValueOf(ProcessNumber)
	
	// 准备参数
	params := []reflect.Value{
		reflect.ValueOf(20),
	}
	
	// 调用并获取返回值
	results := v.Call(params)
	
	// 类型断言转换返回值
	retStr := results[0].Interface().(string)
	fmt.Printf("返回值类型: %T, 值: %s\n", retStr, retStr)
}

第七步：结构体方法的反射调用

方法与函数类似，但绑定在对象上。反射中可以基于名称 (MethodByName) 或索引 (Method) 来调用。

第1步：通过 MethodByName 调用

推荐方式，语义清晰。需注意传入 params 时类型必须严格匹配。

package main

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

type Student struct {
	Name string
	Age  int
}

func (s *Student) SetName(n string) { s.Name = n }
func (s *Student) String() string { 
	return fmt.Sprintf("Name:%s,Age:%s", s.Name, strconv.Itoa(s.Age)) 
}

func main() {
	stu := &Student{Name: "张三", Age: 19}
	v := reflect.ValueOf(stu).Elem() // Elem() 获取指针指向的对象
	
	// 修改前
	fmt.Println(v.MethodByName("String").Call(nil)[0])
	
	// 调用 Setter
	v.MethodByName("SetName").Call([]reflect.Value{reflect.ValueOf("李四")})
	
	// 修改后
	fmt.Println(v.MethodByName("String").Call(nil)[0])
}