Go反射

地址：https://www.topgoer.com/%E5%B8%B8%E7%94%A8%E6%A0%87%E5%87%86%E5%BA%93/%E5%8F%8D%E5%B0%84.html

反射基础

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
package save_query

import (
	"fmt"
	"reflect"
	"testing"
)

//反射获取interface类型信息

func reflect_type(a interface{}) {
	t := reflect.TypeOf(a)
	fmt.Println("类型是：", t)
	// kind()可以获取具体类型
	k := t.Kind()
	fmt.Println(k)
	switch k {
	case reflect.Float64:
		fmt.Printf("a is float64\n")
	case reflect.String:
		fmt.Println("string")
	}
}

//反射获取interface值信息

func reflect_value(a interface{}) {
	v := reflect.ValueOf(a)
	fmt.Println(v)
	k := v.Kind()
	fmt.Println(k)
	switch k {
	case reflect.Float64:
		fmt.Println("a是：", v.Float())
	}
}

//反射修改值
func reflect_set_value(a interface{}) {
	v := reflect.ValueOf(a)
	k := v.Kind()
	fmt.Println("k is:", k)
	switch k {
	case reflect.Float64:
		// 反射修改值
		v.SetFloat(6.9)
		fmt.Println("a is ", v.Float())
	case reflect.Ptr:
		fmt.Println("xxx")
		// Elem()获取地址指向的值
		v.Elem().SetFloat(7.9)
		fmt.Println("case:", v.Elem().Float())
		// 地址
		fmt.Println(v.Pointer())
	}
}

func TestReflectType(t *testing.T) {
	var x float64 = 3.4
	reflect_type(x)
}

func TestReflectValue(t *testing.T) {
	var x float64 = 3.4
	reflect_value(x)
}

func TestReflectSetValue(t *testing.T) {
	var x float64 = 3.4
	// 反射认为下面是指针类型，不是float类型
	reflect_type(x)
	reflect_set_value(&x)
	fmt.Println("main:", x)
}

// 定义结构体
type User struct {
	Id   int
	Name string
	Age  int
}

// 绑方法
func (u User) Hello(name string) {
	fmt.Println(name)
}

// 传入interface{}
func Poni(o interface{}) {
	t := reflect.TypeOf(o)
	fmt.Println("类型：", t)
	fmt.Println("字符串类型：", t.Name())
	// 获取值
	v := reflect.ValueOf(o)
	fmt.Println(v)
	// 可以获取所有属性
	// 获取结构体字段个数：t.NumField()
	for i := 0; i < t.NumField(); i++ {
		// 取每个字段
		f := t.Field(i)
		fmt.Printf("%s : %v", f.Name, f.Type)
		// 获取字段的值信息
		// Interface()：获取字段对应的值
		val := v.Field(i).Interface()
		fmt.Println("val :", val)
	}
	fmt.Println("=================方法====================")
	for i := 0; i < t.NumMethod(); i++ {
		m := t.Method(i)
		fmt.Println(m.Name)
		fmt.Println(m.Type)
	}

}

func TestReflectStruct(t *testing.T) {
	u := User{1, "sz", 20}
	Poni(u)
}

// 匿名字段
type Boy struct {
	User
	Addr string
}

func TestAnonymousStruct(tt *testing.T) {
	m := Boy{User{1, "zs", 20}, "bj"}
	t := reflect.TypeOf(m)
	fmt.Println(t)
	// Anonymous：匿名
	fmt.Printf("%#v\n", t.Field(0))
	// 值信息
	fmt.Printf("%#v\n", reflect.ValueOf(m).Field(0))
}

// 修改结构体值
func SetValue(o interface{}) {
	v := reflect.ValueOf(o)
	// 获取指针指向的元素
	v = v.Elem()
	// 取字段
	f := v.FieldByName("Name")
	if f.Kind() == reflect.String {
		f.SetString("kuteng")
	}
}

func TestReflectSetStructValue(t *testing.T) {
	u := User{1, "5lmh.com", 20}
	SetValue(&u)
	fmt.Println(u)
}

