介绍

我们知道反射是可以在程序的运行期间获取到变量或者结构体的一些元信息，能够知道类型，变量的值甚至修改值，执行方法等

java中的反射应用非常广泛，基本上所有框架都用到了动态代理，而动态代理就是基于反射实现的。

在go中也专门提供了一个标准库reflect，下面我们就基于这个库来简单使用下。

我们准备一个结构体Person，包含有属性方法。

1 创建该结构体的一个对象，通过反射获取到该对象的 结构体名称、类型、各个字段的名字、各个字段的tag、获取方法并执行方法。

2 通过反射构建一个该结构体实例，给每个字段填充值。

package main

import (
	"fmt"
	"reflect"
	"time"
)

type Person struct {
	Name      string    `json:"name"`
	Age       int       `json:"age"`
	Married   bool      `json:"married"`
	BirthTime time.Time `json:"birthTime"`
}

func (p *Person) Eat(name string) {
	fmt.Println("执行：吃", name)
}

func main() {
	location, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		return
	}
	//解析时间
	parse, err := time.ParseInLocation("2006-01-02 15:04:05", "1998-10-04 21:00:32", location)

	// 1 构建一个person指针对象
	person := &Person{Name: "wendell", Age: 20, Married: false, BirthTime: parse}

	// 拿到类型
	t := reflect.TypeOf(person)
	// 拿到value
	v := reflect.ValueOf(person)
	fmt.Printf("type:%s\nvalue:%v\n", t, v)

	// 判断是否是指针类型，一般反射我们都习惯操作指针
	fmt.Println("是否是指针类型", t.Kind() == reflect.Pointer)

	// 只有是指针或者interface才能调用该方法，返回具体的值
	// 如果说一开始操作的不是指针，那么这一步可以省略，直接使用 t v 即可
	tElem := t.Elem()
	vElem := v.Elem()

	fmt.Println("对象名字：", tElem.Name())

	fmt.Println("字段个数：", tElem.NumField())
	for i := 0; i < tElem.NumField(); i++ {
		fmt.Printf("[%v]\t[%v]\t[%v]\t[%v]\n", tElem.Field(i).Name, tElem.Field(i).Tag, tElem.Field(i).Tag.Get("json"), vElem.Field(i).Interface())
	}

	// 获取到方法，执行方法
	method := v.MethodByName("Eat")
	args := make([]reflect.Value, 1)
	args[0] = reflect.ValueOf("苹果")
	method.Call(args)
	fmt.Println("------------------------------------------")

	// 2 创建一个新的person对象
	value := reflect.New(t.Elem()).Interface()
	fmt.Println("构建新的对象", value)

	valueOf := reflect.ValueOf(value)
	elem := valueOf.Elem()

	name := reflect.ValueOf("juan")
	age := reflect.ValueOf(25)

	fmt.Println("name是否允许重新设置值：", elem.Field(0).CanSet())
	// 通过反射给对象设置值
	elem.Field(0).Set(name)
	fmt.Println("age是否允许重新设置值：", elem.Field(1).CanSet())
	elem.Field(1).Set(age)
	fmt.Println("反射设置值之后的", value)
}

执行结果

type:*main.Person
value:&{wendell 20 false 1998-10-04 21:00:32 +0800 CST}
是否是指针类型 true
对象名字： Person
字段个数： 4
[Name]	[json:"name"]	[name]	[wendell]
[Age]	[json:"age"]	[age]	[20]
[Married]	[json:"married"]	[married]	[false]
[BirthTime]	[json:"birthTime"]	[birthTime]	[1998-10-04 21:00:32 +0800 CST]
执行：吃 苹果
------------------------------------------
构建新的对象 &{ 0 false 0001-01-01 00:00:00 +0000 UTC}
name是否允许重新设置值： true
age是否允许重新设置值： true
反射设置值之后的 &{juan 25 false 0001-01-01 00:00:00 +0000 UTC}

Process finished with the exit code 0

通过上面例子我们大概就清楚反射给我们提供了一些什么功能。那么实际框架中怎么应用呢。加入你要做一个orm框架。大概要做到如下程度。只需要打开一个session给出查询条件执行查询就能返回需要的值，并且该值已经封装成了user集合

u := &User{}
userList, err := DB.OpenSession().Like("user_id", "test").SelectAll(u)

那么我们都知道执行一条查询语句需要知道 表名，字段名那么上面代码都没有设置如何获取，这个时候我就可以形成一种规范，结构体名字就是默认表名，属性名称的下划线形式就是默认字段名可以通过tag指定字段名叫啥。返回值我们可以通过传入的类型New出一个结构体对象，通过该对象的属性与表字段名的映射关系就可以自动将查询出的结果设置到结构体中，
于是结构体可以这样写

type User struct {
	UserId      string `db:"user_id",primary:"true"`
	Username    string `db:"user_name"`
	Admin       bool
}

对应的sql语句

select user_id,username,admin from user_id like "%test%"

好了，反射的基本使用就到这里，后面会发布orm框架的简单实现。

欢迎关注，学习不迷路！