阅读 87

新手读的懂的RxSwift源码解析(三)-- FlatMap

今天,笔者与大家分析一下,RxSwift中另一个特别重要,甚至是最重要之一的操作符:flatMap。

如果大家没有读过本系列的第一篇,建议先阅读一下再来看本篇内容。

在RxSwift进行开发的过程中,有一个非常常见的场景:点击某个按钮,然后发送请求,之后处理请求结果。代码大致如下:

myBtn
  .rx
  .tap
  .flatMap { _ in
    performRequest()
  }
  .map {
    processResponse($0)
  }
  .subScribe(
    onNext: { ... }
  )
  .disposed(by: bag)
复制代码

在这个场景中,所要使用的最核心的一个操作符便是flatMap,它的作用是将myBtn产生的点击事件转换成另一个事件序列,并将该事件序列产生的事件向下传递。代码如下:

extension ObservableType {
    public func flatMap<Source: ObservableConvertibleType>(_ selector: @escaping (Element) throws -> Source)
        -> Observable<Source.Element> {
            return FlatMap(source: self.asObservable(), selector: selector)
    }
}
复制代码

该方法接收一个(Element) throws -> Source的closure,Element就是自身的元素类型,而返回值类型Source是一个泛型参数,并且是遵循ObservableConvertibleType的。也就是说,这个closuer会把上游产生的事件转换成一个事件序列。方法实现中返回了一个FlatMap类型的对象,这个对象持有了self.asObservable(),以及传入的closure. 接下来,咱们看一下这个FlatMap的源码:

final private class FlatMap<SourceElement, SourceSequence: ObservableConvertibleType>: Producer<SourceSequence.Element> {
    typealias Selector = (SourceElement) throws -> SourceSequence

    private let source: Observable<SourceElement>
    
    private let selector: Selector

    init(source: Observable<SourceElement>, selector: @escaping Selector) {
        self.source = source
        self.selector = selector
    }
    
    override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == SourceSequence.Element {
        let sink = FlatMapSink(selector: self.selector, observer: observer, cancel: cancel)
        let subscription = sink.run(self.source)
        return (sink: sink, subscription: subscription)
    }
}
复制代码

FlatMap是一个Producer的子类,在它的run方法中通过self.selector和observer生成了一个FlatMapSink类的对象。这个selector就是在调用flatMap时传入的closure, observer其实就是在subscribe方法中创建的observer(参见系列第一篇)。然后调用了FlatMapSink的run方法。但是我们再FlatMapSink里并没有看到run方法,因为FlatMapSink是MergeSink的子类,它的很多逻辑都在它的父类MergeSink里面:

private class MergeSink<SourceElement, SourceSequence: ObservableConvertibleType, Observer: ObserverType>
    : Sink<Observer>
    , ObserverType where Observer.Element == SourceSequence.Element {
    typealias ResultType = Observer.Element
    typealias Element = SourceElement

    let lock = RecursiveLock()

    var subscribeNext: Bool {
        true
    }

    // state
    let group = CompositeDisposable()
    let sourceSubscription = SingleAssignmentDisposable()

    var activeCount = 0
    var stopped = false

    ......    
    
  func run(_ source: Observable<SourceElement>) -> Disposable {
        _ = self.group.insert(self.sourceSubscription)

        let subscription = source.subscribe(self)
        self.sourceSubscription.setDisposable(subscription)
        
        return self.group
    }
}
复制代码

在源码的最后面,我们看到了run方法,只有四行,我们需要关注的是第二行:

let subscription = source.subscribe(self)
复制代码

也就是说让self订阅了传入的Observable,而这个传入的Observable就是FlatMap.source,也就是上游序列。这样一来大致流程就清楚了: 通过Obsevable.flatMap,让FlatMap类持有了上游Obsevable,并通过FlatMapSink订阅了这个上游Obsevable。接下来上游Obsevable的所有事件都会被传递给FlatMapSink的on方法(原理参见系列第一篇)。 接下来的重点,我们需要看一下这个FlatMapSink的on方法做了什么,还是在父类MergeSink里面。

    func on(_ event: Event<SourceElement>) {
        switch event {
        case .next(let element):
            if let value = self.nextElementArrived(element: element) {
                self.subscribeInner(value.asObservable())
            }
        case .error(let error):
            self.lock.performLocked {
                self.forwardOn(.error(error))
                self.dispose()
            }
        case .completed:
            self.lock.performLocked {
                self.stopped = true
                self.sourceSubscription.dispose()
                self.checkCompleted()
            }
        }
    }
