Swift Combine单次保存操作的最佳实践与退订方法问询

我现在遇到一个典型场景：需要执行仅一次的操作，比如用Swift Combine更新数据库中的实体。我困惑的点在于，这类单次操作的最佳实现方式是什么？更新完成后该如何正确退订？

以下是我当前各层级的代码片段：

ViewModel #

let settingsModel: LocalSettingsModel
func saveLocalSettings(){
    let cancelable = settingsUseCase
        .saveLocalSettings(localSettingsModel: settingsModel)
        .sink(receiveCompletion: {_ in
            print("Completed!!!")
        }) { _ in
            print("Result of Save operation!!!")
        }
}

UseCase #

func saveLocalSettings(settings: LocalSettingsModel) -> AnyPublisher<LocalSettingsModel, Error> {
    return repository.saveLocalSettings(settings: settings)
}

Repository #

guard let realmSettings = LocalSettingsRealmModel(fromModel: settings) else {
    return Fail<LocalSettingsModel, Error>(error: .postconditionError(errorMessage: ""))
        .eraseToAnyPublisher()
}
return self.localDataSource
    .saveLocalSettings(localSettings: realmSettings)
    .receive(on: DispatchQueue.main)
    .subscribe(on: DispatchQueue.global())
    .mapError { (error) -> Error in
        // 错误映射逻辑
    }
    .compactMap { settings in
        return (LocalSettingsModel(fromModel: settings))
    }
    .eraseToAnyPublisher()

Data Source #

func saveLocalSettings(localSettings: LocalSettingsRealmModel) -> AnyPublisher<LocalSettingsRealmModel, LocalDataSourceError> {
    do {
        return Just(try saveSettings(localSettings: localSettings))
            .mapError({ (Never) -> LocalDataSourceError in})
            .eraseToAnyPublisher()
    } catch let error as NSError {
        // 返回对应错误
    }
}
func saveSettings(localSettings: LocalSettingsRealmModel) throws -> LocalSettingsRealmModel {
    let realm = try Realm()
    try realm.write {
        realm.add(localSettings, update: .modified)
    }
    return localSettings
}

我想了解在响应式编程中，针对这类无需持续数据流的单次操作场景的最佳实践——是否必须像示例中这样使用Just，或是可以从订阅端进行处理？

嘿，针对你这个Combine单次操作的问题，我来分享下实际项目里的最佳实践，刚好我也经常处理这类数据库更新的场景 #

先给你吃个定心丸：你的现有实现方向是对的，但还有几个细节可以优化，尤其是退订逻辑和Just的使用细节。

1. Just完全适合同步单次操作

你在DataSource里用Just包裹同步的Realm写入操作非常合理——Just就是专门为发出单个值后立即完成的场景设计的，完美匹配你这种“只执行一次、不需要持续数据流”的需求。不过你的mapError处理可以更简洁，用setFailureType(to:)替代空的映射闭包，代码更清晰：

// 优化后的DataSource实现
func saveLocalSettings(localSettings: LocalSettingsRealmModel) -> AnyPublisher<LocalSettingsRealmModel, LocalDataSourceError> {
    do {
        let savedModel = try saveSettings(localSettings: localSettings)
        return Just(savedModel)
            .setFailureType(to: LocalDataSourceError.self) // 直接指定错误类型
            .eraseToAnyPublisher()
    } catch let error as LocalDataSourceError {
        return Fail(error: error).eraseToAnyPublisher()
    } catch {
        return Fail(error: .unknown(error)).eraseToAnyPublisher()
    }
}

这样既保留了Just的简洁性，又正确完成了错误类型的转换，比原来的空闭包更易读。

2. 退订的核心：别让订阅提前被销毁

你当前ViewModel里的cancelable是局部变量，这其实有隐患——函数执行完后，这个变量会被销毁，订阅可能会被提前取消（虽然单次操作大概率能完成，但这是不安全的写法）。正确的做法是在ViewModel里维护一个Set<AnyCancellable>来存储所有订阅：

class YourViewModel {
    let settingsModel: LocalSettingsModel
    private var cancellables = Set<AnyCancellable>() // 新增一个存储容器

    func saveLocalSettings(){
        settingsUseCase
            .saveLocalSettings(localSettingsModel: settingsModel)
            .sink(receiveCompletion: { completion in
                print("Completed!!!")
                // 这里别忘了处理错误，比如给用户弹提示
                if case .failure(let error) = completion {
                    print("保存失败：\(error.localizedDescription)")
                }
            }) { _ in
                print("保存操作完成！")
            }
            .store(in: &cancellables) // 把订阅存到Set里
    }
}

这样订阅会一直存活直到操作完成（或者ViewModel被销毁）。而且Combine有个贴心的机制：当Publisher发送完completion事件后，会自动取消订阅并从Set里移除对应的AnyCancellable，所以你完全不需要手动调用cancel()——省了不少事。

3. 如果是异步操作，换用Future

如果你的数据库写入是异步的（比如用了Realm的异步写入API，或者涉及网络请求），那Just就不适用了，这时候应该用Future——它专门用来处理单次异步任务，在闭包里执行异步逻辑，然后通过promise返回结果或错误：

// 异步场景下的DataSource示例
func saveLocalSettings(localSettings: LocalSettingsRealmModel) -> AnyPublisher<LocalSettingsRealmModel, LocalDataSourceError> {
    Future { promise in
        DispatchQueue.global().async {
            do {
                let realm = try Realm()
                try realm.write {
                    realm.add(localSettings, update: .modified)
                }
                promise(.success(localSettings))
            } catch {
                promise(.failure(.unknown(error)))
            }
        }
    }
    .receive(on: DispatchQueue.main) // 切回主线程处理结果
    .eraseToAnyPublisher()
}

不过你的当前场景是同步写入，所以Just是更优选择。

4. 订阅端不需要额外处理

其实你不用刻意在订阅端做特殊操作——Sink会自动在completion触发后清理资源。你只需要确保订阅被正确存储，避免提前释放就行。

最后总结下关键要点：

• 同步单次操作：用Just+setFailureType，简洁高效
• 异步单次操作：用Future
• 退订：通过store(in: &cancellables)管理订阅，Combine自动处理后续清理
• 错误处理：在sink的receiveCompletion分支统一处理失败情况，代码更易维护

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