Go语言应用中处理外部API字段类型变更引起的JSON解码失败

type GooglePlayClaims struct {
    TokenClaim string `json:"googlePlayTokenClaim"`
    // ... 其他字段
}

type GooglePlayClaimsRobust struct {
    TokenClaim interface{} `json:"googlePlayTokenClaim"` // 允许接收字符串、布尔值或其他类型
    UserID     string      `json:"userId"`
}

func processClaims(data []byte) {
    var claims GooglePlayClaimsRobust
    if err := json.Unmarshal(data, &claims); err != nil {
        fmt.Printf("解码失败: %v\n", err)
        return
    }

    // 处理 TokenClaim 字段
    if val, ok := claims.TokenClaim.(string); ok {
        fmt.Printf("TokenClaim 是字符串: %s\n", val)
        // 执行字符串相关的业务逻辑
    } else if val, ok := claims.TokenClaim.(bool); ok {
        fmt.Printf("TokenClaim 是布尔值: %t\n", val)
        // 执行布尔值相关的业务逻辑，例如转换为字符串或根据布尔值判断
        if val {
            // ...
        }
    } else if claims.TokenClaim != nil {
        fmt.Printf("TokenClaim 是未知类型: %T, 值: %v\n", claims.TokenClaim, claims.TokenClaim)
    } else {
        fmt.Println("TokenClaim 为空")
    }
}

package main

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

// FlexibleTokenClaim 定义一个自定义类型，用于处理可能变化的TokenClaim字段
type FlexibleTokenClaim string

// UnmarshalJSON 为FlexibleTokenClaim实现自定义的JSON解码逻辑
// 它可以尝试将输入解析为字符串或布尔值，并最终统一存储为字符串
func (ftc *FlexibleTokenClaim) UnmarshalJSON(b []byte) error {
    // 尝试作为字符串解析
    var s string
    if err := json.Unmarshal(b, &s); err == nil {
        *ftc = FlexibleTokenClaim(s)
        return nil
    }

    // 尝试作为布尔值解析
    var bVal bool
    if err := json.Unmarshal(b, &bVal); err == nil {
        *ftc = FlexibleTokenClaim(strconv.FormatBool(bVal)) // 将布尔值转换为字符串
        return nil
    }

    // 如果既不是字符串也不是布尔值，则返回错误
    return fmt.Errorf("cannot unmarshal %s into FlexibleTokenClaim (expected string or bool)", string(b))
}

// AuthResponse 示例结构体，使用自定义类型处理TokenClaim
type AuthResponse struct {
    GooglePlayTokenClaim FlexibleTokenClaim `json:"googlePlayTokenClaim"`
    UserID               string             `json:"userId"`
}

func main() {
    // 模拟API响应数据：TokenClaim 为字符串
    dataString := `{"googlePlayTokenClaim": "some_string_token_value", "userId": "user123"}`
    // 模拟API响应数据：TokenClaim 变为布尔值
    dataBool := `{"googlePlayTokenClaim": true, "userId": "user456"}`
    // 模拟API响应数据：TokenClaim 为其他意外类型
    dataInvalid := `{"googlePlayTokenClaim": 123, "userId": "user789"}`
    // 模拟API响应数据：TokenClaim 为另一个布尔值
    dataBoolFalse := `{"googlePlayTokenClaim": false, "userId": "user000"}`


    var res1 AuthResponse
    if err := json.Unmarshal([]byte(dataString), &res1); err != nil {
        fmt.Println("解码字符串类型失败:", err)
    } else {
        fmt.Printf("成功解析字符串类型TokenClaim: %+v\n", res1)
    }

    var res2 AuthResponse
    if err := json.Unmarshal([]byte(dataBool), &res2); err != nil {
        fmt.Println("解码布尔类型失败:", err)
    } else {
        fmt.Printf("成功解析布尔类型TokenClaim: %+v\n", res2)
    }

    var res3 AuthResponse
    if err := json.Unmarshal([]byte(dataInvalid), &res3); err != nil {
        fmt.Println("解码无效类型失败:", err)
    } else {
        fmt.Printf("成功解析无效类型TokenClaim: %+v\n", res3) // 理论上这里会失败
    }

    var res4 AuthResponse
    if err := json.Unmarshal([]byte(dataBoolFalse), &res4); err != nil {
        fmt.Println("解码布尔类型(false)失败:", err)
    } else {
        fmt.Printf("成功解析布尔类型(false)TokenClaim: %+v\n", res4)
    }
}