Golang实现优雅的将struct转换为map

疯子白侠

前言

在项目实践中，有时候我们需要将struct结构体转为map映射表，然后基于map做数据裁剪或操作。那么下面我来介绍下常用的两种转换方式，以及对它们做对比，最后采用更优雅的方式，封装到我们的项目工程的工具包里

方式1：使用JSON序列和反序列化

使用json操作的这个方式是比较简单的，容易想到也易实现。直接上代码：

1. package main
   
2. 
   
3. import (
   
4.     "encoding/json"
   
5.     "fmt"
   
6.     "time"
   
7. )
   
8. 
   
9. type Person struct {
   
10.     Name    string `json:"name"`
    
11.     Address string `json:"address"`
    
12. }
    
13. 
    
14. func main() {
    
15.     t := time.Now().UnixNano()
    
16.     m := make(map[string]interface{})
    
17.     person := Person{
    
18.        Name:    "zhangsan",
    
19.        Address: "北京海淀",
    
20.     }
    
21.     j, _ := json.Marshal(person)
    
22.     json.Unmarshal(j, &m)
    
23.     fmt.Println(m)
    
24.     fmt.Println(fmt.Sprintf("JSON-duration:%d", time.Now().UnixNano() - t))
    
25. }

复制代码

输出结果：

1. map[address:北京海淀 name:zhangsan]JSON-duration:174000

复制代码

方式2：使用反射

通过反射机制，灵活的做类型转换。具体实现：

1. package main
   
2. 
   
3. import (
   
4.     "fmt"
   
5.     "reflect"
   
6.     "time"
   
7. )
   
8. 
   
9. type Person struct {
   
10.     Name    string `json:"name"`
    
11.     Address string `json:"address"`
    
12. }
    
13. 
    
14. func main() {
    
15.     t := time.Now().UnixNano()
    
16.     m := make(map[string]interface{})
    
17.     person := Person{
    
18.         Name:    "zhangsan",
    
19.         Address: "北京海淀",
    
20.     }
    
21. 
    
22.     elem := reflect.ValueOf(&person).Elem()
    
23.     relType := elem.Type()
    
24.     for i := 0; i < relType.NumField(); i++ {
    
25.         name := relType.Field(i).Name
    
26.         m[name] = elem.Field(i).Interface()
    
27.     }
    
28. 
    
29.     fmt.Println(m)
    
30.     fmt.Println(fmt.Sprintf("反射-duration:%d", time.Now().UnixNano() - t))
    
31. }

复制代码

输出结果：

1. map[Address:北京海淀 Name:zhangsan]反射-duration:60000

复制代码

两种方式对比

执行效率：
使用反射的效率，明显比使用json的效率要高，接近3倍
输出结果：
使用json能达到预期，正常解析出结构体tag；
使用反射未能达到预期，未解析出结构体tag，字段是以结构体定义为准

封装到工具包

基于上面两种方式的对比，我们决定采用反射机制，并对结构体tag解析做兼容，优雅的将struct转换为map，并封装到工具包中
具体实现，工具包代码：

1. package utils
   
2. 
   
3. import (
   
4.     "reflect"
   
5.     "strings"
   
6. )
   
7. 
   
8. type IStruct interface {
   
9.     GetStructData() interface{}
   
10. }
    
11. 
    
12. //struct转map
    
13. //使用反射实现，完美地兼容了json标签的处理
    
14. func StructToMap(st IStruct) map[string]interface{} {
    
15.     m := make(map[string]interface{})
    
16.     in := st.GetStructData()
    
17.     val := reflect.ValueOf(in)
    
18.     if val.Kind() == reflect.Ptr {
    
19.         val = val.Elem()
    
20.     }
    
21.     if val.Kind() != reflect.Struct {
    
22.         return m
    
23.     }
    
24. 
    
25.     relType := val.Type()
    
26.     for i := 0; i < relType.NumField(); i++ {
    
27.         name := relType.Field(i).Name
    
28.         tag := relType.Field(i).Tag.Get("json")
    
29.         if tag != "" {
    
30.             index := strings.Index(tag, ",")
    
31.             if index == -1 {
    
32.                 name = tag
    
33.             } else {
    
34.                 name = tag[:index]
    
35.             }
    
36.         }
    
37.         m[name] = val.Field(i).Interface()
    
38.     }
    
39.     return m
    
40. }

复制代码

测试代码：

1. package main
   
2. 
   
3. import (
   
4.     "fmt"
   
5.     "learn-go/utils"
   
6.     "time"
   
7. )
   
8. 
   
9. type Person struct {
   
10.     Name    string `json:"name"`
    
11.     Address string `json:"address"`
    
12. }
    
13. 
    
14. //注意：必须实现这个方法，才能正确调用工具包转换方法
    
15. func (p Person) GetStructData() interface{} {
    
16.     return p
    
17. }
    
18. 
    
19. func main() {
    
20.     t := time.Now().UnixNano()
    
21.     m := make(map[string]interface{})
    
22.     person := Person{
    
23.         Name:    "zhangsan",
    
24.         Address: "北京海淀",
    
25.     }
    
26. 
    
27.     m = utils.StructToMap(person)
    
28.     fmt.Println(m)
    
29.     fmt.Println(fmt.Sprintf("反射2-duration:%d", time.Now().UnixNano() - t))
    
30. }

复制代码

输出结果：

1. map[address:北京海淀 name:zhangsan]反射2-duration:65000

复制代码

结论：
执行效率高的同时，输出结果也符合预期，能正确的解析出结构体tag
到此这篇关于Golang实现优雅的将struct转换为map的文章就介绍到这了,更多相关Golang struct转map内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

付阳傅

看看，学习学习～～～～

美嘉631

感谢楼主分享～～～～～

玟玉278

顶顶更健康！！！

epxkapngze

路过，支持一下

凡八哥

感谢楼主，顶。