能否使用async init(from: Decoder)让类遵循Decodable协议？

你的实现方式不可行，因为Decodable协议规定的init(from: Decoder)必须是同步方法，不能添加async修饰符——这就是编译器报错的核心原因。协议的契约不允许在解码初始化过程中执行异步操作，所以不能直接把数据库查询逻辑塞进这个初始化器里。

下面是几种可行的替代方案：

方案1：拆分初始化与异步加载 #

先完成同步解码（只解析ID等基础属性），再通过单独的异步方法加载关联对象：

class MyClass: Codable {
    let decodedID: myIDType
    var referencedObject: ResultsType? // 用可选类型标记初始未加载

    enum CodingKeys: String, CodingKey {
        case decodedID
        // 其他需要解码的属性键
    }

    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        decodedID = try container.decode(myIDType.self, forKey: .decodedID)
        // 同步解码其他所有属性
    }

    // 单独的异步方法加载关联对象
    func fetchReferencedObject() async throws {
        referencedObject = try await getFromDB(id: decodedID)
    }
}

使用方式：

let decoder = JSONDecoder()
let myObject = try decoder.decode(MyClass.self, from: dbData)
// 之后在合适的异步上下文加载关联对象
try await myObject.fetchReferencedObject()

方案2：自定义异步解码方法 #

绕开标准Decodable的同步初始化，写一个静态异步方法完成完整的解码+关联对象加载：

class MyClass: Codable {
    let decodedID: myIDType
    let referencedObject: ResultsType // 这里可以用非可选类型，因为加载完成后才创建实例

    enum CodingKeys: String, CodingKey {
        case decodedID
        // 其他属性键
    }

    // 私有初始化器，仅内部使用
    private init(decodedID: myIDType, referencedObject: ResultsType) {
        self.decodedID = decodedID
        self.referencedObject = referencedObject
    }

    // 自定义异步解码入口
    static func asyncDecode(from data: Data) async throws -> MyClass {
        let decoder = JSONDecoder()
        // 先解码出包含基础数据的临时结构
        struct TempDecoded: Codable {
            let decodedID: myIDType
            // 其他需要同步解码的属性
        }
        let temp = try decoder.decode(TempDecoded.self, from: data)
        // 异步加载关联对象
        let refObject = try await getFromDB(id: temp.decodedID)
        // 初始化完整实例
        return MyClass(decodedID: temp.decodedID, referencedObject: refObject)
    }
}

使用方式：

let myObject = try await MyClass.asyncDecode(from: dbData)
// 此时referencedObject已经加载完成

方案3：延迟加载（可选，适合特定场景） #

如果关联对象的使用频率不高，可以用lazy结合异步闭包，但要注意线程安全：

class MyClass: Codable {
    let decodedID: myIDType
    private(set) lazy var referencedObject: ResultsType? = nil

    enum CodingKeys: String, CodingKey {
        case decodedID
    }

    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        decodedID = try container.decode(myIDType.self, forKey: .decodedID)
    }

    func loadReferencedIfNeeded() async throws {
        guard referencedObject == nil else { return }
        referencedObject = try await getFromDB(id: decodedID)
    }
}

这种方式适合需要按需加载关联对象的场景，但要确保在访问referencedObject前已经调用过加载方法，或者处理可选值的情况。

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