Golang中处理嵌套JSON响应数组值的技巧

处理嵌套JSON响应数组值时，可以通过定义结构体并使用json.Marshal和json.Unmarshal来移除特定键值对。以下是示例代码：

package main

import (
    "encoding/json"
    "fmt"
)

type ThirdPartyResponse struct {
    Caller         interface{} `json:"Caller,omitempty"`
    Environment    string      `json:"Environment,omitempty"`
    WorkflowName   string      `json:"WorkflowName,omitempty"`
    WorkflowMethod string      `json:"WorkflowMethod,omitempty"`
    Result         string      `json:"Result,omitempty"`
    Output         struct {
        Body struct {
            QueryResponse map[string]interface{} `json:"queryResponse"`
        } `json:"Body"`
    } `json:"Output"`
    TimeStamp interface{} `json:"TimeStamp,omitempty"`
    Location  interface{} `json:"Location,omitempty"`
}

type CleanResponse struct {
    Output struct {
        Body struct {
            QueryResponse map[string]interface{} `json:"queryResponse"`
        } `json:"Body"`
    } `json:"Output"`
}

func main() {
    jsonData := `{
        "Caller": {
            "CallerID": "ABC",
            "CallerIP": "XXX"
        },
        "Environment": "DEV",
        "WorkflowName": "Something",
        "WorkflowMethod": "GET",
        "Result": "Success",
        "Output": {
            "Body": {
                "queryResponse": {
                    "response_code": "SUCCESS",
                    "response_message": {},
                    "change_number": "abcdef",
                    "templateId": "",
                    "title": "random",
                    "primary_application_instance": "random",
                    "primary_application": "random",
                    "external_csi_id": [{
                        "#text": "000000000"
                    }],
                    "primary_ci": {},
                    "start_date": "0000-00-00 00:00:00",
                    "end_date": "0000-00-00 00:00:00",
                    "model": "notsure",
                    "category": "something",
                    "requestor": "random",
                    "requestorsoeid": "random",
                    "outage_start_date": {},
                    "outage_end_date": {},
                    "expiry_time": "0000-00-00 00:00:00",
                    "justification": "random",
                    "risk": "Low",
                    "expedited": false,
                    "expedited_reason": {},
                    "backout_plan_exemption": {},
                    "backout_plan": "none",
                    "cob_category": {},
                    "pre_test_exempt": true,
                    "test_exempt_category": "dummy",
                    "test_plan": "NO NEED",
                    "approvals": [{
                        "assignment_group": "null",
                        "comments": {},
                        "status": "notsure",
                        "approver": "abc",
                        "updated": "0000-00-00 00:00:00"
                    }]
                }
            }
        },
        "TimeStamp": "0000-00-00 00:00:00",
        "Location": null
    }`

    var resp ThirdPartyResponse
    err := json.Unmarshal([]byte(jsonData), &resp)
    if err != nil {
        panic(err)
    }

    cleanResp := CleanResponse{
        Output: resp.Output,
    }

    cleanJSON, err := json.Marshal(cleanResp)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(cleanJSON))
}

如果只需要保留Output部分，可以使用更简洁的方法：

func extractOutput(jsonData string) ([]byte, error) {
    var data map[string]interface{}
    err := json.Unmarshal([]byte(jsonData), &data)
    if err != nil {
        return nil, err
    }

    output, exists := data["Output"]
    if !exists {
        return json.Marshal(map[string]interface{}{})
    }

    return json.Marshal(map[string]interface{}{
        "Output": output,
    })
}

对于需要移除多个特定字段的情况，可以使用json.RawMessage：

type PartialResponse struct {
    Output json.RawMessage `json:"Output"`
}

func removeFields(jsonData []byte) ([]byte, error) {
    var partial PartialResponse
    err := json.Unmarshal(jsonData, &partial)
    if err != nil {
        return nil, err
    }

    result := map[string]interface{}{
        "Output": partial.Output,
    }

    return json.Marshal(result)
}

这些方法可以处理嵌套JSON响应，移除指定键值对，并保留需要的嵌套结构。