如何解析包装的json对象

珍惜时间，勤奋学习！今天给大家带来《如何解析包装的json对象》，正文内容主要涉及到等等，如果你正在学习Golang，或者是对Golang有疑问，欢迎大家关注我！后面我会持续更新相关内容的，希望都能帮到正在学习的大家！

某些 api 端点可能会返回成功结果或错误，如下所示：

// ok
{
    "status": "ok",
    "payload": {
        "id": 10,
        "title": "sample"
    },
    "request_id": "lx-vhr4olm"
}
// error
{
    "status": "error",
    "payload": {
        "message": "internal error"
    },
    "trace_id": "lx-vhr4olm"
}

我正在尝试找到用 go 解析的优雅方法，就像这样

.... some code
if status == "ok" {
    struct := appstruct{} // appstruct contains 2 fields: id and title
    _ := json.unmarshall(payloadbody, &struct)
    return struct 
} else {
    errorstruct := errorstruct{} // contains 1 field for message.
    _ := json.unmarshall(payloadbody, &errorstruct) 
    return nil, errors.new(errorstruct.message)
}

我当前的代码不适用于成功负载：

var result map[string]interface{}
jsonErr := json.Unmarshal(body, &result)
if jsonErr != nil {
    return nil, jsonErr
}
if result["status"] == "error" {
    errorPayload := result["payload"].(map[string]string)
    return nil, errors.New(errorPayload["message"])
} else if result["status"] == "ok" {
    apiResponse := AppInfo{}
    jsonErr := json.Unmarshal([]byte(result["payload"].(string)), &apiResponse)
    if jsonErr != nil {
        return nil, jsonErr
    }
    return &apiResponse, nil
}

我在 json.unmarshal([]byte(result["payload"].(string)), &apiresponse) 行上遇到运行时错误

http: 恐慌服务 [::1]:51091: 接口转换：接口 {} 是 map[string]interface {}，而不是字符串

当然，我可能有 2 个结构：用于成功响应和用于错误响应，但我认为解决我的问题的方法太复杂了。

如何优雅地解析这个 json？

解决方案

感谢https://stackoverflow.com/users/965900/mkopriva提供使用json.rawmessage的想法

我的最终解决方案：

func parsepayload(response []byte, successpayload interface{}) error {
    var result map[string]json.rawmessage
    jsonerr := json.unmarshal(response, &result)
    if jsonerr != nil {
        return jsonerr
    }
    var status string
    jsonerr = json.unmarshal(result["status"], &status)
    if jsonerr != nil {
        return jsonerr
    }
    if status == "ok" {
        jsonerr = json.unmarshal(result["payload"], &successpayload)
        if jsonerr != nil {
            return jsonerr
        }
        return nil
    } else if status == "error" {
        errorpayload := errorpayload{}
        jsonerr = json.unmarshal(result["payload"], &errorpayload)
        if jsonerr != nil {
            return jsonerr
        }
        return errors.new(errorpayload.message)
    }
    log.printf("unknown http result status: %s", status)
    return errors.new("internal error")
}

type errorpayload struct {
    message string `json:"message"`
}

//usage

type appinfo struct {
    id    int    `json:"app_id"`
    title string `json:"app_title"`
}

body := ... // read body
appinfo := appinfo{}
parseerr := parsepayload(body, &appinfo)
if parseerr != nil {
    return nil, parseerr
}
log.printf("parsed app %v", appinfo)
return &appinfo, nil

我真的不确定问题是什么。标准 encoding/json 不需要结构匹配 json 数据中的所有字段。使用一个简单的类型就可以很容易地处理这个问题：

type payload struct {
    id      int    `json:"id"`
    title   string `json:"title"`
    message string `json:"message"`
}

type response struct {
    status  string  `json:"status"`
    id      string  `json:"request_id"`
    traceid string  `json:"trace_id"`
    payload payload `json:"payload"`
}

然后只需解组 response 结构中的响应即可：

var resp response
if err := json.unmarshal(body, &resp); err != nil {
    return err
}

然后您可以简单地检查 status 字段，并确定下一步该做什么。例如：

if resp.status == "error" {
    return fmt.errorf("invalid response: %s - %s", resp.traceid, resp.payload.message)
}
// handle resp.payload.id and resp.payload.title fields
return nil

您可以将对状态字段的这些检查移至响应对象上的接收器函数，具体取决于复杂性和您的具体需求。

也许值得对正常响应中未设置的字段使用指针字段，并使用 omitempty 选项标记它们：

type payload struct {
    id      int     `json:"id"`
    title   string  `json:"title"`
    message *string `json:"message,omitempty"`
}
type response struct {
    status  string  `json:"status"`
    id      string  `json:"request_id"`
    traceid *string `json:"trace_id,omitempty"`
    payload payload `json:"payload"`
}

有了这样的类型，不再需要依赖硬编码的字符串常量来检查错误。相反，您可以轻松地实现更通用的检查，如下所示：

func (r response) iserror() bool {
    return (r.traceid == nil) // will be set in case of an error response
}

更新

正如您在评论中指出的，响应正文实际上比示例中的 2 个字段大得多。当然，复制粘贴结构体定义或编写映射函数将 payload 映射到您已有的类型有点毫无意义。

这里的答案是：组合。

type payload struct {
    appstruct // embedded the appstruct type
    message   *string `json:"message"`
}

response 类型保持原样。如果响应成功，您可以直接从响应中获取 appstruct，如下所示：

appStruct := resp.Payload.AppStruct

这是有效的，因为类型是嵌入的。请注意，那里没有任何 json 标签。嵌入式结构，至少就解组而言，是 payload 结构的一部分。因此，该类型的所有导出字段都将直接解组到结构中。

今天关于《如何解析包装的json对象》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！