func TestReflectCallMethod(t *testing.T) {
	u := User{1, "5lmh.com", 20}
	v := reflect.ValueOf(u)
	// 获取方法
	m := v.MethodByName("Hello")
	// 构建一些参数
	args := []reflect.Value{reflect.ValueOf("6666")}
	// 没参数的情况下：var args2 []reflect.Value
	// 调用方法，需要传入方法的参数
	m.Call(args)
}

// 获取tag字段
type Student struct {
	Name string `json:"name1" db:"name2"`
}

func TestReflectGetTag(tt *testing.T) {
	var s Student
	v := reflect.ValueOf(&s)
	// 类型
	t := v.Type()
	// 获取字段
	f := t.Elem().Field(0)
	fmt.Println(f.Tag.Get("json"))
	fmt.Println(f.Tag.Get("db"))
	if tag, ok := f.Tag.Lookup("json"); ok {
		fmt.Println(tag)
	}

}

反射练习-序列化与反序列化

config.ini

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#this is comment
;this a comment
;[]表示一个section
[server]
ip = 10.238.2.2
port = 8080

[mysql]
username = root
passwd = admin
database = test
host = 192.168.10.10
port = 8000
timeout = 1.2

model.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

type ServerConfig struct {
	Ip   string `ini:"ip"`
	Port int    `ini:"port"`
}

type MysqlConfig struct {
	Username string  `ini:"username"`
	Passwd   string  `ini:"passwd"`
	Database string  `ini:"database"`
	Host     string  `ini:"host"`
	Port     int     `ini:"port"`
	Timeout  float32 `ini:"timeout"`
}

type Config struct {
	ServerConf ServerConfig `ini:"server"`
	MysqlConf  MysqlConfig  `ini:"mysql"`
}

ini_config.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
package main

import (
	"fmt"
	"io/ioutil"
	"reflect"
	"strconv"
	"strings"
)

// MarshalFile 序列化数据到指定文件
func MarshalFile(fileName string, data interface{}) error {
	// 1.数据的序列化
	result, err := Marshal(data)
	if err != nil {
		return err
	}
	// 2. 将序列化好的数据，写出到filename
	return ioutil.WriteFile(fileName, result, 0666)
}

// Marshal 反射解析出传入的数据，转字节切片
func Marshal(data interface{}) (result []byte, err error) {
	// 获取类型
	typeInfo := reflect.TypeOf(data)
	valueInfo := reflect.ValueOf(data)
	// 判断类型
	if typeInfo.Kind() != reflect.Struct {
		return
	}
	var conf []string

	// 获取所有字段去处理
	for i := 0; i < typeInfo.NumField(); i++ {
		// 取字段
		labelField := typeInfo.Field(i)
		// 取值
		labelVal := valueInfo.Field(i)
		fieldType := labelField.Type
		// 判断字段类型
		if fieldType.Kind() != reflect.Struct {
			continue
		}

		// 拼的是[server]和[mysql]
		// 获取tag
		tagVal := labelField.Tag.Get("ini")
		if len(tagVal) == 0 {
			tagVal = labelField.Name
		}
		label := fmt.Sprintf("\n[%s]\n", tagVal)
		conf = append(conf, label)
		// 拼 k-v
		for j := 0; j < fieldType.NumField(); j++ {
			// 这里取到的是大写
			keyField := fieldType.Field(j)
			// 取tag
			fieldTagVal := keyField.Tag.Get("ini")
			if len(fieldTagVal) == 0 {
				fieldTagVal = keyField.Name
			}
			// 取值
			valField := labelVal.Field(j)
			// Interface{}取真正对应的值
			item := fmt.Sprintf("%s=%v\n", fieldTagVal, valField.Interface())
			conf = append(conf, item)
		}
	}

	// 遍历切片转类型
	for _, val := range conf {
		byteVal := []byte(val)
		result = append(result, byteVal...)
	}
	return
}

func UnMarshalFile(fileName string, result interface{}) error {
	// 1.文件读取
	data, err := ioutil.ReadFile(fileName)
	if err != nil {
		return err
	}
	// 2.进行反序列化
	return UnMarshal(data, result)
}

