如何在ReactorKit中优雅绑定Action/Mutation结果到RxFlow的Steps发射器

核心思路 #

要在Reactor内部绑定Action/Mutation到RxFlow的Step发射器，同时避免使用带self捕获的do操作符，核心是将路由副作用从业务流中剥离，通过显式的绑定方法关联Action/Mutation流与Step发射器，同时利用RxSwift的内存管理机制避免循环引用。

实现步骤与代码示例 #

1. 定义Step发射协议

先创建通用协议，让需要发射Step的Reactor统一持有Step发射器：

import ReactorKit
import RxFlow
import RxSwift

protocol StepEmittingReactor: Reactor {
    var steps: PublishRelay<Step> { get }
}

2. 封装绑定扩展

为Reactor添加通用绑定方法，统一处理Action/Mutation到Step的映射与绑定，减少重复代码：

extension Reactor where Self: StepEmittingReactor {
    /// 绑定Action流到Step发射器
    func bindActionToStep(
        filter: @escaping (Action) -> Bool,
        mapToStep: @escaping (Action) -> Step
    ) -> Disposable {
        return action
            .filter(filter)
            .map(mapToStep)
            .bind(to: steps)
    }
    
    /// 绑定Mutation流到Step发射器
    func bindMutationToStep(
        filter: @escaping (Mutation) -> Bool,
        mapToStep: @escaping (Mutation) -> Step
    ) -> Disposable {
        return mutation
            .filter(filter)
            .map(mapToStep)
            .bind(to: steps)
    }
}

3. 实现具体Reactor

以登录场景为例，实现遵循StepEmittingReactor的Reactor，在初始化阶段完成绑定：

// 定义App全局Step
enum AppStep: Step {
    case loginInitiated
    case loginSuccess
    case loginFailed(String)
}

// 登录业务Reactor
class LoginReactor: Reactor, StepEmittingReactor {
    enum Action {
        case login(username: String, password: String)
    }
    
    enum Mutation {
        case setLoading(Bool)
        case setError(String?)
        case loginCompleted
    }
    
    struct State {
        var isLoading: Bool = false
        var error: String?
    }
    
    let initialState = State()
    let steps = PublishRelay<Step>()
    private let loginService: LoginService
    private let disposeBag = DisposeBag()
    
    init(loginService: LoginService) {
        self.loginService = loginService
        
        // 绑定Action：用户触发登录时发射loginInitiated Step
        bindActionToStep(
            filter: {
                guard case .login = $0 else { return false }
                return true
            },
            mapToStep: { _ in AppStep.loginInitiated }
        ).disposed(by: disposeBag)
        
        // 绑定Mutation：登录完成时发射loginSuccess Step
        bindMutationToStep(
            filter: { $0 == .loginCompleted },
            mapToStep: { _ in AppStep.loginSuccess }
        ).disposed(by: disposeBag)
    }
    
    func mutate(action: Action) -> Observable<Mutation> {
        switch action {
        case .login(let username, let password):
            return .concat([
                .just(.setLoading(true)),
                loginService.login(username: username, password: password)
                    .map { _ in Mutation.loginCompleted }
                    .catch { error in .just(.setError(error.localizedDescription)) },
                .just(.setLoading(false))
            ])
        }
    }
    
    func reduce(state: State, mutation: Mutation) -> State {
        var newState = state
        switch mutation {
        case .setLoading(let isLoading):
            newState.isLoading = isLoading
        case .setError(let error):
            newState.error = error
        case .loginCompleted:
            newState.error = nil
        }
        return newState
    }
}

4. 在Flow中订阅Step

在RxFlow的Flow实现里，订阅Reactor的steps发射器，将Step转发到路由逻辑：

class AppFlow: Flow {
    var root: Presentable { rootViewController }
    
    private let rootViewController = UINavigationController()
    private let loginReactor: LoginReactor
    private let disposeBag = DisposeBag()
    
    init(loginReactor: LoginReactor) {
        self.loginReactor = loginReactor
    }
    
    func start() -> FlowContributors {
        let loginVC = LoginViewController(reactor: loginReactor)
        rootViewController.setViewControllers([loginVC], animated: false)
        
        // 订阅Reactor的Step流，转发到Flow的路由处理
        loginReactor.steps
            .subscribe(onNext: { [weak self] step in
                self?.step.accept(step)
            })
            .disposed(by: disposeBag)
        
        return .one(flowContributor: .contribute(withNextPresentable: loginVC, withNextStepper: loginVC))
    }
    
    func navigate(to step: Step) -> FlowContributors {
        guard let appStep = step as? AppStep else { return .none }
        
        switch appStep {
        case .loginSuccess:
            let homeVC = HomeViewController()
            rootViewController.pushViewController(homeVC, animated: true)
            return .none
        case .loginFailed(let error):
            // 显示错误提示逻辑
            return .none
        case .loginInitiated:
            // 记录登录触发日志等操作
            return .none
        }
    }
}

方案优势 #

• 彻底避免do操作符的self捕获问题，副作用处理更直观
• 绑定逻辑通过扩展封装，可在多个Reactor中复用
• 业务逻辑（Reactor）与路由逻辑（Flow）完全分离，符合单一职责原则
• 内存管理安全：通过disposeBag和weak self避免循环引用

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