Swift下Firebase多路径多值原子写入事务实现与代码优化咨询

好问题！在Firebase里实现多路径的原子写入（也就是你说的事务执行）是个很常见的需求，毕竟没人希望出现部分数据写入成功、部分失败的情况。下面我来一步步帮你解决这两个问题：

1. 在Swift中实现多路径的原子写入（事务式执行） #

首先得澄清一个小概念：Firebase的Transaction API本身是针对单个数据节点的并发安全修改，但如果要一次性写入多个不同路径且保证原子性，其实更适合用WriteBatch（批量写入）——它能把多个写操作打包成一个原子事务，所有操作要么全部成功提交，要么全部失败回滚，完全符合你要的“事务”效果。

场景一：单纯写入新数据（无需读取现有数据） #

如果你的需求只是把产品数据写入多个路径，不需要依赖现有数据做判断，用WriteBatch是最直接高效的方式，代码示例如下：

import FirebaseFirestore

// 假设你的产品模型
struct Product {
    let id: String
    let name: String
    let price: Double
    let category: String
    let stockQuantity: Int
}

func registerProductOnDatabase(product: Product) {
    let db = Firestore.firestore()
    let batch = db.batch()
    
    // 1. 写入产品主数据到products集合
    let productRef = db.collection("products").document(product.id)
    batch.setData([
        "name": product.name,
        "price": product.price,
        "category": product.category
    ], forDocument: productRef)
    
    // 2. 写入分类关联数据到categories/{category}/products子集合
    let categoryProductRef = db.collection("categories").document(product.category).collection("products").document(product.id)
    batch.setData([
        "productId": product.id,
        "name": product.name,
        "price": product.price
    ], forDocument: categoryProductRef)
    
    // 3. 写入库存数据到inventory集合
    let inventoryRef = db.collection("inventory").document(product.id)
    batch.setData([
        "productId": product.id,
        "stockQuantity": product.stockQuantity
    ], forDocument: inventoryRef)
    
    // 提交批量操作，原子执行
    batch.commit { error in
        if let error = error {
            print("产品注册失败: \(error.localizedDescription)")
            // 这里处理失败逻辑，比如提示用户
        } else {
            print("产品注册成功，所有数据已原子写入")
            // 处理成功逻辑，比如跳转页面
        }
    }
}

场景二：需要读写结合的并发安全操作 #

如果你的场景需要先读取现有数据，再基于读取结果做写入（比如要检查某个分类下的产品数量是否超限），那就要用Transaction API，它能确保整个读写过程的并发安全，示例如下：

func registerProductWithTransaction(product: Product) {
    let db = Firestore.firestore()
    let productRef = db.collection("products").document(product.id)
    let categoryProductRef = db.collection("categories").document(product.category).collection("products").document(product.id)
    let inventoryRef = db.collection("inventory").document(product.id)
    let categoryRef = db.collection("categories").document(product.category)
    
    db.runTransaction { transaction, errorPointer in
        // 先读取分类文档，获取当前产品数量
        guard let categoryDoc = try? transaction.getDocument(categoryRef),
              let currentProductCount = categoryDoc.data()?["productCount"] as? Int else {
            errorPointer?.pointee = NSError(domain: "AppError", code: -1, userInfo: [NSLocalizedDescriptionKey: "无法读取分类数据"])
            return nil
        }
        
        // 检查产品数量是否超过限制（比如最多100个）
        guard currentProductCount < 100 else {
            errorPointer?.pointee = NSError(domain: "AppError", code: -2, userInfo: [NSLocalizedDescriptionKey: "该分类产品数量已达上限"])
            return nil
        }
        
        // 在事务中执行多个写操作
        transaction.setData([
            "name": product.name,
            "price": product.price,
            "category": product.category
        ], forDocument: productRef)
        
        transaction.setData([
            "productId": product.id,
            "name": product.name,
            "price": product.price
        ], forDocument: categoryProductRef)
        
        transaction.setData([
            "productId": product.id,
            "stockQuantity": product.stockQuantity
        ], forDocument: inventoryRef)
        
        // 更新分类的产品数量
        transaction.updateData(["productCount": currentProductCount + 1], forDocument: categoryRef)
        
        return nil
    } completion: { _, error in
        if let error = error {
            print("事务执行失败: \(error.localizedDescription)")
        } else {
            print("事务执行成功，所有操作原子完成")
        }
    }
}

