Swift如何解决OfflineRequest因[String:Any]不兼容Codable的报错？

这个问题我之前也踩过坑——Codable和Any类型天生不对付，因为Any没有明确的类型信息，自动生成的Codable代码根本不知道该怎么编码解码它。咱们直接上可行的解决方案：

核心思路：用枚举封装所有可能的类型 #

既然Any太灵活，那我们就把params里可能出现的所有类型都用一个枚举明确下来（毕竟Core Data的属性类型无非就是字符串、数字、布尔值、嵌套字典/数组这些），让Codable能识别每一种类型。

1. 定义可编码的Value枚举 #

先写一个CodableValue枚举，覆盖所有你可能用到的类型，同时实现Codable协议和与Any的转换方法：

enum CodableValue: Codable {
    case string(String)
    case int(Int)
    case double(Double)
    case bool(Bool)
    case dictionary([String: CodableValue])
    case array([CodableValue])
    
    // 解码逻辑：尝试把数据转换成对应的类型
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        if let stringValue = try? container.decode(String.self) {
            self = .string(stringValue)
        } else if let intValue = try? container.decode(Int.self) {
            self = .int(intValue)
        } else if let doubleValue = try? container.decode(Double.self) {
            self = .double(doubleValue)
        } else if let boolValue = try? container.decode(Bool.self) {
            self = .bool(boolValue)
        } else if let dictionaryValue = try? container.decode([String: CodableValue].self) {
            self = .dictionary(dictionaryValue)
        } else if let arrayValue = try? container.decode([CodableValue].self) {
            self = .array(arrayValue)
        } else {
            throw DecodingError.dataCorruptedError(in: container, debugDescription: "Unsupported value type")
        }
    }
    
    // 编码逻辑：把枚举值转换成对应类型的数据
    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch self {
        case .string(let value): try container.encode(value)
        case .int(let value): try container.encode(value)
        case .double(let value): try container.encode(value)
        case .bool(let value): try container.encode(value)
        case .dictionary(let value): try container.encode(value)
        case .array(let value): try container.encode(value)
        }
    }
    
    // 方便把枚举转回Any类型
    var asAny: Any {
        switch self {
        case .string(let value): return value
        case .int(let value): return value
        case .double(let value): return value
        case .bool(let value): return value
        case .dictionary(let value): return value.mapValues { $0.asAny }
        case .array(let value): return value.map { $0.asAny }
        }
    }
}

// 扩展：从Any类型初始化CodableValue
extension CodableValue {
    static func fromAny(_ value: Any) throws -> CodableValue {
        switch value {
        case let str as String: return .string(str)
        case let num as Int: return .int(num)
        case let num as Double: return .double(num)
        case let flag as Bool: return .bool(flag)
        case let dict as [String: Any]:
            return .dictionary(try dict.mapValues { try fromAny($0) })
        case let array as [Any]:
            return .array(try array.map { try fromAny($0) })
        default:
            throw NSError(domain: "CodableValueError", code: 0, userInfo: [NSLocalizedDescriptionKey: "Unsupported type: \(type(of: value))"])
        }
    }
}

2. 修改你的OfflineRequest结构体 #

把原来的[String: Any]改成[String: CodableValue]，同时提供从[String: Any]初始化的方法，以及转回Any字典的属性：

struct OfflineRequest: Codable {
    let url: String
    let params: [String: CodableValue]
    
    // 从[String: Any]初始化，自动转换为CodableValue字典
    init(url: String, params: [String: Any]) throws {
        self.url = url
        self.params = try params.mapValues { try CodableValue.fromAny($0) }
    }
    
    // 获取转回的[String: Any]字典，方便你后续发送请求
    var paramsAsAny: [String: Any] {
        params.mapValues { $0.asAny }
    }
}

3. 调整UserDefaults扩展（可选优化） #

你的原扩展里的defaults.synchronize()在iOS 10+已经不需要了，系统会自动处理同步，所以可以删掉这一行：

extension UserDefaults {
    func decode<T : Codable>(for type : T.Type, using key : String) -> T? {
        guard let data = object(forKey: key) as? Data else {return nil}
        return try? PropertyListDecoder().decode(type, from: data)
    }
    
    func encode<T : Codable>(for type : T, using key : String) {
        let encodedData = try? PropertyListEncoder().encode(type)
        set(encodedData, forKey: key)
        // 去掉defaults.synchronize()
    }
}

4. 使用示例 #

保存离线请求：

// 假设你从Core Data拿到的params是[String: Any]类型
let coreDataParams: [String: Any] = [
    "userId": 456,
    "username": "alex",
    "isVerified": true,
    "metadata": ["signupDate": "2024-01-01", "tags": ["new", "user"]]
]

do {
    let offlineRequest = try OfflineRequest(url: "/api/user/save", params: coreDataParams)
    UserDefaults.standard.encode(for: offlineRequest, using: "OfflineRequestQueue")
} catch {
    print("编码失败：\(error)")
}

读取并恢复请求：

if let savedRequest = UserDefaults.standard.decode(for: OfflineRequest.self, using: "OfflineRequestQueue") {
    let restoredParams = savedRequest.paramsAsAny
    // 这里restoredParams就是你原来的[String: Any]，可以直接用来发送请求
    print("恢复的参数：\(restoredParams)")
}

为什么这个方案可行？ #

我们通过枚举把动态的Any转换成了Codable能识别的明确类型，既满足了持久化的需求，又保留了原来使用[String: Any]的业务逻辑，不需要大规模修改现有代码。如果后续有新的类型需要支持，只要在枚举里加对应的case和转换逻辑就行。

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