go的反射

最新推荐文章于 2024-07-06 12:55:27 发布
最新推荐文章于 2024-07-06 12:55:27 发布
阅读量71 收藏
点赞数
文章标签： golang go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62444142/article/details/130439111
版权

反射引出

结构体的tag字段

利用反射机制编写函数的适配器(桥连接）

反射基本

1）反射可以在运动时动态获取变量的各种信息，比如变量的类型（type）类别（kind)

2）如果是结构体变量，还可以获取到结构体本身的信息（包括结构体的字段，方法）

3）通过反射，可以修改变量的值，可以调用关联的方法

4）使用反射，要用包 reflect

反射示意图

 

反射重要的函数和概念

1）reflect.TypeOf(变量名),获取变量的类型返回reflect.Type类型

2）reflect.Value(变量名),获取变量的值，返回reflect.Value类型,reflect.Value是一个结构体

3）变量 空接口 reflect.Value是可以相互转换的，实际开发中会经常用到

eg:

相互转换

 之间的关系

 相互转换案例

package main

import (
    "fmt"
    "reflect"
)

//演示反射
func reflectTest01(a interface{}) {
    //通过反射获取传入的变量， type，king,值
    // 1.获取type
    rtype := reflect.TypeOf(a)
    fmt.Println(rtype)

    // 获取到reflect.Value()
    rVal := reflect.ValueOf(a)
    fmt.Println(rVal)

    rrVal := reflect.TypeOf(rVal)
    fmt.Println(rrVal)

    n1 := 20 + rVal.Int()
    fmt.Println(n1)

    //将rval转回interface
    iv := rVal.Interface()
    //将interface{}通过断言转回需要的类型
    num := iv.(int)
    fmt.Printf("%T", num)
}

type Student struct {
    Name string
    Age  int
}

//对结构体的反射
func reflectTest02(a interface{}) {
    // 1.获取type
    rtype := reflect.TypeOf(a)
    fmt.Println(rtype)

    // 获取到reflect.Value()
    rVal := reflect.ValueOf(a)
    fmt.Println(rVal)
    
    //获取对应的kind
    //rVal.Kind()
    //rtype.Kind()
    fmt.Printf("kind=%v,kind=%v",rVal.Kind(),rtype.Kind())
    
    //将rval转回interface
    iv := rVal.Interface()
    fmt.Printf("%T,,,%v\n", iv, iv)
    //将interface{}通过断言转回需要的类型
    //使用一个待检测的switch的断言形式
    stu, ok := iv.(Student)
    if ok {
        fmt.Printf("%v", stu.Name)
    }

}
func main() {
    num := 100
    reflectTest01(num)

    fmt.Println("_____________________________________")
    stu := Student{
        Name: "tom",
        Age:  100,
    }
    reflectTest02(stu)
}

反射细节和注意

1）reflect.Value.Kind()获取变量类别返回是一个常量

2）type是类型，Kind是类别。tpye和Kind可能相通也可能不相同

eg:

var num int=10 type=int Kind=int

var stu Student stu的Type是包名(pkg1).Student,King是struct

3）通过反射可以让变量在interface()和reflect.Value之间相互转换，这点在前面有示意图：

变量《------------》interface{}《----------》reflect.Value

 

否则，报错

 5）反射修改变量值要使用reflect.Value.Elem()方法

package main

import (
    "fmt"
    "reflect"
)

func reflect01(a interface{}) {
    rVal := reflect.ValueOf(a)
    //传入地址的话，rVal是一个指针
    fmt.Println(rVal.Kind())
    // Elem返回v持有的接口保管的值的Value封装，或者v持有的指针指向的值的Value封装
    rVal.Elem().SetInt(100)

}
func main() {
    num := 1
    reflect01(&num)
    fmt.Println(num)

    //可以这样理解rVal.Elem()
    num1 := 9
    ptr := &num1
    num2 := *ptr
    fmt.Println(num2)
}

反射最佳实践

package main

import (
    "fmt"
    "reflect"
)

type Monster struct {
    Name  string  `json:"name"`
    Age   int     `json:"age"`
    Score float64 `json:"score"`
    Sex   string  `json:"sex"`
}

func (m Monster) Print() {
    fmt.Println("-----start-----")
    fmt.Println(m)
    fmt.Println("----- end------")
}

func (m Monster) GetSum(n1 int, n2 int) int {
    return n1 + n2
}

