Go标准库：Json解析陷阱与版本变动时的偷懒技巧

本文转载自微信公众号「机智的程序员小熊」，作者小熊。转载本文请联系机智的程序员小熊公众号。

在南山等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都网站设计、网站建设、外贸网站建设 网站设计制作按需网站设计,公司网站建设,企业网站建设,成都品牌网站建设,营销型网站建设,外贸网站制作,南山网站建设费用合理。

日常工作中，最常用的数据传输格式就是json，而encoding/json库是内置做解析的库。这一节来看看它的用法，还有几个日常使用中隐晦的陷阱和处理技巧。

  • json 与 struct
  • 解析
  • 反解析
  • 陷阱 1、忘记取地址
  • 陷阱 2、大小写
  • 陷阱 3、十六进制或其他非 UTF8 字符串
  • 陷阱 4、数字转 interface{}
  • 神技、版本变更兼容
  • 小结

json 与 struct

一个常见的接口返回内容如下：

 
 
 
 
    
  
  
  
  
  1. { 
    2. 
  
  
  
  
  2.   "data": { 
    3. 
  
  
  
  
  3.     "items": [ 
    4. 
  
  
  
  
  4.       { 
    5. 
  
  
  
  
  5.         "_id": 2 
    6. 
  
  
  
  
  6.       } 
    7. 
  
  
  
  
  7.     ], 
    8. 
  
  
  
  
  8.     "total_count": 1 
    9. 
  
  
  
  
  9.   }, 
    10. 
  
  
  
  
  10.   "message": "", 
    11. 
  
  
  
  
  11.   "result_code": 200 
    12. 
  
  
  
  
  12. } 
    13.

在golang中往往是要把json格式转换成结构体对象使用的。

在新版Goland粘贴json会自动生成结构体，也可以在网上搜到现成的工具完成自动转换。

 
 
 
 
    
  
  
  
  
  1. type ResponseData struct { 
    2. 
  
  
  
  
  2.  Data struct { 
    3. 
  
  
  
  
  3.   Items []struct { 
    4. 
  
  
  
  
  4.    Id int `json:"_id"` 
    5. 
  
  
  
  
  5.   } `json:"items"` 
    6. 
  
  
  
  
  6.   TotalCount int `json:"total_count"` 
    7. 
  
  
  
  
  7.  } `json:"data"` 
    8. 
  
  
  
  
  8.  Message    string `json:"message"` 
    9. 
  
  
  
  
  9.  ResultCode int    `json:"result_code"` 
    10. 
  
  
  
  
  10. } 
    11.

用反斜杠加注解的方式表明属于json中哪个字段，要注意不应该嵌套层数过多，否则难以阅读容易出错。

一般把内部结构体提出来，方便其他业务另做他用。

 
 
 
 
    
  
  
  
  
  1. type ResponseData struct { 
    2. 
  
  
  
  
  2.  Data struct { 
    3. 
  
  
  
  
  3.   Items []Body `json:"items"` 
    4. 
  
  
  
  
  4.   TotalCount int64 `json:"total_count"` 
    5. 
  
  
  
  
  5.  } `json:"data"` 
    6. 
  
  
  
  
  6.  Message    string `json:"message"` 
    7. 
  
  
  
  
  7.  ResultCode int64  `json:"result_code"` 
    8. 
  
  
  
  
  8. } 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. type Body struct { 
    11. 
  
  
  
  
  11.  ID int `json:"_id"` 
    12. 
  
  
  
  
  12. } 
    13.

解析

解析就是把json字符串转成struct类型。如下，第一个参数为字节数组，第二个为接收的结构体实体地址。如有报错返回错误信息，如没有返回nil。

 
 
 
 
    
  
  
  
  
  1. //函数签名 
    2. 
  
  
  
  
  2. func Unmarshal(data []byte, v interface{}) error 
    3. 
  
  
  
  
  3. // 用法 
    4. 
  
  
  
  
  4. err := json.Unmarshal([]byte(jsonStr), &responseData) 
    5.