复制代码

error事件会直接调用forwardOn,将事件传递给下游observer,completed事件则是调用checkCompleted方法,在checkCompleted方法中判断是否需要将completed事件传递下去。这是因为MergeSink可能会订阅多个事件序列,对这些事件进行一系列变换,直到所有的事件序列都complete之后才会传递,但这个不是今天的重点,所以只要知道个大概就可以了,具体的咱们在后续的文章中再介绍。 接下来看next事件,在next事件中会调用self.nextElementArrived(element: element):

    final private func nextElementArrived(element: SourceElement) -> SourceSequence? {
        self.lock.performLocked {
            if !self.subscribeNext {
                return nil
            }

            do {
                let value = try self.performMap(element)
                self.activeCount += 1
                return value
            }
            catch let e {
                self.forwardOn(.error(e))
                self.dispose()
                return nil
            }
        }
    }
复制代码

这个方法会首先加锁,然后执行self.performMap(element)方法,这个方法在子类(FlatMapSink)中有实现,其实就是调用self.selector:

    override func performMap(_ element: SourceElement) throws -> SourceSequence {
        try self.selector(element)
    }
复制代码

而这个selector其实就是在最初调用Observable.flatMap时传入的closure,所以到这里,myBtn的点击事件就会被转换成了一个事件序列。获取这个返回值之后,on方法会调用subscribeInner方法:

    func subscribeInner(_ source: Observable<Observer.Element>) {
        let iterDisposable = SingleAssignmentDisposable()
        if let disposeKey = self.group.insert(iterDisposable) {
            let iter = MergeSinkIter(parent: self, disposeKey: disposeKey)
            let subscription = source.subscribe(iter)
            iterDisposable.setDisposable(subscription)
        }
    }
复制代码

在这里,主要是创建了一个MergeSinkIter对象,并让这个MergeSinkIter对象订阅了传入的Observable。根据MergeSinkIter的on方法:

    func on(_ event: Event<Element>) {
        self.parent.lock.performLocked {
            switch event {
            case .next(let value):
                self.parent.forwardOn(.next(value))
            case .error(let error):
                self.parent.forwardOn(.error(error))
                self.parent.dispose()
            case .completed:
                self.parent.group.remove(for: self.disposeKey)
                self.parent.activeCount -= 1
                self.parent.checkCompleted()
            }
        }
    }
复制代码

我们可以看见它实际就是将事件传递给了parent,也就是MergeSink。但是注意,这里是直接调用的forwardOn方法,所以会直接把事件传递给下游observer,而不会触发performMap方法(当然也没法直接调用on方法,因为二者接收的参数泛型通常是不一样的)。

这样一来,flatMap的完整流程就结束了。

总结一下: 1.通过flatMap创建了一个FlatMap对象,并通过FlatMapSink订阅了上游Observable 2.当上游Observable产生一个事件时FlatMapSink通过调用FlatMap.performMap方法触发传入的closure,产生了新的事件序列。 3.通过MergeSinkIter将新的事件序列的事件传递个下游的observer,从而实现了Event->Observable->Event的传递。

它的流程和RxSwift中大部分操作符的核心逻辑差不多,都是通过持有上游observable,创建一个Sink的子类去订阅这个上游observable,然后将事件传递个下游的observer。只不过因为这里产生的是事件序列,所以又多出了一个MergeSinkIter来处理这个事件序列的事件并进行传递。 当然,今天只是介绍了FlatMap的具体流程,MergeSink的相关细节我们都忽略了,这个我们后面再说。

码字不易,若有错漏,欢迎指正。若有助益,烦请点赞。^ _ ^

文章分类
iOS
文章标签