使用RxDatasources时如何为自定义表头/表尾视图填充数据

我完全懂你的痛点——硬编码switch(section)配置表头太不灵活，数据源一变就彻底失效。下面给你两个实用方案，都能让自定义表头和RxDatasources的分区数据实时同步：

方案一：复用RxDatasources数据源对象（最直接高效） #

核心思路是把RxTableViewSectionedAnimatedDataSource从局部变量改成ViewController的实例变量，这样在TableView代理方法里就能直接拿到最新的分区数据，不用手动维护索引映射。

步骤1：将数据源声明为实例变量 #

把数据源移到ViewController全局作用域，在初始化时完成配置：

class BotConfigViewController: UIViewController {
    private let disposeBag = DisposeBag()
    private let tableView = UITableView()
    private var botConfigViewModel: ConfigViewModel!
    
    // 声明为实例变量，让代理方法能访问到最新数据
    private let dataSource: RxTableViewSectionedAnimatedDataSource<ConfigStatusSectionModel>
    
    init(viewModel: ConfigViewModel) {
        self.botConfigViewModel = viewModel
        // 初始化数据源，配置单元格逻辑
        self.dataSource = RxTableViewSectionedAnimatedDataSource<ConfigStatusSectionModel>(
            configureCell: { dataSource, tableView, indexPath, item in
                guard let cell = tableView.dequeueReusableCell(withIdentifier: ConfigItemTableViewCell.identifier, for: indexPath) as? BaseTableViewCell else {
                    return UITableViewCell()
                }
                cell.setup(data: item.model)
                return cell
            })
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    // ...其他生命周期方法
}

步骤2：绑定数据源并实现代理方法 #

修改数据绑定逻辑，然后在代理方法里通过数据源获取对应分区的模型，填充自定义表头：

private func observeDatasource(){
    botConfigViewModel.sections
        .bind(to: tableView.rx.items(dataSource: dataSource))
        .disposed(by: disposeBag)
    
    // 设置TableView代理
    tableView.rx.setDelegate(self).disposed(by: disposeBag)
}

extension BotConfigViewController: UITableViewDelegate {
    func tableView(_ tableView: UITableView, viewForHeaderInSection section: Int) -> UIView? {
        guard let header = tableView.dequeueReusableHeaderFooterView(
            withIdentifier: ConfigSectionTableViewHeader.identifier) as? ConfigSectionTableViewHeader,
              // 从数据源获取当前分区的最新模型
              let sectionModel = try? dataSource.sectionModels[section] else {
            return nil
        }
        
        // 用sectionModel的数据配置表头（比如你的sectionModel.model是分区标题）
        header.setup(with: sectionModel.model)
        // 如果表头需要更多数据，可直接从sectionModel的items或其他属性提取
        return header
    }
    
    func tableView(_ tableView: UITableView, heightForHeaderInSection section: Int) -> CGFloat {
        return UITableView.automaticDimension
    }
    
    func tableView(_ tableView: UITableView, estimatedHeightForHeaderInSection section: Int) -> CGFloat {
        return 40
    }
}

为什么这个方案有效？ #

• 每次ViewModel的sections更新时，RxDatasources会自动同步dataSource.sectionModels的内容
• TableView刷新时会重新调用viewForHeaderInSection，此时拿到的sectionModel是最新的，完全和数据源同步
• 不管分区数量、顺序怎么变化，代理方法逻辑都不用修改，彻底摆脱硬编码

方案二：用Rx直接绑定表头数据（更灵活） #

如果你的表头需要独立响应数据变化（比如实时监听分区数据的细微改动），可以给自定义表头添加Rx属性，通过分区索引绑定对应数据：

步骤1：给自定义表头添加Rx绑定能力 #

class ConfigSectionTableViewHeader: UITableViewHeaderFooterView {
    private let titleLabel = UILabel()
    
    // 定义Rx属性，用于接收标题数据
    var title: Binder<String> {
        return Binder(self) { header, title in
            header.titleLabel.text = title
        }
    }
    
    // ...初始化和布局代码
}

步骤2：在ViewController中绑定表头数据 #

监听sections变化，给每个分区的表头绑定对应数据：

private func observeDatasource(){
    let sectionsObservable = botConfigViewModel.sections.share()
    
    // 绑定单元格数据源
    sectionsObservable
        .bind(to: tableView.rx.items(dataSource: dataSource))
        .disposed(by: disposeBag)
    
    // 绑定表头数据
    sectionsObservable
        .subscribe(onNext: { [weak self] sections in
            guard let self = self else { return }
            for (sectionIndex, sectionModel) in sections.enumerated() {
                if let header = self.tableView.headerView(forSection: sectionIndex) as? ConfigSectionTableViewHeader {
                    header.title.onNext(sectionModel.model)
                }
            }
        })
        .disposed(by: disposeBag)
    
    tableView.rx.setDelegate(self).disposed(by: disposeBag)
}

这个方案适合复杂的响应式场景，但方案一已经能满足大部分需求，更简洁易用。

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