一、背景介绍
在go语言开发过程中经常需要将json字符串解析为struct,通常我们都是根据json的具体层级关系定义对应的struct，然后通过json.Unmarshal()命令实现json到struct对象的转换，然后再根据具体逻辑处理相应的数据。
你是否遇到过在无法准确确定json层级关系的情况下对json进行解析的需求呢？
接下来我将介绍一次解析不确定的json对象的经历，以及遇到的问题和解决方法。
假设我们需要调用某个http接口从而获得一件商品的相似品推荐结果,该服务的输入参数只有一个skuId参数,接口的返回数据时json格式,并且同时存在两种返回参数。我们无法通过入参判断接口返回哪一种结果(估计这种异常是http服务开发者无意导致的，但是没办法，我们必须基于该服务接口开发某种功能。)
具体的，返回结果有两种情况
第一种
{
"return": "0",
"result":[
{
"goods_id": 37278077211,
....
"shop_name": "xxxxx",
},
{
"goods_id": 236492067349,
....
"shop_name": "xxxxx",
}
]
}
第二种
{
"return": "0",
"result": {
"data": [
{
"goods_id": 58054798450,
......
"shop_name": "xxxxxxxx"
},
{
"goods_id": 27395404673,
......
"shop_name": "xxxxxxxx"
}
]
}
}
二、解决方案
(1)将Json直接解析为map
由于在解析前我们并不能确定result到底是一个struct还是一个Slice,因此我们也无法直接利用json.Unmarshal一步解出对应的struct对象。好在我们知道所有json都可以直接解析成map[string]interface{}的结构，因此我们可以将json先转化为map,然后根据结构名key去决定后续的转换流程，具体代码如下：
var object interface{}
var data interface{}
err := json.Unmarshal([]byte(jsonStr),&object)
if err != nil{
fmt.Printf("unmarshal %s error: %s\n",jsonStr,err.Error())
}
//判断returnCode
ret := object.(map[string]interface{})["return"]
if ret != 0{
fmt.Println("the response of http error")
}
//判断result是何种类型
result := object.(map[string]interface{})["result"]
resultType := reflect.TypeOf(result)
if resultType.Kind() == reflect.Map{
data = result.(map[string]interface{})["data"]
}
if resultType.Kind() == reflect.Slice{
data = result
}
//解析goods_id
var skuList []int64
for _,v := range data.([]interface{}){
preSku := v.(map[string]interface{})["goods_id"].(float64)
skuList = append(skuList,int64(preSku))
}
fmt.Printf("the skuLst = %+v\n",skuList)
这种方式的优点是只需要Unmarshal一次，缺点是每一级都需要显示的去做类型转化，书写起来比较繁琐。尤其是json本身结构复杂，其中只有一小部分需要确定具体类型的情况下，解析过程会更加繁琐复杂。
那么是否可以只解析确定部分，不确定的部分先保留[]byte的原始格式，按map解析呢？
答案是肯定的。这时候就需要用到json.RawMessage字段类型了
(2)、解析部分json struct的方法 (json.RawMessage的用法)
在解析json过程中，有时我们可能只需要解析json的某一部分数据，比如，当json中只有一部分是我们需要的数据，或者我们需要先解析一部分数据，才能根据解析的部分数据来决定剩余数据如何解析。我们继续以上面的需求为例。此时需要我们预先定义需要解析的部分
type RespStruct struct {
RetCode int `json:"return"`
Result json.RawMessage `json:"result"`
}
我们首先解析return字段。result字段内容将继续保持[]byte类型的状态。接下来我们继续解析剩余部分
var object RespStruct
err := json.Unmarshal([]byte(jsonStr2),&object)
if err != nil{
fmt.Printf("unmarshal %s error: %s\n",jsonStr,err.Error())
}
//判断returnCode
if object.RetCode != 0{
fmt.Println("the response of http error")
}
//判断result是何种类型
var data interface{}
err = json.Unmarshal(object.Result,&data)
if err != nil{
fmt.Printf("unmarshal %s error: %s\n",object.Result,err.Error())
}
resultType := reflect.TypeOf(data)
if resultType.Kind() == reflect.Map{
data = data.(map[string]interface{})["data"]
}
//解析goods_id
var skuList []int64
for _,v := range data.([]interface{}){
preSku := v.(map[string]interface{})["goods_id"].(float64)
skuList = append(skuList,int64(preSku))
}
fmt.Printf("the skuLst = %+v\n",skuList)
看到这里，有人可能会产生疑问，我可不可以将不需要解析的字段定义为[]byte 类型呢，毕竟解析为rawMessage类型后，该字段本身也是[]byte。通过实验我们发现是不可以的，如果将rawMessage替换为 []byte类型，解析过程会返回错误，因为在json包中，虽然RawMessage类型时 []byte的别名，但是解析过程中，只处理rawMessage类型(golang 是强类型编程语言)。
type RawMessage []byte
(3) json.Number类型的使用
在上个实验中，有些同学可能发现，为什么goods_id字段的类型先由interface{}类型转为float64，然后才被转换为我们需要的int64呢？
这是因为在 json 中是没有整型和浮点型之分的，当我们利用json 包中的 Unmarshal 方法将数字类型解析为interface{}时，它就会将把所有数字类型全部转换为和规范最接近的float64类型。如果我们希望更加方便的将数字类型准换为指定的类型，就需要用到json.Number这个类型。具体如下：
var object RespStruct
err := json.Unmarshal([]byte(jsonStr),&object)
if err != nil{
fmt.Printf("unmarshal %s error: %s\n",jsonStr,err.Error())
}
//判断returnCode
if object.RetCode != 0{
fmt.Println("the response of http error")
}
//判断result是何种类型
var data interface{}
decoder := json.NewDecoder(bytes.NewReader(object.Result))
decoder.UseNumber()
decoder.Decode(&data)
resultType := reflect.TypeOf(data)
if resultType.Kind() == reflect.Map{
data = data.(map[string]interface{})["data"]
}
//解析goods_id
var skuList []int64
for _,v := range data.([]interface{}){
preSku,err := v.(map[string]interface{})["goods_id"].(json.Number).Int64()
if err != nil{
fmt.Printf("get goods_id error")
}
skuList = append(skuList,preSku)
}
fmt.Printf("the skuLst = %+v\n",skuList)
利用json.Number类型可以让我们很方便的将数字类型转换成我们想要的类型，除了转换为int64类型外，还支持转换为float64和string。
为了进一步了解json.Number的实现，我们查看相关源码可以发现
//decode.go
// A Number represents a JSON number literal.
type Number string
// String returns the literal text of the number.
func (n Number) String() string { return string(n) }
// Float64 returns the number as a float64.
func (n Number) Float64() (float64, error) {
return strconv.ParseFloat(string(n), 64)
}
// Int64 returns the number as an int64.
func (n Number) Int64() (int64, error) {
return strconv.ParseInt(string(n), 10, 64)
}
通过源码我们可以发现json.Number本身是string类型，只是在json包中被定义了别名，然后通过封装的三个方法，实现了将string转换为int64和float64类型的方法。
以上就是本篇文章的全部内容啦。
参考文档
go json 实践中遇到的坑
Go语言reflect.TypeOf()和reflect.Type
有疑问加站长微信联系（非本文作者）