完整代码如下

 
 
 
 
    
  
  
  
  
  1. func foo() { 
    2. 
  
  
  
  
  2.  jsonStr := `{"data":{"items":[{"_id":2}],"total_count":1},"message":"","result_code":200}` 
    3. 
  
  
  
  
  3.  //把string解析成struct 
    4. 
  
  
  
  
  4.  var responseData ResponseData 
    5. 
  
  
  
  
  5.  err := json.Unmarshal([]byte(jsonStr), &responseData) 
    6. 
  
  
  
  
  6.  if err != nil { 
    7. 
  
  
  
  
  7.   fmt.Println("parseJson error:" + err.Error()) 
    8. 
  
  
  
  
  8.   return 
    9. 
  
  
  
  
  9.  } 
    10. 
  
  
  
  
  10.  fmt.Println(responseData) 
    11. 
  
  
  
  
  11. } 
    12.

输出如下，和java的toString不同，go会直接输出了值，如有需要要自行实现并绑定ToString方法。

 
 
 
 
    
  
  
  
  
  1. {{[{2}] 1}  200} 
    2.

反解析

第一步，复习初始化结构体的方法。

 
 
 
 
    
  
  
  
  
  1. r := ResponseData{ 
    2. 
  
  
  
  
  2.     Data: struct { 
    3. 
  
  
  
  
  3.         Items      []Body `json:"items"` 
    4. 
  
  
  
  
  4.         TotalCount int64  `json:"total_count"` 
    5. 
  
  
  
  
  5.     }{ 
    6. 
  
  
  
  
  6.         Items: []Body{ 
    7. 
  
  
  
  
  7.             {ID: 1}, 
    8. 
  
  
  
  
  8.             {ID: 2}, 
    9. 
  
  
  
  
  9.         }, 
    10. 
  
  
  
  
  10.         TotalCount: 1, 
    11. 
  
  
  
  
  11.     }, 
    12. 
  
  
  
  
  12.     Message:    "", 
    13. 
  
  
  
  
  13.     ResultCode: 200, 
    14. 
  
  
  
  
  14. } 
    15.

如上，无类型的结构体Data需要明确把类型再写一遍，再为其赋值。[]Body因为是列表类型，内部如上赋值即可。

反解析函数签名如下，传入结构体，返回编码好的[]byte，和可能的报错信息。

 
 
 
 
    
  
  
  
  
  1. func Marshal(v interface{}) ([]byte, error) 
    2.

完整代码如下

 
 
 
 
    
  
  
  
  
  1. func bar() { 
    2. 
  
  
  
  
  2.  r := ResponseData{ 
    3. 
  
  
  
  
  3.   .... 
    4. 
  
  
  
  
  4.  } 
    5. 
  
  
  
  
  5.  //把struct编译成string 
    6. 
  
  
  
  
  6.  resBytes, err := json.Marshal(r) 
    7. 
  
  
  
  
  7.  if err != nil { 
    8. 
  
  
  
  
  8.   fmt.Println("convertJson error: " + err.Error()) 
    9. 
  
  
  
  
  9.  } 
    10. 
  
  
  
  
  10.  fmt.Println(string(resBytes)) 
    11. 
  
  
  
  
  11. } 
    12.

输出

 
 
 
 
    
  
  
  
  
  1. {"data":{"items":[{"_id":1},{"_id":2}],"total_count":1},"message":"","result_code":200} 
    2.

陷阱 1、忘记取地址

解析的代码在结尾处应该是&responseData) 忘记取地址会导致无法赋值成功，返回报错。

 
 
 
 
    
  
  
  
  
  1. err := json.Unmarshal([]byte(jsonStr), responseData) 
    2.

输出报错

 
 
 
 
    
  
  
  
  
  1. json: Unmarshal(non-pointer main.ResponseData) 
    2.

陷阱 2、大小写

定义一个简单的结构体来演示这个陷阱。

 
 
 
 
    
  
  
  
  
  1. type People struct { 
    2. 
  
  
  
  
  2.  Name string `json:"name"` 
    3. 
  
  
  
  
  3.  age  int    `json:"age"` 
    4. 
  
  
  
  
  4. } 
    5.

