当前位置：移动技术网 > IT编程>脚本编程>Go语言 > golang的reflection（转）

golang的reflection（转）

2018年11月15日 | 移动技术网IT编程 | 我要评论

惠灵顿天气,李姝妍,石家庄铁道大学四方学院怎么样

作者：bgbiao
链接：https://www.jianshu.com/p/42c19f88df6c
來源：简书

反射reflection

可以大大提高程序的灵活性，使得interface{}有更大的发挥余地
反射可以使用typeof和valueof函数从接口中获取目标对象信息
反射会将匿名字段作为独立字段（匿名字段的本质）
想要利用反射修改对象状态，前提是interface.data是settable，即pointer-interface
通过反射可以“动态”调用方法

常用的类型、函数和方法

//返回动态类型i的类型，如果i是一个空结构体类型，typeof将返回nil
func typeof(i interface{}) type

//type 接口类型
type type interface {
    align() int
    fieldalign() int
    //指定结构体中方法的下标，返回某个方法的对象，需要注意的是返回的method是一个独立的结构体
    method(int) method
    /*
    type method struct {
        name string
        pkgpath string
        type type
        func value
        index int
    }
    */


    methodbyname(string) (method, bool)

    //返回该结构体类型的方法下标
    nummethod() int
    //返回类型的名称，即动态类型i的名称
    name() string
    pkgpath() string
    size() uintptr
    string() string
    kind() kind
    implements(u type) bool
    assignableto(u type) bool
    convertibleto(u type) bool
    comparable() bool
    bits() int
    chandir() chandir
    isvariadic() bool
    elem() type
    //返回结构体类型第i个字段
    field(i int) structfield
    //structfield结构体
    //type structfield struct {
    // name string
    // pkgpath string
    // type type
    // tag  structtag
    // offset uintptr
    // index []int
    // anonymous bool

    //根据结构体字段索引获取嵌入字段的结构体信息
    fieldbyindex(index []int) structfield

    fieldbyname(name string) (structfield, bool)
    fieldbynamefunc(match func(string) bool) (structfield, bool)
    in(i int) type
    key() type
    len() int
    //返回动态类型i(结构体字段)的字段总数
    numfield() int
    numin() int
    numout() int
    out(i int) type
}

//返回接口i的一个初始化的新值.valueof(nil)返回一个零值
func valueof(i interface{}) value

// value结构体
type value struct {

}
// value结构体的一些方法
// 返回结构体v中的第i个字段。如果v的类型不是结构体或者i超出了结构体的范围，则会出现panic
func (v value) field(i int) value