func (m *Monster) Set(name string, age int, score float64, sex string) {
    m.Name = name
    m.Age = age
    m.Score = score
    m.Sex = sex
}

func TestStruct(a interface{}) {
    //获取reflect.Type类型
    typ := reflect.TypeOf(a)
    //获取reflect.Value类型
    val := reflect.ValueOf(a)
    // 获取到a对应的类别
    kd := val.Kind()
    if kd != reflect.Struct {
        fmt.Println("传入参数不为结构体，已自动退出")
        return
    }
    //获取该结构体题的字段数
    num := val.NumField()
    fmt.Println("该结构体有", num, "个字段")
    //循环输出字段
    for i := 0; i < num; i++ {

        fmt.Printf("字段:%v,值为:%v,", i, val.Field(i))
        tagval := typ.Field(i).Tag.Get("json")
        if tagval != "" {
            fmt.Printf("tag标签为%v,\n", tagval)
        } else {
            fmt.Println()
        }
    }
    numMethod := val.NumMethod()
    fmt.Println("该结构体有", numMethod, "个方法")
    // 获取到第二个方法，并调用
    //方法排序是按照函数名字母(ASCII码)进行的排序
    val.Method(1).Call(nil)
    // 调用结构体的第一个方法Method(0)
    var params []reflect.Value
    params = append(params, reflect.ValueOf(20))
    params = append(params, reflect.ValueOf(72))
    res := val.Method(0).Call(params)
    fmt.Println(res[0].Int())
}
func main() {
    mon := &Monster{
        Name:  "孙悟空",
        Age:   1000,
        Score: 100.2,
        Sex:   "男",
    }
    TestStruct(mon)
}


package main

import (
    "fmt"
    "reflect"
)

type Monster struct {
    Name  string  `json:"name"`
    Age   int     `json:"age"`
    Score float64 `json:"score"`
    Sex   string  `json:"sex"`
}

func (m *Monster) Print() {
    fmt.Println("-----start-----")
    fmt.Println(m)
    fmt.Println("----- end------")
}

func (m *Monster) GetSum(n1 int, n2 int) int {
    return n1 + n2
}

func (m *Monster) Set(name string, age int, score float64, sex string) {
    m.Name = name
    m.Age = age
    m.Score = score
    m.Sex = sex
}

func TestStruct(a interface{}) {
    //获取reflect.Type类型
    typ := reflect.TypeOf(a)
    //获取reflect.Value类型
    val := reflect.ValueOf(a)
    // 获取到a对应的类别
    kd := val.Kind()
    if kd != reflect.Ptr && val.Elem().Kind() == reflect.Struct {
        fmt.Println("传入参数不为结构体，已自动退出")
        return
    }
    //获取该结构体题的字段数
    num := val.Elem().NumField()
    fmt.Println("该结构体有", num, "个字段")
    //修改值
    val.Elem().Field(0).SetString("刘广硕")
    //循环输出字段
    for i := 0; i < num; i++ {

        fmt.Printf("字段:%v,值为:%v,", i, val.Elem().Field(i))
        tagval := typ.Elem().Field(i).Tag.Get("json")
        if tagval != "" {
            fmt.Printf("tag标签为%v,\n", tagval)
        } else {
            fmt.Println()
        }
    }
    numMethod := val.NumMethod()
    fmt.Println("该结构体有", numMethod, "个方法")
    // 获取到第二个方法，并调用
    //方法排序是按照函数名字母(ASCII码)进行的排序
    val.Method(1).Call(nil)
    // 调用结构体的第一个方法Method(0)
    var params []reflect.Value
    params = append(params, reflect.ValueOf(20))
    params = append(params, reflect.ValueOf(72))
    res := val.Method(0).Call(params)
    fmt.Println(res[0].Int())
}
func main() {
    mon := &Monster{
        Name:  "孙悟空",
        Age:   1000,
        Score: 100.2,
        Sex:   "男",
    }
    TestStruct(mon)
}


package main

import (
    "reflect"
    "testing"
)

func TestReflectFunc(t *testing.T) {
    call1 := func(v1 int, v2 int) {
        t.Log(v1, v2)
    }
    call2 := func(v1 int, v2 int, s string) {
        t.Log(v1, v2, s)
    }
    var (
        function reflect.Value
        invalue  []reflect.Value
        n        int
    )
    bridge := func(call interface{}, args ...interface{}) {
        n = len(args)
        invalue = make([]reflect.Value, n)
        for i := 0; i < n; i++ {
            invalue[i] = reflect.ValueOf(args[i])
        }
        function = reflect.ValueOf(call)
        function.Call(invalue)
    }
    bridge(call1, 1, 2)
    bridge(call2, 1, 2, "test2")
}

