RxSwift-序列继承链

上一篇里我们去找了RxSwift的Create文件，create这个方法会返回一个AnonymousObservable对象，他继承自Producer，而Producer又继承自Observable，Observable是所有序列的基类，他又遵循了一个ObservableType的协议，我们会发现这个协议基本上是贯穿全局的，它可以根据不同的模块和业务功能等进行扩展。这个是RxSwift万物皆序列的第一点。

减少篇幅，不重复贴源码了，可以去翻RxSwift核心逻辑初探。在这里我们看一下Observable，重点在asObservable()这个方法，返回的是self,奇不奇怪？本身就是个序列了，为什么还要返回一个self?

public class Observable<Element> : ObservableType {
    /// Type of elements in sequence.
    public typealias E = Element
    
    init() {
#if TRACE_RESOURCES
        _ = Resources.incrementTotal()
#endif
    }
    
    public func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
        rxAbstractMethod()
    }
    
    public func asObservable() -> Observable<E> {
        return self
    }
    
    deinit {
#if TRACE_RESOURCES
        _ = Resources.decrementTotal()
#endif
    }

    // this is kind of ugly I know :(
    // Swift compiler reports "Not supported yet" when trying to override protocol extensions, so ¯\_(ツ)_/¯

    /// Optimizations for map operator
    internal func composeMap<R>(_ transform: @escaping (Element) throws -> R) -> Observable<R> {
        return _map(source: self, transform: transform)
    }
}

来个例子：Person继承自NSObject，但是Person就是NSObject吗？当然不是了，但我们想让Person具有NSObject的能力，一般在swift里面会用 Person as NSObject来进行强制类型转换，来保证Person是一个NSObject类型。通过代码看一下

UISwitch().rx.value.asObservable()

不写.asObservable(),其实也可以使用，但是我们点进去value看一下

public var value: ControlProperty<Bool> {
        return base.rx.controlPropertyWithDefaultEvents(
            getter: { uiSwitch in
                uiSwitch.isOn
            }, setter: { uiSwitch, value in
                uiSwitch.isOn = value
            }
        )
    }

ControlProperty再点进去看下

public struct ControlProperty<PropertyType> : ControlPropertyType 

ControlPropertyType是个协议,它遵循ObservableType这个协议

public protocol ControlPropertyType : ObservableType, ObserverType {

    /// - returns: `ControlProperty` interface
    func asControlProperty() -> ControlProperty<E>
}

这代码写着写着，发现违背了一个宗旨，这不是序列了啊，只是遵循了一个ObservableType的协议。就不能当作普通序列来使用，但是我们加上.asObservable(),再点进去看下.asObservable()的实现,返回的就是Observable对象了。这就是万物皆序列的第二点

    /// - returns: `Observable` interface.
    public func asObservable() -> Observable<E> {
        return self._values
    }

看图更明了

RxObservable继承链.png

我们平时也会去封装基类，但是有时候基类里面会写很多东西，在基类里面放什么才是最合适的呢？基类是要实现普遍功能的人，以Observable为例，序列要具有一个序列的功能，所以就有asObservable(),序列要有订阅，所以就有subscribe抽象接口，init（）和deinit（）使得继承自他的所有对象都具有他自己维护的引用计数增减的功能，类似埋点。