特征序列(Traits)简介
RxSwift 里面 Observable
也存在一些特征序列,这些特征序列可以帮助我们更准确的描述序列。并且它们还可以给我们提供语法糖,让我们能够用更加优雅的方式书写代码。Single
、Completable
、Maybe
都属于可监听序列(Observable
),本文主要介绍这几个的特性以及使用方式以及部分源码解读:
01. Single
1. Single介绍
a. 要么只能发出一个元素
b. 要么产生一个error
事件
c. 不会共享附加作用
一个比较常见的例子就是执行 HTTP 请求,然后返回一个应答或错误。不过你也可以用Single
来描述任何只有一个元素的序列。
2. Single发送、订阅部分源码解读
从源码可以看到当create
的时候只能发送success
和failure
,在success
中调用on(.next(element)
后,又立刻调用了on(.completed)
,则整个过程结束,为什么调用了on(.completed)
最后却没收到完成信号?请继续向下看~
public static func create(subscribe: @escaping (@escaping SingleObserver) -> Disposable) -> Single<Element> { let source = Observable<Element>.create { observer in return subscribe { event in switch event { case .success(let element): observer.on(.next(element)) observer.on(.completed) case .failure(let error): observer.on(.error(error)) } } } return PrimitiveSequence(raw: source) }
@frozen public enum Result<Success, Failure> where Failure : Error { case success(Success) case failure(Failure) }
订阅部分仔细看stopped
属性会发现,当接收到event
后stopped
由false
改为了true
,并且内部判断当为true
的时候,直接return
了,这就是为什么调用了on(.completed)
最后却没收到完成信号?后面的信号Maybe
也是类似设计,下文不再重复介绍;
再来看回调可以看到SingleEvent
为Result
的别名,Result
只有success
和failure
两个值,而订阅的结果为next(Event)
和error
,不会再执行completed
,最后订阅的结果包装成SingleEvent
,供外界使用
public func subscribe(_ observer: @escaping (SingleEvent<Element>) -> Void) -> Disposable { var stopped = false return self.primitiveSequence.asObservable().subscribe { event in if stopped { return } stopped = true switch event { case .next(let element): observer(.success(element)) case .error(let error): observer(.failure(error)) case .completed: rxFatalErrorInDebug("Singles can't emit a completion event") } } }
3. Single的使用
single(.success(100)):发出一个100的元素
single(.failure(TestError.none)):发出一个error信号
Single<Int>.create { (single) -> Disposable in single(.success(100)) // single(.failure(TestError.none)) return Disposables.create() }.subscribe { (value) in print(value) } onFailure: { (error) in print(error) } onDisposed: { print("onDisposed") }.disposed(by: disposeBag)
运行结果:
100 onDisposed
02. Completable
1. Completable介绍
a. 不会发出任何元素
b. 发出一个completed
事件或者一个error
事件
c. 不会共享附加作用
Completable
适用于那种你只关心任务是否完成,而不需要在意任务返回值的情况。它和Observable<Void>
有点相似。
2. Completable订阅回调部分源码解读
从源码可以看到 CompletableEvent
是一个枚举,有error
和completed
两个值,订阅的结果只有error
和completed
事件,没有next(Event)
事件,并把订阅的结果包装成CompletableEvent
,供外界使用
public enum CompletableTrait { } public typealias Completable = PrimitiveSequence<CompletableTrait, Swift.Never> @frozen public enum CompletableEvent { case error(Swift.Error) case completed }
extension PrimitiveSequenceType where Trait == CompletableTrait, Element == Swift.Never { public func subscribe(_ observer: @escaping (CompletableEvent) -> Void) -> Disposable { ... switch event { case .next: rxFatalError("Completables can't emit values") case .error(let error): observer(.error(error)) case .completed: observer(.completed) } }
3. Completable的使用
completable(.completed)
: 发出完成事件
completable(.error(TestError.none))
:发出error
事件
Completable.create(subscribe: { (completable) -> Disposable in completable(.completed) completable(.error(TestError.none)) return Disposables.create() }).subscribe { print("completed") } onError: { (error) in print(error) } onDisposed: { print("onDisposed") }.disposed(by: disposeBag)
运行结果:
completedon Disposed
03. Maybe
1. Maybe介绍
a. 发出一个元素或者一个completed
事件或者一个error
事件
b. 不会共享附加作用
如果你遇到那种可能需要发出一个元素,又可能不需要发出时,就可以使用Maybe
2. Maybe订阅回调部分源码解读
从源码可以看到CompletableEvent
是一个枚举,有success
,error
和completed
三个值,订阅的结果也有next(Event)
,error
和completed
事件,一旦收到订阅结果后,后面的就不会再执行,和上文Single
设计类似,最后再订阅的结果包装成MaybeEvent
,供外界使用
public enum MaybeTrait { } public typealias Maybe<Element> = PrimitiveSequence<MaybeTrait, Element> @frozen public enum MaybeEvent<Element> { case success(Element) case error(Swift.Error) case completed }
extension PrimitiveSequenceType where Trait == MaybeTrait { public typealias MaybeObserver = (MaybeEvent<Element>) -> Void ... public func subscribe(_ observer: @escaping (MaybeEvent<Element>) -> Void) -> Disposable { ... switch event { case .next(let element): observer(.success(element)) case .error(let error): observer(.error(error)) case .completed: observer(.completed) } } }
3. Maybe的使用
maybe(.success(200))
: 发出一个元素
maybe(.completed)
: 发出完成事件
maybe(.error(TestError.none))
:发出error
事件
Maybe<Int>.create(subscribe: { (maybe) -> Disposable in maybe(.success(200)) // maybe(.completed) // maybe(.error(TestError.none)) return Disposables.create() }).subscribe { (element) in print(element) } onError: { (error) in print(error) } onCompleted: { print("completed") } onDisposed: { print("onDisposed") }.disposed(by: disposeBag)
运行结果:
200 onDisposed
总结
Single
、Completable
、Maybe
均不会共享附加作用
1. Single
要么只能发出一个元素、要么产生一个error
事件
2. Completable
不会发出任何元素,只能发出一个completed
事件或者一个error
事件
3.Maybe
只能发出一个元素或者一个completed
事件或者一个error
事件