package main

import (
    "reflect"
    "testing"
)

type user struct {
    UserId string
    Name   string
}

func TestReflectStruct(t *testing.T) {
    var (
        model *user
        st    reflect.Type
        elem  reflect.Value
    )
    st = reflect.TypeOf(model)                  //获取类型*user
    t.Log("reflect.TypeOf", st.Kind().String()) //ptr
    st = st.Elem()                              //st指向的类型
    elem = reflect.New(st)
    t.Log("reflect.New", elem.Kind().String()) //ptr
    t.Log("reflect.New.Elem", elem.Elem().Kind().String())
    //model就是创建的user结构体变量
    model = elem.Interface().(*user) //model是*user它的指向和elem是一样的
    elem = elem.Elem()               //取得elem指向的值
    elem.FieldByName("UserId").SetString("12345678")
    elem.FieldByName("Name").SetString("nickname")
    t.Log("model model.Name", model, model.Name)

}
package main

import (
    "fmt"
    "math/rand"
    "reflect"
    "time"
)

type Cal struct {
    Num1 int
    Num2 int
}

func (c *Cal) GetSum(name string) string {
    return fmt.Sprintf("%v完成了减法运算,%v - %v = %v", name, c.Num1, c.Num2, c.Num1-c.Num2)
}

func TestCal(c interface{}) {
    // typ := reflect.TypeOf(c)
    val := reflect.ValueOf(c)
    num := val.Elem().NumField()
    rand.Seed(time.Now().Unix())
    for i := 0; i < num; i++ {
        val.Elem().Field(i).SetInt(int64(rand.Intn(100)))
    }
    var params []reflect.Value
    params = append(params, reflect.ValueOf("tom"))
    res := val.Method(0).Call(params)
    fmt.Println(res)
}
func main() {
    c := &Cal{}
    TestCal(c)
}

