优化Realm Swift SDK中MongoDB聚合结果转Swift对象性能

核心问题分析 #

当前手动逐个解析AnyBSON属性的方式，在处理两次lookup带来的多层嵌套文档时，会产生大量可选链判断和重复类型转换开销，这是导致转换耗时过高的主要原因。

优化方案 #

1. 利用Codable协议自动解码 #

借助Swift原生Codable特性，结合Realm BSON与Codable的适配，直接将聚合结果批量解码为自定义对象，替代手动解析的冗余操作。

实现步骤：

• 让自定义对象及嵌套关联对象遵循Codable协议，并映射BSON字段：

class ExampleObject: Identifiable, Codable {
    var id: String
    var example: String?
    var nestedObject: NestedObject? // 对应第一次lookup的关联文档
    
    enum CodingKeys: String, CodingKey {
        case id = "_id"
        case example
        case nestedObject = "your_nested_field_key"
    }
    
    init(id: String, example: String? = nil, nestedObject: NestedObject? = nil) {
        self.id = id
        self.example = example
        self.nestedObject = nestedObject
    }
}

class NestedObject: Codable {
    var nestedId: String
    var anotherNested: AnotherNestedObject? // 对应第二次lookup的关联文档
    
    enum CodingKeys: String, CodingKey {
        case nestedId = "_id"
        case anotherNested = "your_second_nested_key"
    }
    
    init(nestedId: String, anotherNested: AnotherNestedObject? = nil) {
        self.nestedId = nestedId
        self.anotherNested = anotherNested
    }
}

class AnotherNestedObject: Codable {
    var id: String
    var detail: String?
    
    enum CodingKeys: String, CodingKey {
        case id = "_id"
        case detail
    }
    
    init(id: String, detail: String? = nil) {
        self.id = id
        self.detail = detail
    }
}

• 扩展AnyBSON实现直接解码能力：

extension AnyBSON {
    func decode<T: Codable>(to type: T.Type) throws -> T {
        guard let doc = self.documentValue else {
            throw NSError(domain: "BSONDecodeError", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid BSON document"])
        }
        let data = try JSONSerialization.data(withJSONObject: doc)
        return try JSONDecoder().decode(T.self, from: data)
    }
}

• 批量转换聚合结果：

do {
    let resultObjectsRaw = try await collection.aggregate(pipeline: aggregatePipeline)
    let exampleObjects = try resultObjectsRaw.compactMap { bson in
        guard let validBSON = bson else { return nil }
        return try validBSON.decode(to: ExampleObject.self)
    }
} catch {
    print("转换失败：\(error)")
}

2. 优化手动解析的可选链开销 #

若坚持手动解析，可通过提前提取文档内容、减少可选链层级来降低运行时开销：

guard let doc = document.documentValue else { return nil }

// 提前提取字段，避免多层??判断
let documentId = doc["_id"]?.stringValue ?? ""
guard !documentId.isEmpty else { return nil }
let example = doc["example"]?.stringValue

// 嵌套文档解析同理，提前提取层级
let nestedDoc = doc["your_nested_field_key"]?.documentValue
let nestedObject = nestedDoc.flatMap { nested in
    let nestedId = nested["_id"]?.stringValue ?? ""
    guard !nestedId.isEmpty else { return nil }
    
    let anotherNestedDoc = nested["your_second_nested_key"]?.documentValue
    let anotherNested = anotherNestedDoc.flatMap { another in
        let anotherId = another["_id"]?.stringValue ?? ""
        guard !anotherId.isEmpty else { return nil }
        return AnotherNestedObject(id: anotherId, detail: another["detail"]?.stringValue)
    }
    
    return NestedObject(nestedId: nestedId, anotherNested: anotherNested)
}

let object = ExampleObject(id: documentId, example: example, nestedObject: nestedObject)

3. 后台线程批量处理 #

将转换操作放在后台并发队列执行，避免阻塞主线程，同时利用Swift并发特性提升处理效率：

do {
    let resultObjectsRaw = try await collection.aggregate(pipeline: aggregatePipeline)
    // 在后台优先级队列处理转换
    let exampleObjects = try await Task.detached(priority: .userInitiated) {
        return try resultObjectsRaw.compactMap { bson in
            guard let validBSON = bson else { return nil }
            return try validBSON.decode(to: ExampleObject.self)
        }
    }.value
    // 回到主线程更新UI或后续操作
    DispatchQueue.main.async {
        // 使用转换后的对象
    }
} catch {
    print("错误：\(error)")
}

关键优化说明 #

• Codable解码利用Swift原生高效序列化逻辑，大幅减少手动解析的重复判断和类型转换开销，尤其适配多层嵌套结构。
• 减少可选链层级能降低运行时的可选绑定开销，提升单文档解析速度。
• 后台线程处理可避免主线程阻塞，同时借助系统并发调度提升整体转换效率。

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