2. 优化代码，避免重复 #

重复的字段映射和路径定义确实会让代码变臃肿，这里有几个实用的优化方式：

方式一：给Product模型扩展数据转换方法 #

把不同路径需要的字典提取到模型的扩展里，这样每次写入直接调用方法即可，还能复用公共字段：

extension Product {
    // 主产品数据字典
    func toProductData() -> [String: Any] {
        var data = baseProductData()
        data["category"] = category
        return data
    }
    
    // 分类关联数据字典
    func toCategoryProductData() -> [String: Any] {
        return baseProductData()
    }
    
    // 库存数据字典
    func toInventoryData() -> [String: Any] {
        var data = baseProductData()
        data["stockQuantity"] = stockQuantity
        return data
    }
    
    // 提取公共字段，进一步减少重复
    private func baseProductData() -> [String: Any] {
        return [
            "productId": id,
            "name": name,
            "price": price
        ]
    }
}

修改后，批量写入的代码就简化成：

batch.setData(product.toProductData(), forDocument: productRef)
batch.setData(product.toCategoryProductData(), forDocument: categoryProductRef)
batch.setData(product.toInventoryData(), forDocument: inventoryRef)

方式二：封装数据库操作到单独的服务类 #

把所有和产品数据库相关的逻辑放到一个服务类里，既分离了业务逻辑和数据层，也方便后续维护和修改：

class ProductDatabaseService {
    private let db = Firestore.firestore()
    
    /// 原子注册产品到多个路径
    func registerProduct(_ product: Product, completion: @escaping (Error?) -> Void) {
        let batch = db.batch()
        
        // 统一管理所有路径引用
        let productRef = db.collection("products").document(product.id)
        let categoryProductRef = db.collection("categories").document(product.category).collection("products").document(product.id)
        let inventoryRef = db.collection("inventory").document(product.id)
        
        // 添加批量操作
        batch.setData(product.toProductData(), forDocument: productRef)
        batch.setData(product.toCategoryProductData(), forDocument: categoryProductRef)
        batch.setData(product.toInventoryData(), forDocument: inventoryRef)
        
        // 提交
        batch.commit(completion)
    }
    
    /// 带并发检查的事务式注册
    func registerProductWithTransaction(_ product: Product, completion: @escaping (Error?) -> Void) {
        // 这里可以把之前的transaction逻辑移过来，代码结构更清晰
    }
}

使用的时候就非常简洁：

let productService = ProductDatabaseService()
productService.registerProduct(myProduct) { error in
    if let error = error {
        // 处理失败
    } else {
        // 处理成功
    }
}

方式三：用枚举管理数据库路径 #

如果你的数据库路径很多，还可以用枚举来统一管理，避免硬编码字符串，减少拼写错误：

enum FirestorePath {
    case product(String)
    case categoryProduct(categoryId: String, productId: String)
    case inventory(String)
    
    var reference: DocumentReference {
        let db = Firestore.firestore()
        switch self {
        case .product(let productId):
            return db.collection("products").document(productId)
        case .categoryProduct(let categoryId, let productId):
            return db.collection("categories").document(categoryId).collection("products").document(productId)
        case .inventory(let productId):
            return db.collection("inventory").document(productId)
        }
    }
}

然后获取引用的时候就变成：

let productRef = FirestorePath.product(product.id).reference
let categoryProductRef = FirestorePath.categoryProduct(categoryId: product.category, productId: product.id).reference
let inventoryRef = FirestorePath.inventory(product.id).reference

这样后续修改路径的时候，只需要修改枚举的实现，不用到处找硬编码的字符串。

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