本文摘自网络，作者，侵删。

一、背景介绍

在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类型的方法。

以上就是本篇文章的全部内容啦。