//以接口类型返回v的当前值
func (v value) interface() (i interface{})
//等价于.
var i interface{} = (v's underlying value)


//通过反射方式修改结构体对象的一些方法

//返回接口v包含或者指针v包含的值
func (v value) elem() value
//判断该接口v是否可以被set修改
func (v value) canset() bool

//使用另外一个反射接口去修改反射值
func (v value) set(x value)
//其他不同类型的set
func (v value) setbool(x bool)
func (v value) setbytes(x []byte)
func (v value) setfloat(x float64)
func (v value) setint(x int64)
//设置结构体对象v的长度为n
func (v value) setlen(n int)
func (v value) setstring(x string)


//一些辅助方法
//返回反射结构体的value的类型.如果v为零值，isvalid将返回false
func (v value) kind() kind
//判断value是否为有效值，通常用在判断某个字段是否在反射体的value中
func (v value) isvalid() bool

//kind常量
type kind uint
const (
        invalid kind = iota
        bool
        int
        int8
        int16
        int32
        int64
        uint
        uint8
        uint16
        uint32
        uint64
        uintptr
        float32
        float64
        complex64
        complex128
        array
        chan
        func
        interface
        map
        ptr
        slice
        string
        struct
        unsafepointer
)

反射的基本操作

通过反射来获取结构体字段的名称以及其他相关信息。

package main

import (
    "fmt"
    "reflect"
)

//定义结构体
type user struct {
    id   int
    name string
    age  int
}

//定义结构体方法
func (u user) hello() {
    fmt.println("hello xuxuebiao")
}

func main() {
    u := user{1, "bgops", 25}
    info(u)
    u.hello()
}

//定义一个反射函数,参数为任意类型
func info(o interface{}) {
    //使用反射类型获取o的type,一个包含多个方法的interface
    t := reflect.typeof(o)
    //打印类型o的名称
    fmt.println("type:", t.name())

    //使用反射类型获取o的value,一个空的结构体
    v := reflect.valueof(o)
    fmt.println("fields:")

    //t.numfield()打印结构体o的字段个数(id,name,age共三个)
    for i := 0; i < t.numfield(); i++ {
        //根据结构体的下标i来获取结构体某个字段,并返回一个新的结构体
        /**
        type structfield struct {
            name string
            pkgpath string
            type      type
            tag       structtag
            offset    uintptr
            index     []int
            anonymous bool
        }
        **/
        f := t.field(i)

        //使用结构体方法v.field(i)根据下标i获取字段value(id,name,age)
        //在根据value的interface()方法获取当前的value的值(interface类型)
        val := v.field(i).interface()
        fmt.printf("%6s:%v = %v\n", f.name, f.type, val)
    }

    //使用t.nummethod()获取所有结构体类型的方法个数(只有hello()一个方法)
    //接口type的方法nummethod() int
    for i := 0; i < t.nummethod(); i++ {
        //使用t.method(i)指定方法下标获取方法对象。返回一个method结构体
        //method(int) method
        m := t.method(i)
        //打印method结构体的相关属性
        /*
        type method struct {
              name    string
              pkgpath string
              type    type
              func    value
              index   int
        }
        */
        fmt.printf("%6s:%v\n", m.name, m.type)
    }
}

输出

type: user
fields:
    id:int = 1
  name:string = bgops
   age:int = 25
 hello:func(main.user)
hello xuxuebiao

注意：我们上面的示例是使用值类型进行进行反射构造的。如果是指针类型的话，我们需要使用reflect.struct字段进行判断接口类型的kind()方法

if k := t.kind();k != reflect.struct {
    fmt.println("非值类型的反射")
    return
}

匿名字段的反射以及嵌入字段

注意:反射会将匿名字段当做独立的字段去处理,需要通过类型索引方式使用fieldbyindex方法去逐个判断

//根据指定索引返回对应的嵌套字段
fieldbyindex(index []int) structfield

type structfield struct {
    name    string
    pkgpath string
    type    type
    tag     structtag
    offset  uintptr
    index   []int
    anonymous   bool //是否为匿名字段
}

package main

import (
    "fmt"
    "reflect"
)

type user struct {
    id   int
    name string
    age  int
}

type manager struct {
    user
    title string
}

func main() {
    //注意匿名字段的初始化操作
    m := manager{user: user{1, "biaoge", 24}, title: "hello biao"}
    t := reflect.typeof(m)

    fmt.printf("%#v\n", t.fieldbyindex([]int{0}))
    fmt.printf("%#v\n", t.fieldbyindex([]int{1}))
    fmt.printf("%#v\n", t.fieldbyindex([]int{0, 0}))
    fmt.printf("%#v\n", t.fieldbyindex([]int{0, 1}))

}

输出：

reflect.structfield{name:"user", pkgpath:"", type:(*reflect.rtype)(0x4ac660), tag:"", offset:0x0, index:[]int{0}, anonymous:true}
reflect.structfield{name:"title", pkgpath:"main", type:(*reflect.rtype)(0x49d820), tag:"", offset:0x20, index:[]int{1}, anonymous:false}
reflect.structfield{name:"id", pkgpath:"", type:(*reflect.rtype)(0x49d1a0), tag:"", offset:0x0, index:[]int{0}, anonymous:false}
reflect.structfield{name:"name", pkgpath:"", type:(*reflect.rtype)(0x49d820), tag:"", offset:0x8, index:[]int{1}, anonymous:false}

通过反射修改目标对象

通过反射的方式去修改对象的某个值。需要注意的亮点是，首先，需要找到对象相关的名称，其次需要找到合适的方法去修改相应的值。

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := 123
    v := reflect.valueof(&x)
    v.elem().setint(5256)
    fmt.println(x)
}

输出：

修改i的时候需要找到对象字段的名称;并且判断类型，使用相对正确的类型修改值

v.fieldbyname("name");f.kind() == reflect.string {
    f.setstring("test string")
}

判断是否找到正确的字段名称：

f := v.fieldbyname("name1")
//判断反射对象value中是否找到name1字段
if !f.isvalid() {
    fmt.println("bad field")
    return
}

package main

import (
    "fmt"
    "reflect"
)

type user struct {
    id   int
    name string
    age  int
}

//使用反射方式对结构体对象的修改有两个条件
//1.通过指针
//2.必须是可set的方法
func main() {
    num := 123
    numv := reflect.valueof(&num)
    //通过value的elem()和setx()方法可直接对相关的对象进行修改
    numv.elem().setint(666)
    fmt.println(num)

    u := user{1, "biao", 24}
    uu := reflect.valueof(&u)
    //set()后面的必须是值类型
    //func (v value) set(x value)
    test := user{2, "bgops", 2}
    testv := reflect.valueof(test)
    uu.elem().set(testv)
    fmt.println("change the test to u with set(x value)", uu)

    //此时的u已经被上面那个uu通过指针的方式修改了
    set(&u)
    fmt.println(u)
}