变量如果需要被外部使用，也就是java中的public权限，定义时首字母必须用大写，这也是Go约定的权限控制。

 
 
 
 
    
  
  
  
  
  1. type People struct 
    2.

要用来解析json的struct内部，假如使用了小写作为变量名，会导致无法解析成功，而且不会报错!

 
 
 
 
    
  
  
  
  
  1. func err1() { 
    2. 
  
  
  
  
  2.  reqJson := `{"name":"minibear2333","age":26}` 
    3. 
  
  
  
  
  3.  var person People 
    4. 
  
  
  
  
  4.  err := json.Unmarshal([]byte(reqJson), &person) 
    5. 
  
  
  
  
  5.  if err != nil {...} 
    6. 
  
  
  
  
  6.  fmt.Println(person) 
    7. 
  
  
  
  
  7. } 
    8.

输出 0，没有成功取到age字段。

 
 
 
 
    
  
  
  
  
  1. {minibear2333 0} 
    2.

这是因为标准库中是使用反射来获取的，私有字段是无法获取到的，源码内部不知道有这个字段，自然无法显示报错信息。

我以前没有用自动解析，手敲上去结构体，很容易出现这样的问题，把某个字段首字母弄成小写。好在编译器会有提示。

陷阱 3、十六进制或其他非 UTF8 字符串

Go 默认使用的字符串编码是 UTF8 编码的。直接解析会出错

 
 
 
 
    
  
  
  
  
  1. func err2() { 
    2. 
  
  
  
  
  2.  raw := []byte(`{"name":"\xc2"}`) 
    3. 
  
  
  
  
  3.  var person People 
    4. 
  
  
  
  
  4.  if err := json.Unmarshal(raw, &person); err != nil { 
    5. 
  
  
  
  
  5.   fmt.Println(err) 
    6. 
  
  
  
  
  6.  } 
    7. 
  
  
  
  
  7. } 
    8.

输出

 
 
 
 
    
  
  
  
  
  1. invalid character 'x' in string escape code 
    2.

要特别注意，加上反斜杠转义可以成功，或者使用base64编码成字符串，这下子单元测试的重要性就体现出来了。如下:

 
 
 
 
    
  
  
  
  
  1. raw := []byte(`{"name":"\\xc2"}`) 
    2. 
  
  
  
  
  2. raw := []byte(`{"name":"wg=="}`) 
    3.

其他需要注意的是编码如果不是UTF-8格式，那么Go会用 ? (U+FFFD) 来代替无效的 UTF8，这不会报错，但是获得的字符串可能不是你需要的结果。

陷阱 4、数字转 interface{}

因为默认编码无类型数字视为 float64 。如果想用类型判断语句为int会直接panic。

 
 
 
 
    
  
  
  
  
  1. func err4() { 
    2. 
  
  
  
  
  2.  var data = []byte(`{"age": 26}`) 
    3. 
  
  
  
  
  3.  var result map[string]interface{} 
    4. 
  
  
  
  
  4.  ... 
    5. 
  
  
  
  
  5.  var status = result["age"].(int) //error 
    6. 
  
  
  
  
  6. } 
    7.
  • 上面的代码隐含一个知识点，json中value是简单类型时，可以直接解析成字典。
  • 如果有嵌套，那么内部类型也会解析成字典。
  • 解析成字典，输出的时候有类似ToString的效果。

运行时 Panic:

 
 
 
 
    
  
  
  
  
  1. panic: interface conversion: interface {} is float64, not int 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. goroutine 1 [running]: 
    4. 
  
  
  
  
  4. main.err4() 
    5.

可以先转换成float64再转换成int

其实还有几种方法，太麻烦了也没有必要，就不做特别介绍了。

神技、版本变更兼容

你有没有遇到过一种场景，一个接口更新了版本，把json的某个字段变更了，在请求的时候每次都定义两套struct。

比如Age在版本 1 中是int在版本 2 中是string，解析的过程中就会出错。

 
 
 
 
    
  
  
  
  
  1. json: cannot unmarshal number into Go struct field People.age of type string 
    2.

我在下面介绍一个技巧，可以省去每次解析都要转换的工作。

我在源码里面看到，无论反射获得的是哪种类型都会去调用相应的解析接口UnmarshalJSON。

