如何在Go中处理Authorize.net API的未知响应结构体Unmarshal？

针对你遇到的问题，核心是利用响应中区分成功/失败的固定字段来判断要使用的反序列化结构体，以下是几种实用的实现方式（以Go语言为例，其他语言思路类似）：

方案1：先解析基础状态字段，再选择目标结构体 #

先定义一个只包含状态标识的轻量结构体，解析出关键的状态字段后，再用对应的完整结构体解析整个响应体：

// 基础结构体，仅包含区分成功/失败的核心字段（根据Authorize.net实际字段调整）
type BaseAuthResponse struct {
    ResponseCode string `json:"responseCode"` // 示例：成功为"1"，拒绝为"2"
}

func ProcessAuthResponse(respBody []byte) (interface{}, error) {
    // 第一步：解析基础状态
    var baseResp BaseAuthResponse
    if err := json.Unmarshal(respBody, &baseResp); err != nil {
        return nil, err
    }

    // 第二步：根据状态选择对应结构体解析
    switch baseResp.ResponseCode {
    case "1":
        var approvedResp AuthorizeApprovedResponse
        if err := json.Unmarshal(respBody, &approvedResp); err != nil {
            return nil, err
        }
        return approvedResp, nil
    case "2":
        var declinedResp AuthorizeDeclinedResponse
        if err := json.Unmarshal(respBody, &declinedResp); err != nil {
            return nil, err
        }
        return declinedResp, nil
    default:
        return nil, fmt.Errorf("未识别的响应码: %s", baseResp.ResponseCode)
    }
}

方案2：用RawMessage延迟解析可变部分 #

如果成功/失败的响应有共同的外层结构，可变内容嵌套在某个字段里，可以用json.RawMessage暂存可变部分，再按需解析：

import "encoding/json"

type AuthResponseWrapper struct {
    ResultCode string          `json:"messages.resultCode"` // 按API实际字段调整
    Details    json.RawMessage `json:"transactionResponse"` // 可变内容所在字段
}

func ProcessAuthResponse(respBody []byte) (interface{}, error) {
    var wrapper AuthResponseWrapper
    if err := json.Unmarshal(respBody, &wrapper); err != nil {
        return nil, err
    }

    switch wrapper.ResultCode {
    case "Ok":
        var approvedResp AuthorizeApprovedResponse
        if err := json.Unmarshal(wrapper.Details, &approvedResp); err != nil {
            return nil, err
        }
        return approvedResp, nil
    case "Error":
        var declinedResp AuthorizeDeclinedResponse
        if err := json.Unmarshal(wrapper.Details, &declinedResp); err != nil {
            return nil, err
        }
        return declinedResp, nil
    default:
        return nil, fmt.Errorf("未识别的结果状态: %s", wrapper.ResultCode)
    }
}

不推荐的方案：直接用interface{}类型断言 #

虽然你提到了用interface{}再转换，但这种方式类型不安全，容易出现断言失败的情况，仅作为备选：

func ProcessAuthResponse(respBody []byte) (interface{}, error) {
    var raw interface{}
    if err := json.Unmarshal(respBody, &raw); err != nil {
        return nil, err
    }

    respMap, ok := raw.(map[string]interface{})
    if !ok {
        return nil, fmt.Errorf("响应格式无效")
    }

    // 提取状态字段（需匹配API实际字段）
    resultCode, ok := respMap["messages.resultCode"].(string)
    if !ok {
        return nil, fmt.Errorf("无法获取结果状态")
    }

    // 重新序列化后解析到目标结构体
    respBytes, err := json.Marshal(respMap)
    if err != nil {
        return nil, err
    }

    switch resultCode {
    case "Ok":
        var approvedResp AuthorizeApprovedResponse
        json.Unmarshal(respBytes, &approvedResp)
        return approvedResp, nil
    case "Error":
        var declinedResp AuthorizeDeclinedResponse
        json.Unmarshal(respBytes, &declinedResp)
        return declinedResp, nil
    default:
        return nil, fmt.Errorf("未识别的结果状态: %s", resultCode)
    }
}

关键注意事项 #

1. 务必对照Authorize.net官方文档，确认用于区分交易状态的实际字段名（比如responseCode、messages.resultCode等），不要硬编码示例中的字段；
2. 优先选择方案1或方案2，它们类型更安全、可读性更强，避免使用interface{}的松散方式。

内容的提问来源于stack exchange，提问作者pigfox