阅读 RxSwift 源码的目的

RxSwift采用面向协议编程思想，函数式编程，堪称教科书式编码，想要写好Swift的代码，都应该读读其核心代码，了解其编程思想以及编程技巧

Hello RxSwift

先看看hello world 代码

/*:
 ### Observables and observers (aka subscribers)
 
 `Observable`s will not execute their subscription closure unless there is a subscriber. In the following example, the closure of the `Observable` will never be executed, because there are no subscribers:
 */
example("Observable with no subscribers") {
    _ = Observable<String>.create { (observerOfString: AnyObserver<String>) -> Disposable in
        print("This will never be printed")
        
        
        observerOfString.on(.next("😬"))
        observerOfString.on(.completed)
        return Disposables.create()
    }
}

这段代码的闭包永远不会执行，那为什么它不会执行呢？我们跟踪一下

extension ObservableType {
    // MARK: create

    /**
     Creates an observable sequence from a specified subscribe method implementation.

     - seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)

     - parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
     - returns: The observable sequence with the specified implementation for the `subscribe` method.
     */
    public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
        return AnonymousObservable(subscribe)
    }
}

ObservableType 是一个协议，协议扩展了一个create方法，对协议不太熟悉请查阅相关：面向协议编程、协议扩展资料
该方法返回 AnonymousObservable 类，那么我们仔细看看 AnonymousObservable 这个类

final fileprivate class AnonymousObservable<Element> : Producer<Element> {
    typealias SubscribeHandler = (AnyObserver<Element>) -> Disposable

    let _subscribeHandler: SubscribeHandler

    init(_ subscribeHandler: @escaping SubscribeHandler) {
        _subscribeHandler = subscribeHandler
    }

    override func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {
        let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
        let subscription = sink.run(self)
        return (sink: sink, subscription: subscription)
    }
}

看到这里大家应该明白了，create函数只是简单的创建一个实体类，这个实体类在初始化的时候只是简单的持有这个闭包，并没有执行这个闭包

技巧解析

final fileprivate class AnonymousObservable<Element> : Producer<Element> 

• final : 表示该类不可被继承，能够保证其方法能够正确执行，禁止对该类进行继承，然后override 其方法，属性，以致于得到非预期的结果
• fileprivate ： 确定权限，确保只有同属于一个文件的类，才能直接初始化该类
• AnonymousObservable：匿名Observable，这个类对外是不可见的，如果仅限于使用Rx，都无需知道它的具体存在，良好的封装性保证其透明性

透明性： 实际存在的东西，用户却感知不到它的存在，例如你使用http协议，你就感受不到tcp协议，tcp协议对于你来说就是透明的，好像根本不存在一样

那为什么说它是透明的呢？ 首先你从外部没法直接初始化该类，你只能通过调用create方法初始化该类，但是该方法返回的是Observable 对象，这样用户根本不知道AnonymousObservable的存在，事实上用户也不用关心他到底是不是AnonymousObservable。

Rx尽可能避免返回具体的Observable具体类型，确保用户不需要关心具体的内部细节。