结合前面的知识，在Go里面看起来像鸭子就是鸭子，我们只要实现这个方法，并绑定到结构体对象上，就可以让源码来调用我们的方法。

 
 
 
 
    
  
  
  
  
  1. type People struct { 
    2. 
  
  
  
  
  2.     Name string `json:"name"` 
    3. 
  
  
  
  
  3.     Age  int    `json:"_"` 
    4. 
  
  
  
  
  4. } 
    5. 
  
  
  
  
  5. func (p *People) UnmarshalJSON(b []byte) error { 
    6. 
  
  
  
  
  6.  ... 
    7. 
  
  
  
  
  7. } 
    8.
  • 使用下划线表示此类型不解析。
  • 必须用指针的方式绑定方法。
  • 必须与 interface{}中定义的方法签名完全一致。

一共有四个步骤

1、定义临时类型。用来接受非json:"_"的字段，注意用的是type关键字。

 
 
 
 
    
  
  
  
  
  1. type tmp People 
    2.

2、用中间变量接收 json 串，tmp 以外的字段用来接受json:"_"属性字段

 
 
 
 
    
  
  
  
  
  1. var s = &struct { 
    2. 
  
  
  
  
  2.     tmp 
    3. 
  
  
  
  
  3.     // interface{}类型，这样才可以接收任意字段 
    4. 
  
  
  
  
  4.     Age interface{} `json:"age"` 
    5. 
  
  
  
  
  5. }{} 
    6. 
  
  
  
  
  6. // 解析 
    7. 
  
  
  
  
  7. err := json.Unmarshal(b, &s) 
    8.

3、判断真实类型，并类型转换

 
 
 
 
    
  
  
  
  
  1. switch t := s.Age.(type) { 
    2. 
  
  
  
  
  2. case string: 
    3. 
  
  
  
  
  3.     var age int 
    4. 
  
  
  
  
  4.     age, err = strconv.Atoi(t) 
    5. 
  
  
  
  
  5.     if err != nil {...} 
    6. 
  
  
  
  
  6.     s.tmp.Age = age 
    7. 
  
  
  
  
  7. case float64: 
    8. 
  
  
  
  
  8.     s.tmp.Age = int(t) 
    9. 
  
  
  
  
  9. } 
    10.

4、tmp 类型转换回 People，并赋值

 
 
 
 
    
  
  
  
  
  1. *p = People(s.tmp) 
    2.

小结

通过本节，我们掌握了标准库中json解析和反解析的方法，以及很有可能日常工作中踩到的几个坑。它们是：

  • 陷阱 1、忘记取地址
  • 陷阱 2、大小写
  • 陷阱 3、十六进制或其他非 UTF8 字符串
  • 陷阱 4、数字转 interface{}

版本变量时兼容技巧

最后分享的技巧在实际使用中，更加灵活。

留一个作业：假如有v1和v2不同的两个版本json几乎完成不同，业务逻辑已经使用v1版本，是否可以把v2版本转换成v1版本，几乎不用改动业务逻辑?

提示：可以通过深拷贝把v2版本解析出来的结构体完全转换成v1版本的结构体。

要求：必须使用实现 UnmarshalJSON的技巧。

本文转载自微信公众号「机智的程序员小熊」，可以通过以下二维码关注。转载本文请联系机智的程序员小熊公众号。

文章题目：Go标准库：Json解析陷阱与版本变动时的偷懒技巧
当前URL：http://www.stwzsj.com/qtweb/news25/4775.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

搜索引擎优化知识

分类信息网站

成都SEO公司　　 　江油网站建设　　 　广告吸塑字　　 　传美奇电器　　 　成都品牌网站建设　　 　seo优化　　 　四川服务器托管　　 　成都网站建设哪家好　　 　成都网站改版　　 　电信内江机房　　 　葆金莱自动门　　 　雪茄烟　　 　成都企业网站设计　　 　LED显示屏厂家　　 　内江智速网站建设　　 　中国西部信息中心　　 　乐山网站建设　　 　网站seo　　 　成都网站设计　　 　雕琢时光茶叶