rxswift学习-Observable初探

2017-06-06

什么是Observable?

observable sequence也是一个sequence。

Observable等价于sequence
Observable的subscribe方法等价于sequence的makeIterator方法
传入subscribe方法的observer用来接收elements 等价于 sequence的iterator的next()方法来获取elements。

let sequence = 0..<3
var iterator = sequence.makeIterator()
while let n = iterator.next() {
	print(n)
}

let one = 1
let two = 2
let three = 3
let observable = Observable.of(one, two, three)
observable.subscribe { event in
	print(event)
}

如果遇到.completed和.error将不会再emit elements。

这些都比较官方话，现在还是没什么概念。先看看关系图：

先选一个详细看看

Just操作符

public static func just(
_ element: E, 
scheduler: ImmediateSchedulerType) 
-> Observable<E> {
    return JustScheduled(element: element, scheduler: scheduler)
}

再看看JustScheduled

final class JustScheduled<Element> : Producer<Element> {
    fileprivate let _scheduler: ImmediateSchedulerType
    fileprivate let _element: Element
    ///由于just的emit一个element，所以传入需要emit的element
    init(element: Element, scheduler: ImmediateSchedulerType) {
        _scheduler = scheduler
        _element = element
    }
  override func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == E {
   ///关于这段代码，有些不是太懂，除了这个操作符，很多其他的操作符都会先创建一个sink对象，然后调用他的run方法，然后返回。至于为什么要将observer、cancelable封装成sink对象？不大明白，只能理解为是对流程的一个抽象，将具体的emit操作交给sink完成，然后统一暴露一个run方法来执行emit，这样其他操作符也可以统一按照这个抽象执行。如果要新增一个操作符，那么可以创建一个对应的sink对象，然后调用run方法，具体的逻辑已经被封装到了sink对象中,这里的run方法就能够保证有统一的行为。
      let sink = JustScheduledSink(parent: self, observer: observer, cancel: cancel)
      let subscription = sink.run()
      return (sink: sink, subscription: subscription)
  }
}

final class JustScheduledSink<O: ObserverType> : Sink<O> {
    typealias Parent = JustScheduled<O.E>
    private let _parent: Parent
    /**
    将所有emit需要的东西作为参数传入,
    parent包含了需要emit的element和scheduler
    observer包含了处理element的eventHanlder,
    cancel:是一个SinkDisposer，不太明白为什么要传入这个，用到它的地方是sink的dispose方法。因为本来就是SinkDisposer的dispose方法会调用sink的dispose方法。现在sink的dispose方法又调用了SinkDisposer的dispose方法。还好SinkDisposer的dispose方法中有判断，不然就是一个循环调用了。
    */
    init(parent: Parent, observer: O, cancel: Cancelable) {
        _parent = parent
        super.init(observer: observer, cancel: cancel)
    }
    ///再来看看sink的run方法，通过parent拿到scheduler，在sheduler中调用forwardOn将element emite出去。最后返回一个disposable。
    func run() -> Disposable {
        let scheduler = _parent._scheduler
        return scheduler.schedule(_parent._element) { element in
            self.forwardOn(.next(element))
            return scheduler.schedule(()) { _ in
                self.forwardOn(.completed)
                self.dispose()
                return Disposables.create()
            }
        }
    }
}

实际上很多操作符都是这种模式。创建对应的sink类，在run方法中去emit element，再返回一个disposable。我们在学习操作符时就可以猜测他怎么实现的，在看源码进行比较，这样记忆会深刻一点。