Go应用中JSON解码类型不匹配错误的排查与弹性处理策略

package main

import (
    "encoding/json"
    "fmt"
)

// OriginalClaim 结构体，期望 tokenClaim 为字符串
type OriginalClaim struct {
    TokenClaim string `json:"tokenClaim"`
}

func main() {
    // 模拟旧的API响应
    oldResponse := `{"tokenClaim": "some_string_value"}`
    var original OriginalClaim
    err := json.Unmarshal([]byte(oldResponse), &original)
    if err != nil {
        fmt.Println("解析旧响应错误:", err)
    } else {
        fmt.Println("解析旧响应成功:", original.TokenClaim) // 输出: some_string_value
    }

    // 模拟新的API响应，tokenClaim 变为布尔值
    newResponse := `{"tokenClaim": true}`
    err = json.Unmarshal([]byte(newResponse), &original) // 这里会报错
    if err != nil {
        fmt.Println("解析新响应错误:", err) // 预期输出: json: cannot unmarshal bool into Go value of type string
    } else {
        fmt.Println("解析新响应成功:", original.TokenClaim)
    }
}

package main

import (
    "encoding/json"
    "fmt"
)

// FlexibleClaim 结构体，使用 interface{} 接受不确定类型的字段
type FlexibleClaim struct {
    TokenClaim interface{} `json:"tokenClaim"`
}

func main() {
    oldResponse := `{"tokenClaim": "some_string_value"}`
    newResponse := `{"tokenClaim": true}`

    var flexible FlexibleClaim
    json.Unmarshal([]byte(oldResponse), &flexible)
    fmt.Printf("灵活解析旧响应: %v (类型: %T)\n", flexible.TokenClaim, flexible.TokenClaim)
    // 输出: 灵活解析旧响应: some_string_value (类型: string)

    json.Unmarshal([]byte(newResponse), &flexible)
    fmt.Printf("灵活解析新响应: %v (类型: %T)\n", flexible.TokenClaim, flexible.TokenClaim)
    // 输出: 灵活解析新响应: true (类型: bool)

    // 后续处理：类型断言
    if val, ok := flexible.TokenClaim.(bool); ok {
        fmt.Println("TokenClaim 是布尔值:", val)
    } else if val, ok := flexible.TokenClaim.(string); ok {
        fmt.Println("TokenClaim 是字符串:", val)
    }
}

package main

import (
    "encoding/json"
    "fmt"
)

// CustomClaim 结构体，目标是将 tokenClaim 统一转换为 string
type CustomClaim struct {
    TokenClaim string `json:"tokenClaim"`
}

// UnmarshalJSON 为 CustomClaim 类型实现自定义的 JSON 解组逻辑
func (c *CustomClaim) UnmarshalJSON(data []byte) error {
    // 首先尝试将整个 JSON 对象解组到一个 map[string]json.RawMessage 中
    // 这样可以获取到原始的 JSON 字段值，而不触发默认的类型检查
    var raw map[string]json.RawMessage
    if err := json.Unmarshal(data, &raw); err != nil {
        return err
    }

    // 检查 "tokenClaim" 字段是否存在
    if tokenClaimBytes, ok := raw["tokenClaim"]; ok {
        // 尝试将 tokenClaimBytes 解组为字符串
        var s string
        if err := json.Unmarshal(tokenClaimBytes, &s); err == nil {
            c.TokenClaim = s
            return nil // 成功解组为字符串
        }

        // 如果解组为字符串失败，尝试解组为布尔值
        var b bool
        if err := json.Unmarshal(tokenClaimBytes, &b); err == nil {
            c.TokenClaim = fmt.Sprintf("%t", b) // 将布尔值转换为字符串
            return nil                          // 成功解组为布尔值并转换
        }

        // 如果以上两种尝试都失败，则返回错误
        return fmt.Errorf("failed to unmarshal tokenClaim as string or bool: %s", string(tokenClaimBytes))
    }
    // 如果字段不存在，可以根据业务逻辑选择返回错误或保持默认值
    return nil
}

func main() {
    oldResponse := `{"tokenClaim": "some_string_value"}`
    newResponse := `{"tokenClaim": true}`
    missingFieldResponse := `{}`

    var custom CustomClaim
    err := json.Unmarshal([]byte(oldResponse), &custom)
    if err != nil {
        fmt.Println("自定义解析旧响应错误:", err)
    } else {
        fmt.Println("自定义解析旧响应成功:", custom.TokenClaim) // 输出: some_string_value
    }

    err = json.Unmarshal([]byte(newResponse), &custom)
    if err != nil {
        fmt.Println("自定义解析新响应错误:", err)
    } else {
        fmt.Println("自定义解析新响应成功:", custom.TokenClaim) // 输出: true
    }

    err = json.Unmarshal([]byte(missingFieldResponse), &custom)
    if err != nil {
        fmt.Println("自定义解析缺失字段响应错误:", err)
    } else {
        fmt.Println("自定义解析缺失字段响应成功:", custom.TokenClaim) // 输出: (空字符串，因为字段缺失)
    }
}

package main

import (
    "encoding/json"
    "fmt"
)

// DelayedClaim 结构体，使用 json.RawMessage 延迟解析复杂字段
type DelayedClaim struct {
    OtherField string          `json:"otherField"`
    ComplexData json.RawMessage `json:"complexData"` // 原始JSON字节
}

// ComplexDataType 复杂数据的实际结构
type ComplexDataType struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func main() {
    responseWithComplexData := `{"otherField": "value", "complexData": {"id": 123, "name": "Test"}}`

    var delayed DelayedClaim
    err := json.Unmarshal([]byte(responseWithComplexData), &delayed)
    if err != nil {
        fmt.Println("延迟解析错误:", err)
        return
    }

    fmt.Println("其他字段:", delayed.OtherField)

    // 延迟解析 complexData
    var complexData ComplexDataType
    err = json.Unmarshal(delayed.ComplexData, &complexData)
    if err != nil {
        fmt.Println("二次解析 complexData 错误:", err)
        return
    }
    fmt.Printf("二次解析 complexData 成功: ID=%d, Name=%s\n", complexData.ID, complexData.Name)
}