星月147
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
图文详解go语言反射实现原理
12-20
如果对golang的 interface 底层实现还没有理解，可以去看我之前的文章： Go语言interface底层实现 ， unsafe.Pointer 会在后续的文章中做介绍。 （本文目前使用的Go环境是Go 1.12.9） interface回顾 首先我们简单的...
golang之反射常用函数介绍
qq_38151401的博客
05-01 1261
目录 1、通过反射获取到传入变量的type，值、kind 2、变量、interface{},reflect.Value相互转化 3、反射获取结构体内容 4、反射最佳实践 反射可以在运行时动态获取变量的各种信息，比如变量的类型、类别。如果是结构体变量，还可以获取到结构体本身的信息（包括结构体字段、方法）。通过反射，可以修改变量的值，可以调用关联的方法 1、通过反射获取到传入变量的t...
Go学习值reflect反射篇
叮当猫的喵i
09-09 778
简言之：就是利用【反射功能】注册【一些信息】到程序可执行文件中，因此在程序运行期间，可以利用【反射功能】取出或修改【这些信息】反射是**【指在程序运行期间对程序本身进行访问和修改的能力】**。程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取自身的信息。支持反射的语言可以在程序编译期间将变量的反射信息，如字段名称、类型信息、结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，这样就可以在程序运行期间获取类型的反射信息，并且有能力修改它们。
Go---反射
weixin_47328424的博客
01-20 604
反射 1) 反射可以在运行时动态获取变量的各种信息，比如变量的类型，类别 2) 如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法) 3) 通过反射,可以修改变量的值,可以调用关联的方法。 4) 使用反射,需要 import ("reflect") 5）反射的示意图 反射的应用场景 反射常见应用场景有以下两种 1) 不知道接口调用哪个函数，根据传入参数在运行时确定调用的具体接口，这种需要对函数或方法反射。 2)对结构体序列化时，如果结构体有指定Tag, 也会使用到反射.
Go语言通过反射用字符串字段给结构体变量赋值理解reflect的使用
有问题 ! 请留言 !
05-07 3387
Go语言通过反射用字符串字段给结构体变量赋值理解reflect的使用 我们知道给一个结构体变量直接赋值可以直接写死 a := struct { name string age int }{ name: "haha", age: 1, } a.name = "hahaha" **但是如果我们需要用一个字符串字段给结构体变量赋值,因为字符串有可能是动态传入或者动态获取的,所以就需...
golang基础-反射获取（基础数据、结构体）、操作（基本类型、结构体、指针）、反射获取Tag
热门推荐
全干工程师
11-04 1万+
反射获取基本类型反射：可以在运行时动态获取变量的相关信息 Import (“reflect”)a. reflect.TypeOf，获取变量的类型，返回reflect.Type类型 b. reflect.ValueOf，获取变量的值，返回reflect.Value类型 c. reflect.Value.Kind，获取变量的类别，返回一个常量 d. reflect.Value.Inte
Go反射使用记录
01-07
Go反射使用记录 type User struct { Name string Age int } 1. 通过反射方法reflect.New()创建实例 通过reflect.New()创建的实例，总是返回的是实例指针类型。 func ReflectNew(arg interface{}) interface{} { ...
详解Golang利用反射reflect动态调用方法
09-19
主要介绍了详解Golang利用反射reflect动态调用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
谈谈Go语言的反射三定律
09-21
Go语言的反射机制是其强大的特性之一，它允许程序在运行时检查和修改自身的结构，特别是类型信息。本文将深入探讨Go语言中的反射三定律，以及类型和接口的基础知识。 首先，反射的核心在于程序能够检查并操作自身的...
Golang Reflect反射的使用详解1
weixin_33950035的博客
01-29 1324
2019独角兽企业重金招聘Python工程师标准>>> ...
go反射获取类型对象与值、go反射获取指针名称和类型、golang反射对象的空值处理、golang反射值对象修改变量的值
点点的博客
02-23 9163
一、反射获取类型对象与值 package main import ( "fmt" "reflect" ) func main() { a := 36 atype := reflect.TypeOf(a) fmt.Println(atype.Name()) //获取类型名称为int avalue := reflect.ValueOf(a) fmt.Println(avalue.Int()) //获取具体的数值 } 二、反射获取结构体类型名称与类型 package main import
golang：interface作为函数传参时如何获取值
OceanStar的博客
12-11 1139
package main import ( "reflect" "fmt" ) func test(parms interface{}){ r := reflect.ValueOf(&parms).Elem().Interface() fmt.Println(r) // int int } func main() { var i = 11 test(i) v...
golang利用反射设置结构体变量的值
开心就好的专栏
10-08 5741
如果需要动态设置struct变量field的情况下, 可以利用reflect来完成. 代码如下: package main import ( &amp;amp;amp;quot;fmt&amp;amp;amp;quot; &amp;amp;amp;quot;reflect&amp;amp;amp;quot; ) // 定义结构体Person type Person struct { Name string Age int } func main() { pe
Go 反射获取结构体的字段名和字段值 根据字段名获取字段值
霍城延的随笔
09-12 1万+
直接上代码： type User struct{ Username string `json:"Username"` Socre float`json:"Socre"` } //获取结构体中字段的名称 func GetFieldName(columnName string, info User) float64 { var val float64...
go使用反射reflect获取变量类型
学亮编程手记
12-22 359
可以用反射： package main import ( "fmt" "reflect" ) func main() { var x float64 = 3.4 fmt.Println("type:", reflect.TypeOf(x)) } 这样就可以得出变量x的类型信息
Golang 通过反射获取方法名称
08-08 2986
import"runtime" runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name() 转载于:https://my.oschi...
go 为什么是抢占式调度
最新发布
2401_82869454的博客
07-06 359
这样有一个严重的问题，就是垃圾回收器进行 STW 时，如果有一个 Goroutine 一直都在阻塞调用，垃圾回收器就会一直等待他，不知道等到什么时候…但万一代码是在运行了好一段时间后又能够运行了（业务上也允许长等待），也就是该 Goroutine 从阻塞状态中恢复了，期望继续运行，没了 P 怎么办？这个例子在老版本（1.14版本之前）的 Go 语言中，就会一直阻塞，没法重见天日，是一个需要做抢占的场景。也就是抢占 P，本身就是一个双向行为，你抢了我的 P，我也可以去抢别人的 P 来继续运行。
golang 垃圾回收
hjx_dou的专栏
07-04 409
gc不回收什么垃圾回收算法三色标记法垃圾回收流程。
go反射
05-30
在 Go 语言中，反射是一种机制，可以在程序运行时动态获取变量的类型信息和值信息，并可以对其进行修改。反射可以使代码更加灵活，但也会带来一定的性能损失。 Go 语言中的反射主要通过 `reflect` 包来实现。`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值