当前位置：首页 > article >正文

Go语言反射从入门到进阶

article 2024/12/28 11:15:30

一、反射的基础概念

在 Go 语言中，反射是程序在运行时检查和修改自身状态的能力。通过反射，我们可以在运行时获取变量的类型信息、查看结构体的字段、调用方法等。Go 语言的反射功能主要通过 reflect 包实现。

1.1 反射的基本类型：Type 和 Value

Go 的反射主要基于两个重要的类型：

reflect.Type：表示 Go 类型的接口
reflect.Value：表示 Go 值的接口

让我们从一个简单的例子开始：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.14
    
    // 获取变量的类型信息
    t := reflect.TypeOf(x)
    fmt.Printf("类型：%v\n", t)
    
    // 获取变量的值信息
    v := reflect.ValueOf(x)
    fmt.Printf("值：%v\n", v)
}

二、基本类型的反射操作

2.1 获取类型信息

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var num int64 = 42
    var str string = "hello"
    
    // 获取基本类型信息
    fmt.Printf("num 的类型：%v\n", reflect.TypeOf(num))
    fmt.Printf("str 的类型：%v\n", reflect.TypeOf(str))
    
    // 获取类型的种类（Kind）
    fmt.Printf("num 的种类：%v\n", reflect.TypeOf(num).Kind())
    fmt.Printf("str 的种类：%v\n", reflect.TypeOf(str).Kind())
}

2.2 获取和修改值

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := 3.14
    v := reflect.ValueOf(&x) // 注意：这里传入指针
    
    // 检查值是否可以被修改
    if v.Kind() == reflect.Ptr && v.Elem().CanSet() {
        v.Elem().SetFloat(2.718)
    }
    
    fmt.Printf("修改后的值：%v\n", x)
}

三、结构体的反射操作

3.1 基本结构体反射

package main

import (
    "fmt"
    "reflect"
)

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

func main() {
    p := Person{
        Name: "张三",
        Age:  25,
    }
    
    t := reflect.TypeOf(p)
    
    // 遍历结构体字段
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("字段名：%s\n", field.Name)
        fmt.Printf("字段类型：%v\n", field.Type)
        fmt.Printf("标签：%v\n", field.Tag.Get("json"))
    }
}

3.2 动态调用方法

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func (p Person) SayHello(msg string) string {
    return fmt.Sprintf("Hello, %s. I am %s", msg, p.Name)
}

func main() {
    p := Person{Name: "张三", Age: 25}
    
    // 获取方法
    v := reflect.ValueOf(p)
    method := v.MethodByName("SayHello")
    
    // 准备参数
    args := []reflect.Value{reflect.ValueOf("世界")}
    
    // 调用方法
    result := method.Call(args)
    
    fmt.Println(result[0].String())
}

四、高级应用场景

4.1 通用的结构体字段验证器

package main

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

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

func validate(v interface{}) []string {
    var errors []string
    t := reflect.TypeOf(v)
    val := reflect.ValueOf(v)
    
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        value := val.Field(i)
        
        // 获取验证规则
        rules := strings.Split(field.Tag.Get("validate"), ",")
        
        for _, rule := range rules {
            switch {
            case rule == "required":
                if value.Interface() == reflect.Zero(value.Type()).Interface() {
                    errors = append(errors, fmt.Sprintf("%s 是必填字段", field.Name))
                }
            case strings.HasPrefix(rule, "min="):
                // 这里简化处理，实际应用中需要更复杂的验证逻辑
                if value.Kind() == reflect.String && len(value.String()) < 3 {
                    errors = append(errors, fmt.Sprintf("%s 长度不能小于3", field.Name))
                }
            }
        }
    }
    
    return errors
}

func main() {
    user := User{
        Name:  "张",
        Email: "invalid-email",
        Age:   16,
    }
    
    if errors := validate(user); len(errors) > 0 {
        fmt.Printf("验证错误：\n%s\n", strings.Join(errors, "\n"))
    }
}

4.2 通用的 JSON 序列化器

package main

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

func toJSON(v interface{}) string {
    t := reflect.TypeOf(v)
    val := reflect.ValueOf(v)
    
    if t.Kind() != reflect.Struct {
        return fmt.Sprintf("\"%v\"", val.Interface())
    }
    
    var pairs []string
    
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        value := val.Field(i)
        
        // 获取json标签
        jsonTag := field.Tag.Get("json")
        if jsonTag == "" {
            jsonTag = field.Name
        }
        
        pair := fmt.Sprintf("\"%s\":%v", jsonTag, toJSON(value.Interface()))
        pairs = append(pairs, pair)
    }
    
    return "{" + strings.Join(pairs, ",") + "}"
}

type Address struct {
    Street string `json:"street"`
    City   string `json:"city"`
}

type Person struct {
    Name    string  `json:"name"`
    Age     int     `json:"age"`
    Address Address `json:"address"`
}

func main() {
    p := Person{
        Name: "张三",
        Age:  25,
        Address: Address{
            Street: "中关村大街",
            City:   "北京",
        },
    }
    
    fmt.Println(toJSON(p))
}