func UnMarshal(data []byte, result interface{}) (err error) {
	// 先判断是否是指针
	typeInfo := reflect.TypeOf(result)
	if typeInfo.Kind() != reflect.Ptr {
		return
	}

	// 判断是否是结构体
	if typeInfo.Elem().Kind() != reflect.Struct {
		return
	}

	// 转类型，按行切割
	lineArr := strings.Split(string(data), "\n")
	// 定义全局标签名，也就是server和mysql
	var myFieldName string

	for _, line := range lineArr {
		// 各种严谨判断
		line = strings.TrimSpace(line)
		// 处理文档中有注释的情况
		if len(line) == 0 || line[0] == ';' || line[0] == '#' {
			continue
		}

		// 按照括号去判断
		if line[0] == '[' {
			// 按照大标签去处理
			myFieldName, err = myLabel(line, typeInfo.Elem())
			if err != nil {
				return
			}
			continue
		}
		// 按照正常数据处理
		err = myField(myFieldName, line, result)
		if err != nil {
			return
		}
	}
	return
}

// 处理大标签
func myLabel(line string, typeInfo reflect.Type) (fieldName string, err error) {
	// 去字符串头和尾
	labelName := line[1 : len(line)-1]
	// 循环去结构体找tag，对应上才能解析
	for i := 0; i < typeInfo.NumField(); i++ {
		field := typeInfo.Field(i)
		tagValue := field.Tag.Get("ini")
		// 判断tag
		if labelName == tagValue {
			fieldName = field.Name
			break
		}
	}
	return
}

// 解析属性
// 参数：大标签名，行数据，对象
func myField(fieldName string, line string, result interface{}) (err error) {
	fmt.Println(line)
	key := strings.TrimSpace(line[0:strings.Index(line, "=")])
	val := strings.TrimSpace(line[strings.Index(line, "=")+1:])

	// 解析到结构体
	// resultType := reflect.TypeOf(result)
	resultValue := reflect.ValueOf(result)
	// 拿到字段值，这里直接设置不知道的类型
	labelValue := resultValue.Elem().FieldByName(fieldName)
	// 拿到该字段类型
	fmt.Println(labelValue)
	labelType := labelValue.Type()
	// 第一次进来应该是server
	// 存放取到的字段名
	var keyName string
	// 遍历server结构体的所有字段
	for i := 0; i < labelType.NumField(); i++ {
		// 获取结构体字段
		field := labelType.Field(i)
		tagVal := field.Tag.Get("ini")
		if tagVal == key {
			keyName = field.Name
			break
		}
	}

	// 给字段赋值
	// 取字段值
	fieldValue := labelValue.FieldByName(keyName)
	// 修改值
	switch fieldValue.Type().Kind() {
	case reflect.String:
		fieldValue.SetString(val)
	case reflect.Int:
		i, err2 := strconv.ParseInt(val, 10, 64)
		if err2 != nil {
			fmt.Println(err2)
			return
		}
		fieldValue.SetInt(i)
	case reflect.Uint:
		i, err := strconv.ParseUint(val, 10, 64)
		if err != nil {
			fmt.Println(err)
			return err
		}
		fieldValue.SetUint(i)
	case reflect.Float32:
		f, _ := strconv.ParseFloat(val, 64)
		fieldValue.SetFloat(f)
	}
	return
}

main.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main

import (
	"fmt"
	"io/ioutil"
)

func parseFile(fileName string) {
	data, err := ioutil.ReadFile(fileName)
	if err != nil {
		return
	}
	var conf Config
	err = UnMarshal(data, &conf)
	if err != nil {
		return
	}
	fmt.Printf("反序列化成功 conf: %#v\n port:%#v\n", conf, conf.ServerConf.Port)
}

func parseFile2(fileName string) {
	// 有一些假数据
	var conf Config
	conf.ServerConf.Ip = "127.0.0.1"
	conf.ServerConf.Port = 8000
	conf.MysqlConf.Port = 9000
	err := MarshalFile(fileName, conf)
	if err != nil {
		return
	}
}

func main() {
	//parseFile("/Users/louris/tech_learning/go_reflect_practise/config.ini")
	parseFile2("/Users/louris/tech_learning/go_reflect_practise/config_test.ini")
}

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

做一个安静细微的人，<br> 于角落里自在开放，<br> 默默悦人，<br> 却始终不引起过分热闹的关注，<br> 保有独立而随意的品格，<br> 这就很好。<br><br> Stick to what you insist on,<br> believe what you believe!<br> Life hastily for decades,<br> do what I can!