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、創建序列
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接收
代碼執行順序
-
Observable<Any>.create創建一個閉包 -
ob.subscribe，需要取得text值才能繼續下一步閉包內打印 - 執行
observer.onNext("訂閱中心發送消息")取text的值 - 返回text的值執行
print("訂閱到:\(text)")，打印結果
源碼分析
- 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))
}
- 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
}
