Golang——reflect(反射)

已于 2024-05-18 11:33:43 修改
阅读量767 收藏 3
点赞数 5
分类专栏： golang 文章标签： golang
于 2024-05-18 10:50:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57023347/article/details/138973771
版权

        反射是指在程序运行期间对程序本身进行访问和修改的能力。

        一. 变量的内在机制

  • 变量包含类型信息和值信息
  • 类型信息：是静态的元信息，是预先定义好的
  • 值信息：是程序运行过程中动态改变的

        二. 反射的使用

  • reflect包封装了反射相关的方法
  • 获取类型信息：reflect.TypeOf，是静态的
  • 获取值信息：reflect.ValueOf，是动态的

        三. 空接口和反射

  • 反射可以在运行时动态获取程序的各种详细信息
  • 反射获取interface类型信息

  • 反射获取interface值信息

  • 反射修改值信息

 四. 结构体与反射

  • 查看类型，字段和方法

        注意：结构体方法名和属性名必须大写，否则获取不到方法或报错。

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Id   int
	Name string
	Age  int
}

func (u User) SayHello() {
	fmt.Println("hello")
}

func Poni(x interface{}) {
	//获取类型
	t := reflect.TypeOf(x)
	fmt.Println(t)
	fmt.Println("字符串类型：", t.Name())

	//获取值
	v := reflect.ValueOf(x)
	fmt.Println("值：", v)

	//获取所有属性
	//通过类型获取结构体字段个数
	for i := 0; i < t.NumField(); i++ {
		//通过类型取每一个字段，包括类型和字段变量名
		f := t.Field(i)
		fmt.Printf("%s, %v\n", 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 main() {
	u := User{
		1,
		"wy",
		20,
	}
	Poni(u)
}

  •  查看匿名字段

  • 修改结构体的值

  • 调用结构体方法

  • 获取字段的tag

        标签保存在类型的reflect.StructField结构体里。

 五.反射练习

  • 任务：解析如下配置文件
    • 序列化：将结构体序列化为配置文件数据并保存到硬盘
    • 反序列化：将配置文件内容反序列化到程序的结构体
  • 配置文件有server和mysql相关配置
#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
  • 思路

        反序列化：将配置文件读上来，根据根据结构体的tag，赋值到对应结构体属性字段。利用反射(reflect)获取到tag和赋值

        序列化：利用反射(reflect)获取到对应字段tag和值，编写为对应形式，再写道文件中。

main.go：主函数

package main

import (
	"io/ioutil"
	"log"
)

// 反序列化
func parseFile(infilename string, res interface{}) {
	data, err := ioutil.ReadFile(infilename)
	if err != nil {
		log.Println("read file fail ", err)
		return
	}
	//fmt.Println(string(data))

	err = Unmarshal(data, res)
	if err != nil {
		log.Println("Unmarshal fail ", err)
		return
	}
}

// 序列化
func parseDataToFile(filename string, res interface{}) {
	data, err := Marshal(res)
	if err != nil {
		log.Println("marshal fail ", err)
		return
	}

	err = ioutil.WriteFile(filename, data, 0666)
	if err != nil {
		log.Println("write file fail  ", err)
		return
	}
}

func main() {
	var cfg Cofig
	parseFile("./config.ini", &cfg)
	log.Printf("反序列化成功%#v", cfg)

	parseDataToFile("./my.ini", &cfg)
}

model.go：结构体

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  float64 `ini:"timeout"`
}

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

init_config.go：序列化和反序列化细节实现。

package main

import (
	"errors"
	"fmt"
	"log"
	"reflect"
	"strconv"
	"strings"
)

func myLable(str string, res_type reflect.Type) (fieldname string, err error) {
	//去掉前后[]
	lable_str := str[1 : len(str)-1]
	//循环查找tag
	for i := 0; i < res_type.NumField(); i++ {
		field := res_type.Field(i)
		lable_name := field.Tag.Get("ini")
		if lable_name == lable_str {
			//属性名，不是tag名
			fieldname = field.Name
			return
		}
	}
	return
}

func myField(fieldName string, line string, res interface{}) (err error) {
	//获取key和value
	key_str := strings.TrimSpace(line[0:strings.Index(line, "=")])
	val_str := strings.TrimSpace(line[strings.Index(line, "=")+1:])

	//找到res中属性名为fieldName的field
	res_val := reflect.ValueOf(res).Elem()
	//fmt.Println(fieldName)
	lable_name := res_val.FieldByName(fieldName)

	//找到tag为key_str的属性
	lable_type := lable_name.Type()
	if lable_type.Kind() != reflect.Struct {
		return errors.New(fieldName + " is not a struct")
	}
	var key_name string
	for i := 0; i < lable_type.NumField(); i++ {
		field := lable_type.Field(i)
		tag_str := field.Tag.Get("ini")
		if tag_str == key_str {
			key_name = field.Name
			break
		}
	}

	//设置值
	val_field := lable_name.FieldByName(key_name)
	switch val_field.Type().Kind() {
	case reflect.String:
		val_field.SetString(val_str)
	case reflect.Int:
		tmp, err := strconv.ParseInt(val_str, 10, 32)
		if err != nil {
			log.Println(err)
			return err
		}
		val_field.SetInt(tmp)
	case reflect.Float64:
		tmp, err := strconv.ParseFloat(val_str, 64)
		if err != nil {
			log.Println(err)
			return err
		}
		val_field.SetFloat(tmp)
	}

	return
}

// 解析配置，序列化和反序列化
func Unmarshal(data []byte, res interface{}) (err error) {
	//得到res类型
	res_type := reflect.TypeOf(res)
	//是输出型参数，需要是指针类型
	if res_type.Kind() != reflect.Ptr {
		return errors.New("args type error not pointer")
	}
	//获得实际类型
	real_res_type := res_type.Elem()
	if real_res_type.Kind() != reflect.Struct {
		return errors.New("args real type error not struct")
	}

	//以'\n'分隔每一行
	var myFieldName string
	datalines := strings.Split(string(data), "\n")
	for _, line := range datalines {
		//去掉空格
		line = strings.TrimSpace(line)

		//处理有注释的情况
		if len(line) == 0 || line[0] == '#' || line[0] == ';' {
			continue
		}

		//按方括号判断大标签的情况
		if line[0] == '[' {
			//赋值大标签
			myFieldName, err = myLable(line, real_res_type)
			if err != nil {
				log.Println("handle lable fail ", err)
				return
			}
			continue
		}

		err = myField(myFieldName, line, res)
		if err != nil {
			continue
		}
	}

	return
}

func Marshal(res interface{}) (data []byte, err error) {
	res_type := reflect.TypeOf(res).Elem()
	res_val := reflect.ValueOf(res).Elem()
	if res_type.Kind() != reflect.Struct {
		return nil, errors.New("type error")
	}

	var lines []string
	for i := 0; i < res_type.NumField(); i++ {
		//取类型字段
		type_field := res_type.Field(i)
		//取值
		val_field := res_val.Field(i)
		//获得标签
		tag_str := type_field.Tag.Get("ini")
		if len(tag_str) == 0 {
			continue
		}
		//标签
		line := fmt.Sprintf("[%s]\n", tag_str)
		fmt.Print(line)
		lines = append(lines, line)

		if type_field.Type.Kind() != reflect.Struct {
			continue
		}
		//遍历成员的属性
		for j := 0; j < type_field.Type.NumField(); j++ {
			sub_type_field := type_field.Type.Field(j)
			//取标签
			sub_tag := sub_type_field.Tag.Get("ini")
			if len(sub_tag) == 0 {
				continue
			}
			//取值
			sub_val_field := val_field.Field(j)
			//Interface为真正的值
			line = fmt.Sprintf("%s = %v\n", sub_tag, sub_val_field.Interface())
			fmt.Print(line)
			lines = append(lines, line)
		}
		lines = append(lines, "\n")
	}

	for _, str := range lines {
		d := []byte(str)
		data = append(data, d...) //...将切片打散
	}
	return
}

 写入到文件演示：

        问题：

        我直接编译main.go出现报错：

        原因：

  • go run和go build命令都会编译文件，go run不仅编译还会直接执行文件。由于上面只输入了main.go文件，在main.go文件中引用其它文件的函数，结构或变量会出现找不到的情况。

        解决：

  • 由于go run必须输入文件，此时需要输入所有引用文件

  • go build可以不输入文件，默认自动查找引用文件并打开包。或者go build加上所有引用文件。

 

 

两片空白
关注
专栏目录
golang 反射（reflect）
pmlpml的专栏
12-20 2239
反射是现代程序必备的元素，用于在运行时获取程序元数据，实现动态识别类型及其结构，以及相关的语义信息。
golang 初始化并赋值_Go 语言——用反射实现初始化
weixin_39900286的博客
12-21 642
背景type MyB struct{Age *int}type MyA struct{Name *stringB *MyB}func main() {a := MyA{}fmt.Println("a", a) // a { } fmt.Println("a.B", a.B) // a.B // panic: runtime error: invalid memory address ...
golang中的reflect(反射)
_____________________________________simanstar____
01-26 4396
一、概述 在golang中，reflect是一个比较高级的话题，本文将尽可能简单而又清楚的介绍相关内容。 本文将从如下几个方面进行阐述： - 什么是reflection ？ - 如何检查一个变量var 并获得其真实类型 - golang中的reflect包 1.1 reflect.Type 和 reflect.Value 1.2 reflect.Kind 1.3 NumField() 和 Field() 1.4 Int() 和 String() - 完整实例 - 如何使用reflection 二、什么
八、golang基础之reflect反射
最新发布
weixin_54447296的博客
07-15 1061
反射可以大大提高程序的灵活性，使得interface{}有更大的发挥余地反射必须结合interface才玩得转 变量的type要是concrete type的（也就是interface变量）才有反射一说反射可以将“接口类型变量”转换为“反射类型对象”反射使用 TypeOf 和 ValueOf 函数从接口中获取目标对象信息反射可以将“反射类型对象”转换为“接口类型变量reflect.value.Interface().(已知的类型)遍历reflect.Type的Field获取其Field。
golang reflect
weixin_34306676的博客
10-15 95
golang reflect go语言中reflect反射机制。详细原文：地址 接口值到反射对象 package main import ( "fmt" "reflect" ) func main() { var x int = 1 fmt.Println("type: ", reflect.TypeOf(x)) } type: int TypeOf函数...
GoLang反射
m0_53157173的博客
08-15 5999
反射是 Go 语言比较重要的特性。虽然在大多数的应用和服务中并不常见，但是很多框架都依赖 Go 语言的反射机制实现简化代码的逻辑。因为 Go 语言的语法元素很少、设计简单，所以它没有特别强的表达能力，但是 Go 语言的 reflect 包能够弥补它在语法上的一些劣势。reflect 实现了运行时的反射能力，能够让程序操作不同类型的对象。...
golang 反射
baixiao9898的博客
04-27 157
参考：|--http://blog.51cto.com/speakingbaicai/1707637 　　　|--https://studygolang.com/articles/6324 　　反射是在golang程序运行时检查变量所具有类型的一种机制。由于反射可以得出关于变量结构的数据（即“关于数据的数据”），所以这也被认为是golang元编程的基础。我们由反射三法则入手： ...
golang——反射
qq_43747991的博客
04-13 4770
反射基本概念反射规则反射API反射三定律反射优缺点优点缺点 基本概念 Go的反射基础是接口和类型系统。Go的反射借助了实例到接口的转换所使用的的数据结构，首先将实例传递给内部的空接口，实际上是将一个实例类型转换为接口可以表述的数据结构eface ，反射基于这个转换后的数据结构来访问和操作实例的值和类型。 在Golang的实现中，每个interface变量都有一个对应的pair，pair中记录了实际变量的值和类型： (value, type) value是实际变量值，type是实际变量的类型。一个inte
golang interface 与 反射
惜暮
02-01 2884
golang interface 与 反射golang interface 使用场景golang interface 数据结构golang interface 一些使用场景原理函数参数是 interface 的成本interface{}和带方法的interface的赋值过程动态类型与动态分发是如何实现的，动态分发什么时候进行，并且有什么样的调用成本如何进行类型转换如何进行断言，断言的成本有多高为什...
Golang_反射
DkSakura的博客
05-10 1341
一、引入 先看官方Doc中Rob Pike给出的关于反射的定义： Reflection in computing is the ability of a program to examine its own structure, particularly through types; it’s a form of metaprogramming. It’s also a great source of confusion. (在计算机领域，反射是一种让程序——主要是通过类型——理解其自身结构的一种能力。它是
关于Golang反射模块reflect使用方式浅谈
hdxx2022的博客
08-19 195
Golang的反射功能，在很多场景都会用到，最基础的莫过于rpc、orm跟json的编解码，更复杂的可能会到做另外一门语言的虚拟机，这篇文章主要介绍了Golang反射模块reflect使用方式探索,需要的朋友可以参考下。可以看到，我们可以很方便拿到结构体的定义信息，更加深层嵌套的定义信息也都能拿到。类型的对象，可以认为是对原对象的一个描述性质的对象（元对象，233）。方法，可以定位到一个对象下的某个名字的方法实例，通过对方法实例调用。方法绑定的是指针对象，在这样的条件下，指针指向实例的反射值就拿不到。
探究Golang中的黑科技——反射机制详解与实战
喜欢把复杂的事情说简单
08-19 302
反射机制是 Golang 中非常重要的一个特性，它可以让我们在运行时获取变量的 Type 和 Value，并对变量进行动态操作。但是，反射机制也有一些缺点，它会影响代码的性能和可读性。因此，在使用反射机制时，需要考虑到性能和可读性的平衡，避免过度使用反射机制。
Golang的reflect
Gcaptain
11-02 389
文章目录1. 概述2. 反射类型对象3. 反射的值对象4. 反射修改值5. 综合Demo 1. 概述 Go语言提供了一种机制，能够在运行时更新变量和检查它们的值、调用它们的方法和它们支持的内在操作，而不需要在编译时就知道这些变量的具体类型。这种机制被称为反射。反射也可以让我们将类型本身作为第一类的值类型处理。 2. 反射类型对象 使用reflect.TypeOf() 函数获取任意变量的...
golang中的反射
wowzai的专栏
07-11 6640
Golang中的反射 今天看了一下golang中的反射，觉得golang中的反射还是比较容易使用的。 类型和接口 由于反射是基于类型系统(type system)的，所以先简单了解一下类型系统。 首先Golang是一种静态类型的语言，在编译时每一个变量都有一个类型对应，例如：int,floate32,[]byte,*MyType等等。如果我们这样声明： type MyInt int v
golang：reflect
OceanStar的博客
02-28 304
引入 反射机制是程序能够检测其自身结果，属于元编程的范畴，强大的同时也往往是困扰的源头。虽然各种语言的反射模型有所不同，但是通过简单的比较也能有所收获。虽然各种语言的反射模型有所不同，但是通过简单的比较也能有所收获。在了解Go的反射机制之前先来看看Java的反射机制吧。 java的反射机制： 我们所熟知的java的反射机制是什么？对于类和对象的使用，普通的方式是知道类和对象的属性和方法之后进行调...
Go语言之反射
weixin_34273046的博客
11-25 136
和Java语言一样，Go也实现运行时反射，这为我们提供一种可以在运行时操作任意类型对象的能力。比如我们可以查看一个接口变量的具体类型，看看一个结构体有多少字段，如何修改某个字段的值等。 TypeOf和ValueOf 在Go的反射定义中，任何接口都会由两部分组成的，一个是接口的具体类型，一个是具体类型对应的值。比如var i int = ...
GoLang(7)反射
tangyaya8的博客
03-02 352
什么是反射 反射是指在程序运行的时候，可以修改它本身状态的一种行为和能力，它能获取到一些元数据，比如java语言中类的成员变量，方法，注解等元数据，go语言中结构体的field，方法等等，有了反射可以让语言变得更加灵活和更多的功能，比如java中的jdk自带的动态代理就用到了反射，再比如很多框架和封装的ORM也大量用到了反射机制，我们来了解一下go语言的反射。 GO语言中的反射 go是一个比较年轻...
golang package reflect
Geek猫的专栏
01-12 544
reflect包实现了运行时反射，允许程序操作任意类型的对象。典型用法是用静态类型interface{}保存一个值，通过调用TypeOf获取其动态类型信息，该函数返回一个Type类型值。调用ValueOf函数返回一个Value类型值，该值代表运行时的数据。Zero接受一个Type类型参数并返回一个代表该类型零值的Value类型值。 import “reflect” type Type inte...
golang reflect
weixin_33730836的博客
10-05 251
reflect包实现了运行时反射，允许程序操作任意类型的对象。典...
golang json 获取所有key_Golang —— JSON 大法
06-10
好的，您的问题是如何在 Golang 中获取 JSON 数据的所有键（key）？ 在 Golang 中，可以使用 `encoding/json` 包来处理 JSON 数据。要获取 JSON 数据的所有键，您可以先将其解码为 `map[string]interface{}` 类型，然后遍历该 map 并输出所有键。 以下是一个简单的示例代码： ```go package main import ( "encoding/json" "fmt" ) func main() { // 示例 JSON 数据 jsonData := `{ "name": "John Doe", "age": 30, "email": "johndoe@example.com" }` // 将 JSON 解码为 map[string]interface{} var data map[string]interface{} err := json.Unmarshal([]byte(jsonData), &data) if err != nil { panic(err) } // 输出所有键 for key := range data { fmt.Println(key) } } ``` 输出结果： ``` name age email ``` 希望这能解决您的问题！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值