RxSwift+MVVM场景下如何批量保存问题答案的技术问询

嘿，这个场景我太熟悉了！用RxSwift+MVVM做批量保存，关键就是要把「实时响应答案变更」和「点击保存才提交」这两个逻辑拆分开——你之前的问题是因为订阅了每个问题的answer变更，导致每次作答就触发保存，现在我们要改成只有点击保存按钮时，才一次性收集所有当前答案再批量处理。

下面给你两个实用的方案，按需选择：

方案一：直接持有ViewModel数组，点击时遍历取当前值 #

这是最直接易懂的方式，适合不需要太复杂Rx操作的场景。我们只需要给QuestionViewModel提供一个获取当前答案的入口，然后在保存按钮点击时遍历所有ViewModel收集答案：

// 先调整QuestionViewModel，暴露当前答案的访问方法
class QuestionViewModel {
    private let question: Question
    private let questionAnswerRelay = BehaviorRelay<String?>(value: nil)
    // 对外暴露的Driver，用于绑定UI展示答案
    var questionAnswer: Driver<String?> {
        questionAnswerRelay.asDriver()
    }
    
    init(question: Question) {
        self.question = question
    }
    
    // 提供获取当前答案的方法（或者直接把questionAnswerRelay设为内部可访问）
    func getCurrentAnswer() -> String? {
        questionAnswerRelay.value
    }
    
    // 处理用户输入的方法，比如绑定输入框的内容
    func updateAnswer(_ answer: String?) {
        questionAnswerRelay.accept(answer)
    }
}

// 主页面的ViewModel
class MainQuestionViewModel {
    private let questionViewModels: [QuestionViewModel]
    let saveButtonTapped = PublishRelay<Void>()
    private let disposeBag = DisposeBag()
    
    init(questions: [Question]) {
        self.questionViewModels = questions.map { QuestionViewModel(question: $0) }
        
        // 绑定保存按钮的点击事件
        saveButtonTapped
            .subscribe(onNext: { [weak self] in
                guard let self = self else { return }
                // 收集所有非空的答案，配对问题ID
                let answersToSave = self.questionViewModels.compactMap { vm in
                    guard let answer = vm.getCurrentAnswer() else { return nil }
                    return (questionId: vm.question.id, answer: answer)
                }
                
                // 执行批量保存逻辑
                self.performBatchSave(answersToSave)
            })
            .disposed(by: disposeBag)
    }
    
    private func performBatchSave(_ answers: [(questionId: String, answer: String)]) {
        // 这里写你的批量保存逻辑：比如调用API、写入本地数据库等
        // 示例：如果是网络请求，可以用RxSwift封装的网络层
        // APIService.batchSaveAnswers(answers)
        //     .subscribe(onNext: { _ in
        //         // 保存成功后的处理：比如弹出提示、返回上一页
        //     }, onError: { error in
        //         // 处理错误
        //     })
        //     .disposed(by: disposeBag)
    }
}

优点：逻辑直观，代码量少，适合简单场景；缺点：直接访问了BehaviorRelay的value，稍微有点背离纯响应式的理念，但在实际项目中非常实用。

方案二：用Rx的combineLatest+withLatestFrom实现纯响应式收集 #

如果你想更贴合RxSwift的响应式思维，不想直接访问Relay的value，可以用combineLatest把所有问题的Answer Observable合并，然后在保存按钮点击时取一次最新值：

// QuestionViewModel不需要修改，保持原有Driver即可
class QuestionViewModel {
    private let question: Question
    private let questionAnswerRelay = BehaviorRelay<String?>(value: nil)
    var questionAnswer: Driver<String?> {
        questionAnswerRelay.asDriver()
    }
    
    init(question: Question) {
        self.question = question
    }
    
    func updateAnswer(_ answer: String?) {
        questionAnswerRelay.accept(answer)
    }
}

// 主ViewModel的实现
class MainQuestionViewModel {
    private let questionViewModels: [QuestionViewModel]
    let saveButtonTapped = PublishRelay<Void>()
    private let disposeBag = DisposeBag()
    
    init(questions: [Question]) {
        self.questionViewModels = questions.map { QuestionViewModel(question: $0) }
        
        // 把所有QuestionViewModel的answer Driver转成Observable数组
        let allAnswerObservables = questionViewModels.map { $0.questionAnswer.asObservable() }
        
        // 绑定保存按钮事件：用withLatestFrom获取合并后的最新答案数组
        saveButtonTapped
            .withLatestFrom(Observable.combineLatest(allAnswerObservables))
            .subscribe(onNext: { [weak self] allAnswers in
                guard let self = self else { return }
                // 配对问题和答案，过滤空值
                let answersToSave = zip(self.questionViewModels, allAnswers).compactMap { (vm, answer) in
                    guard let answer = answer else { return nil }
                    return (questionId: vm.question.id, answer: answer)
                }
                
                self.performBatchSave(answersToSave)
            })
            .disposed(by: disposeBag)
    }
    
    // 批量保存方法和方案一一致
    private func performBatchSave(_ answers: [(questionId: String, answer: String)]) {
        // 执行批量保存逻辑
    }
}

优点：完全遵循响应式编程理念，没有直接访问Relay的value；缺点：逻辑稍微绕一点，适合对RxSwift使用比较熟练的场景。

额外注意事项 #

• 答案校验：如果有必填问题，在收集答案后可以先校验，比如检查是否有必填问题未回答，再决定是否执行保存；
• 加载状态：保存过程中可以用一个BehaviorRelay<Bool>来控制页面的loading显示，比如在performBatchSave开始时loadingRelay.accept(true)，结束后loadingRelay.accept(false)；
• 内存泄漏：一定要用[weak self]避免循环引用，尤其是在subscribe的闭包里；

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