func set(o interface{}) {
    v := reflect.valueof(o)
    //判断反射体值v是否是ptr类型并且不能进行set操作
    if v.kind() == reflect.ptr && ! v.elem().canset() {
        fmt.println("xxx")
        return
        //初始化对象修改后的返回值(可接受v或v的指针)
    } else {
        v = v.elem()
    }
    //按照结构体对象的名称进行查找filed，并判断类型是否为string，然后进行set
    if f := v.fieldbyname("name"); f.kind() == reflect.string {
        f.setstring("byby")
    }
}

输出：

666
change the test to u with set(x value) &{2 bgops 2}
{2 byby 2}

通过反射进行动态方法的调用

使用反射的相关知识进行方法的动态调用

package main

import (
    "fmt"
    "reflect"
)

type user struct {
    id   int
    name string
    age  int
}

func (u user) hello(name string, id int) {
    fmt.printf("hello %s,my name is %s and my id is %d\n", name, u.name, id)
}

func main() {
    u := user{1, "biaoge", 24}
    fmt.println("方法调用:")
    u.hello("xuxuebiao", 121)

    //获取结构体类型u的value
    v := reflect.valueof(u)
    //根据方法名称获取value中的方法对象
    mv := v.methodbyname("hello")

    //构造一个[]value类型的变量，使用value的call(in []value)方法进行动态调用method
    //这里其实相当于有一个value类型的slice，仅一个字段
    args := []reflect.value{reflect.valueof("xuxuebiao"), reflect.valueof(5256)}
    fmt.println("通过反射动态调用方法:")
    //使用value的call(in []value)方法进行方法的动态调用
    //func (v value) call(in []value) []value
    //需要注意的是当v的类型不是func的化，将会panic;同时每个输入的参数args都必须对应到hello()方法中的每一个形参上
    mv.call(args)

}

方法调用:
hello xuxuebiao,my name is biaoge and my id is 121
通过反射动态调用方法:
hello xuxuebiao,my name is biaoge and my id is 5256

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！点击进行留言回复

golang实现http server提供文件下载功能

简介go（又称golang）是google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。罗伯特·格瑞史莫（robert griesemer... [阅读全文]
Golang 实现插入排序的方法示例(2种)

再次研究了插入排序的概念：定义一个有序的数据序列a，将待排序的序列b中的数依次插入到a的合适位置，插入后仍然有序总结其与冒泡、选择的区别在于，内部迭代的次数是逐... [阅读全文]
Go 字符串格式化的实例代码详解

go对字符串格式化提供了良好的支持。下面我们看些常用的字符串格式化的例子。package mainimport "fmt"import "os"type poi... [阅读全文]
Golang logrus 日志包及日志切割的实现

本文主要介绍 golang 中最佳日志解决方案，包括常用日志包的基本使用，如何结合包实现日志文件的轮转切割两大话题。golang 关于日志处理有很多包可以使用，... [阅读全文]
Go语言学习之goroutine详解

什么是goroutine？goroutine是建立在线程之上的轻量级的抽象。它允许我们以非常低的代价在同一个地址空间中并行地执行多个函数或者方法。相比于线程，它... [阅读全文]
图文详解go语言反射实现原理

go反射的实现和 interface 和 unsafe.pointer 密切相关。如果对golang的 interface 底层实现还没有理解，可以去看我之前的... [阅读全文]
Golang执行go get私有库提示"410 Gone" 的问题及解决办法

之前没有使用过私有库，今天正好碰到，把解决方法整理一下错误记录如果你在用go get 私有库碰到如下类似错误：解决方法$ export go111module=... [阅读全文]
Golang import 导入包语法及一些特殊用法详解

package 的导入语法写 go 代码的时经常用到 import 这个命令用来导入包，参考如下：import( "fmt")然后在代码里面可以通过如下的方式... [阅读全文]
Golang常用环境变量说明与设置详解

无论你是使用windows,linux还是mac os操作系统来开发go应用程序，在安装好go安装语言开发工具之后，都必须配置好go语言开发所要求的环境变量，... [阅读全文]
golang实现微信小程序商城后台系统（moshopserver）

golang和c/c++比起来是一门新的语言，一直想学，网上搜集了一些资料，有些人说很容易上手，确实是这样，和c/c++比起来，少了很多乱七八糟的语法。学一门新... [阅读全文]

网友评论


验证码：