Go语言反射机制详解

半桶水专家

于 2025-03-20 09:13:00 发布

阅读量996

点赞数 17

分类专栏： golang入门文章标签： golang 开发语言后端

本文链接：https://blog.youkuaiyun.com/jkzyx123/article/details/146387530

版权

golang入门专栏收录该内容

38 篇文章

订阅专栏

Go语言中的反射（Reflection）是一种在运行时动态检查类型信息和操作对象的能力。通过反射，可以获取变量的类型、值、方法、结构体字段等信息，甚至动态调用函数或修改变量的值。Go的反射功能由标准库中的 reflect 包提供。

反射的核心概念

反射的核心围绕两个接口展开：

reflect.Type：表示Go语言中的类型信息（如类型名称、方法、字段等）。
reflect.Value：表示某个类型的实例的值信息（如具体的值、值的修改等）。

通过 reflect.TypeOf() 和 reflect.ValueOf() 函数，可以获取任意变量的类型和值信息。

基本用法

1. 获取类型和值信息

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := 42
    t := reflect.TypeOf(x)  // 获取类型信息
    v := reflect.ValueOf(x) // 获取值信息

    fmt.Println("Type:", t)         // 输出: int
    fmt.Println("Value:", v.Int())  // 输出: 42
}

2. 区分底层类型（Kind）

reflect.Type 的 Kind() 方法返回类型的底层类型（如 int, struct, slice 等）：

func checkKind(x interface{}) {
    t := reflect.TypeOf(x)
    fmt.Println("Kind:", t.Kind()) // 输出底层类型
}

checkKind(42)         // int
checkKind("hello")    // string
checkKind(struct{}{}) // struct

值的操作

1. 从 `reflect.Value` 获取值

通过 v.Interface() 可以将 reflect.Value 转换回 interface{}，再通过类型断言获取原始值：

x := 42
v := reflect.ValueOf(x)
value := v.Interface().(int) // 类型断言
fmt.Println(value) // 42

2. 修改值（需指针）

要修改变量的值，必须通过指针，且需要确保 reflect.Value 是可设置的（CanSet() 返回 true）：

x := 42
v := reflect.ValueOf(&x).Elem() // 获取指针指向的Value
if v.CanSet() {
    v.SetInt(100) // 修改值
}
fmt.Println(x) // 输出: 100

结构体的反射

反射常用于处理结构体的字段和方法：

1. 遍历结构体字段

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func inspectStruct(u interface{}) {
    t := reflect.TypeOf(u)
    v := reflect.ValueOf(u)

    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)
        fmt.Printf("Field: %s, Tag: %s, Value: %v\n", 
            field.Name, 
            field.Tag.Get("json"), 
            value.Interface(),
        )
    }
}

u := User{"Alice", 30}
inspectStruct(u)
// 输出:
// Field: Name, Tag: name, Value: Alice
// Field: Age, Tag: age, Value: 30

2. 调用结构体方法

type Calculator struct{}

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

func callMethod(obj interface{}, methodName string, args ...interface{}) {
    v := reflect.ValueOf(obj)
    method := v.MethodByName(methodName)

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

    // 调用方法
    result := method.Call(in)
    fmt.Println("Result:", result[0].Int())
}

calc := Calculator{}
callMethod(calc, "Add", 3, 5) // 输出: Result: 8