如何解組不同的json格式

Question

我閱讀了很多類似的問題，但還沒有找到正確的解決方案。 希望有人能給我更好的主意。

我的錯誤響應可能是以下格式之一：

var errProxy = `{"errors":{"id": "1", "message": "failed to resolve the ip", "status": "failed"}}`
var errServer = `{"errors": "failed to ping the dns server."}`

我試圖通過使用兩個結構並嘗試一個接一個地解組，直到 err 為零並返回來解決這個問題：

// ErrorServer and ErrorProxy is my two struct to represent my above two error response.

type ErrorServer struct {
    Error string `json:"errors"`
}

type ErrorResponse struct {
    ID      string `json:"id"`
    Message string `json:"message"`
    Status  string `json:"status"`
}
type ErrorProxy struct {
    ErrorResponse
}

這是我用來解析它的函數：

func parseErrorResponse(body io.ReadCloser) (string, error) {
    var errServer ErrorServer
    var errProxy ErrorProxy
    err := json.NewDecoder(body).Decode(&errServer)
    if err != nil {
        err = json.NewDecoder(body).Decode(&errProxy)
        if err != nil {
            return "", err
        }
        return errProxy.Error, nil
    }
    return errServer.Errors, nil
}

Answer 1

我認為自定義解組函數適合這種情況

type ErrorServer struct {
    Error string
}

type ErrorResponse struct {
    ID      string
    Message string
    Status  string
}
type ErrorProxy struct {
    Err ErrorResponse
}

func parseErrorResponse(body io.Reader) (interface{}, error) {
    data := make(map[string]interface{})
    if err := json.NewDecoder(body).Decode(&data); err != nil {
        return nil, err
    }
    // Check type of errors field
    switch errors := data["errors"].(type) {
    case string:
        // Unmarshal for ErrorServer
        errServer := &ErrorServer{
            Error: errors,
        }
        return errServer, nil
    case map[string]interface{}:
        // Unmarshal for ErrorProxy
        errProxy := &ErrorProxy{
            Err: ErrorResponse{
                ID:      errors["id"].(string),
                Message: errors["message"].(string),
                Status:  errors["status"].(string),
            },
        }
        return errProxy, nil
    default:
        return nil, fmt.Errorf(`failed to parse "errors" field`)
    }
}

func main() {
    body := bytes.NewReader([]byte(`{"errors": "failed to ping the dns server."}`))
    //body := bytes.NewReader([]byte(`{"errors":{"id": "1", "message": "failed to resolve the ip", "status": "failed"}}`))
    
    parsedErr, _ := parseErrorResponse(body)

    switch err := parsedErr.(type) {
    case *ErrorServer:
        fmt.Printf("err server: %+v \n", err)
    case *ErrorProxy:
        fmt.Printf("err response: %+v \n", err)
    }
}

Answer 2

另一種方法是使用類型斷言。 您可以將該 json 字符串解組為map[string]interface{}並檢查該值interface{}是string還是map[string]interface{} 。 取決於它的類型，您知道它是哪種錯誤並從中構造一個結構。

Answer 3

有趣的是，我只是在這里給出了這個問題的答案：使用定制的UnmarshalJSON函數。 你如何在 Golang 中修改這個結構體來接受兩個不同的結果？

適用於您的情況：

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

type Answer struct {
    Errors Error `json:"errors"`
}

type ErrorResponse struct {
    ID      string `json:"id"`
    Message string `json:"message"`
    Status  string `json:"status"`
}

type Error struct {
    Error         string
    ErrorResponse ErrorResponse
}

func (s *Error) UnmarshalJSON(b []byte) error {
    if len(b) == 0 {
        // no data, nothing to do
        return nil
    }
    if b[0] == '{' {
        // is object
        return json.Unmarshal(b, &s.ErrorResponse)
    }
    return json.Unmarshal(b, &s.Error)
}

func main() {
    var errProxy = []byte(`{"errors":{"id": "1", "message": "failed to resolve the ip", "status": "failed"}}`)
    var errServer = []byte(`{"errors": "failed to ping the dns server."}`)

    var answ Answer
    if err := json.Unmarshal(errProxy, &answ); err != nil {
        log.Fatal(err)
    }
    fmt.Println(answ)

    answ = Answer{}
    if err := json.Unmarshal(errServer, &answ); err != nil {
        log.Fatal(err)
    }
    fmt.Println(answ)
}

去游樂場

上面例子中的關鍵是包含這兩種變體的類型。 我們還可以簡化它，因為這兩個錯誤都可以包含在ErrorResponse類型中：

type Answer struct {
    Errors ErrorResponse `json:"errors"`
}

type ErrorResponse struct {
    ID      string
    Message string
    Status  string
}

func (s *ErrorResponse) UnmarshalJSON(b []byte) error {
    if len(b) == 0 {
        // no data, nothing to do
        return nil
    }
    if b[0] == '{' {
        // is object
        var tmp struct {
            ID      string `json:"id"`
            Message string `json:"message"`
            Status  string `json:"status"`
        }
        if err := json.Unmarshal(b, &tmp); err != nil {
            return err
        }
        s.ID = tmp.ID
        s.Message = tmp.Message
        s.Status = tmp.Status
        return nil
    }
    return json.Unmarshal(b, &s.Message)
}

這里不需要Error結構。