RxSwift特征序列Single、Maybe、Completable的使用-阿里云开发者社区

RxSwift特征序列Single、Maybe、Completable的使用

2023-09-03 145

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： RxSwift特征序列Single、Maybe、Completable的使用

特征序列(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事件

RxSwift特征序列Single、Maybe、Completable的使用

热门文章

最新文章

相关课程

相关电子书