1. 前言

ReactorKit是建立在RxSwift生态下的一个状态管理框架，说是框架，其实它的封装非常轻量。本文是阅读源码的一些收获。

2. 协议和运行时

为了让Swift的protocol extension具有 给实现协议的人动态添加一个属性（依赖） 这个能力，它采用了runtime的实现方式。

例如给Reactor协议添加一个disposeBag变量：

protocol Reactor { ... }
extension Reactor {
    fileprivate var disposeBag: DisposeBag {
        get { return self.associatedObject(forKey: &disposeBagKey, default: DisposeBag()) }
    }
}

最终调用的是：

objc_setAssociatedObject(self, key, object, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

3. 谁来处理副作用

对于一个函数式框架来说，这点至关重要。比如Flux是通过ActionCreator，Redux是由Middlewares来真正处理这些对外界环境的不纯函数（脏活累活）。

而ReactorKit这边是由Reactor里的mutate()函数来处理副作用的。

func mutate(action: Action) -> Observable<Mutation>

需要注意的是，由于他的返回值是Observable，这意味着在Action转换到Mutation的过程中，可以异步执行副作用来获取结果（比如网络请求，数据库操作）。

4. 如何修改内部状态(State)

Reactor的核心方法（也是最长的）就是：

func createStateStream() -> Observable<State>

Reactor内声明的大多数函数都在此方法被调用，状态就是在这个方法内最终被改变的。

具体看一下他是怎么做到的：

public func createStateStream() -> Observable<State> {
    let action = self._action.asObservable()
    let transformedAction = self.transform(action: action)
    let mutation = transformedAction
      .flatMap { [weak self] action -> Observable<Mutation> in
        guard let `self` = self else { return .empty() }
        return self.mutate(action: action).catchError { _ in .empty() }
      }
    let transformedMutation = self.transform(mutation: mutation)
    let state = transformedMutation
      .scan(self.initialState) { [weak self] state, mutation -> State in
        guard let `self` = self else { return state }
        return self.reduce(state: state, mutation: mutation)
      }
      .catchError { _ in .empty() }
      .startWith(self.initialState)
      .observeOn(MainScheduler.instance)
    let transformedState = self.transform(state: state)
      .do(onNext: { [weak self] state in
        self?.currentState = state
      })
      .replay(1)
    transformedState.connect().disposed(by: self.disposeBag)
    return transformedState
  }

【Action】 取Observable<Action>
【Action】 放到transform()函数中，给用户时机改变其序列类型
【Action】 于是得到了转换过的Observable<Action>，记作transformedAction
【Action 绑定 (Action) -> Mutation】 把transformedAction绑定(flatMap)到mutate()函数上，mutate()的签名是(Action) -> Observable<Mutation>，用户的副作用在绑定过程中执行。
【Mutation】 于是得到新的序列，类型为Observable<Mutation>，意味着用户已经把数据拿到，一切就位。
【Mutation】 放到transform()函数中，给用户时机改变其序列类型
【Mutation】 于是得到了转换过的Observable<Mutation>，记作transformedMutation
【(State, Mutation) -> State】 即执行reduce()方法，通过scan函数让mutation可以不断作用到state上
【State】 得到结果Observable<State>
【State】 放到transform()函数中，给用户时机改变其序列类型
【State】 于是得到了转换过的Observable<State>，记作transformedState
【State】 顺便修改内部的currentState
【State】 返回最终结果

这个过程结合这个图看就更加清晰，这个函数（也是整个Reactor）的作用就是要做这么一件事： Action->Mutation->State