RxSwift Observable可觀察序列

squence序列

  • 有限序列
let ob = Observable.just([1, 2, 3, 4])
        ob.subscribe(onNext: { (num) in
            print(num)
        }, onCompleted: {
            print("完成")
        })
/*
輸出結果:
[1, 2, 3, 4]
完成
*/
  • 無限序列
URLSession.shared.rx.response(request: URLRequest.init(url: URL.init(string: "http://www.baidu.xx")!))
            .subscribe(onNext: { (response, data) in
                
            }, onError: { (error) in
                print(error)
            })
/*
輸出結果:
錯誤,Error Domain=NSURLErrorDomain Code=-1022 "The resource could not be loaded because the App Transport Security policy requires the use of a secure connection."
*/

核心邏輯

  1. 序列的產生
  2. 序列的訂閱
  3. 序列的銷燬
        //1、創建序列
        let ob = Observable<Any>.create { (observer) -> Disposable in
            //3、發送序列
            observer.onNext("訂閱中心發送消息")
            //complete和error不會同時發生
//            observer.onCompleted()
            observer.onError(NSError.init(domain: "error", code: 1002, userInfo: nil))
            return Disposables.create()
        }
        
        //2、訂閱序列
       let _ = ob.subscribe(onNext: { (text) in
            print("訂閱到:\(text)")
        }, onError: { (error) in
            print("error:\(error)")
        }, onCompleted: {
            print("completed")
        }) {
            print("disposed")
        }

響應式核心邏輯

類似於UIControl類調用addTarget響應#selector定義的事件,RxSwift將響應事件留在rx內部類處理,在內部類由訂閱中心執行onNext發送消息,消息傳送到subscribe接收

代碼執行順序
  1. Observable<Any>.create創建一個閉包
  2. ob.subscribe,需要取得text值才能繼續下一步閉包內打印
  3. 執行observer.onNext("訂閱中心發送消息")取text的值
  4. 返回text的值執行print("訂閱到:\(text)"),打印結果
源碼分析
  1. create方法

create方法聲明,從註釋和查找得到create方法在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 (RxSwift.AnyObserver<Self.Element>) -> Disposable) -> RxSwift.Observable<Self.Element>

從RxSwift源碼查找Create類的create方法實現,create方法返回了一個帶subscribe參數的AnonymousObservable

public static func create(_ subscribe: @escaping (AnyObserver<Element>) -> Disposable) -> Observable<Element> {
        return AnonymousObservable(subscribe)
    }

AnonymousObservable匿名內部類,繼承於Producer;
內部類執行init初始化,_subscribeHandler保存create閉包,使用函數式編程,可以在使用的地方隨時調用_subscribeHandler

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

    let _subscribeHandler: SubscribeHandler
//init初始化
    init(_ subscribeHandler: @escaping SubscribeHandler) {
        self._subscribeHandler = subscribeHandler //保存閉包
    }

    //run方法,執行sink.run(self),
    override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
        let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
        let subscription = sink.run(self)
        return (sink: sink, subscription: subscription)
    }
}

sink.run實現,調用了_subscribeHandler將create閉包數據傳遞出去

typealias Parent = AnonymousObservable<Element>
//parent爲AnonymousObservable的別名創建的對象
func run(_ parent: Parent) -> Disposable {
        return parent._subscribeHandler(AnyObserver(self))
    }
  1. subscribe方法

subscribe方法聲明,Observable繼承於ObservableType協議,需要找協議裏的subscribe方法實現

public func subscribe(onNext: ((Self.Element) -> Void)? = nil, onError: ((Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil) -> Disposable

subscribe方法實現,創建了AnonymousObserver,參數是閉包,event類型決定執行閉包裏的對應方法->next、error、complete

    public func subscribe(onNext: ((Element) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
        -> Disposable { //銷燬
            let disposable: Disposable
            
            if let disposed = onDisposed {
                disposable = Disposables.create(with: disposed)
            }
            else {
                disposable = Disposables.create()
            }
            
            #if DEBUG
                let synchronizationTracker = SynchronizationTracker()
            #endif
            //調用堆棧
            let callStack = Hooks.recordCallStackOnError ? Hooks.customCaptureSubscriptionCallstack() : []
            //創建AnonymousObserver,參數是閉包,包含next、error、complete信息
            let observer = AnonymousObserver<Element> { event in
                
                #if DEBUG
                    synchronizationTracker.register(synchronizationErrorMessage: .default)
                    defer { synchronizationTracker.unregister() }
                #endif
                
                switch event {
                case .next(let value):
                    onNext?(value)
                case .error(let error):
                    if let onError = onError {
                        onError(error)
                    }
                    else {
                        Hooks.defaultErrorHandler(callStack, error)
                    }
                    disposable.dispose()
                case .completed:
                    onCompleted?()
                    disposable.dispose()
                }
            }
            //返回銷燬者,其中回調subscribe(observer),subscribe是在AnonymousObservable的父類Producer中實現
            return Disposables.create(
                self.asObservable().subscribe(observer),
                disposable
            )
    }

Producer實現,繼承於Observable,內部執行了子類AnonymousObservable 的run方法

class Producer<Element> : Observable<Element> {
    override init() {
        super.init()
    }

    override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
        if !CurrentThreadScheduler.isScheduleRequired {
            // The returned disposable needs to release all references once it was disposed.
            let disposer = SinkDisposer()
            let sinkAndSubscription = self.run(observer, cancel: disposer)
            disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

            return disposer
        }
        else {
            return CurrentThreadScheduler.instance.schedule(()) { _ in
                let disposer = SinkDisposer()
                let sinkAndSubscription = self.run(observer, cancel: disposer)
                disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

                return disposer
            }
        }
    }

    func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
        rxAbstractMethod()
    }
}

AnonymousObserver類的實現,類內部初始化創建了_eventHandler保存所有事件->next、error、complete信息

final class AnonymousObserver<Element>: ObserverBase<Element> {
    typealias EventHandler = (Event<Element>) -> Void
    
    private let _eventHandler : EventHandler
    //初始化,eventHandler保存所有事件
    init(_ eventHandler: @escaping EventHandler) {
#if TRACE_RESOURCES
        _ = Resources.incrementTotal()
#endif
        self._eventHandler = eventHandler
    }

    override func onCore(_ event: Event<Element>) {
        return self._eventHandler(event)
    }
    
#if TRACE_RESOURCES
    deinit {
        _ = Resources.decrementTotal()
    }
#endif
}
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章