RxSwift（3.4.1）- Connectable Observable

来源：互联网发布：c语言从入门到放弃图片编辑：程序博客网时间：2024/06/07 07:47

Connectable Observable

可连接的观察者序列（Connectable observables）是观察者序列中特殊的一个类。不管订阅者的数量多少，他们并不会发送任何的元素，一直到你调用观察者序列的connect()方法。记住：对于一些操作符，如果返回 ConnectableObservable<E>而不是Observable<E>，那么就需要执行调用connect()方法。这些操作符号有：

 replay(_:) replayAll() multicast(_:) publish()

publish()

publish()将一个普通序列转换成Connectable Observable序列.

    let intSequence = Observable<Int>                          .interval(1, scheduler: MainScheduler.instance)                          .publish()        _ = intSequence            .subscribe(onNext: { print("Subscription 1:, Event: \($0)") })                delay(2) {           print("-----2-----")         _ = intSequence.connect() }                delay(4) {             print("-----4-----")            _ = intSequence                .subscribe(onNext: { print("Subscription 2:, Event: \($0)") })        }                delay(6) {             print("-----6-----")            _ = intSequence                .subscribe(onNext: { print("Subscription 3:, Event: \($0)") })        }

执行结果：

-----2-----

Subscription 1:, Event: 0

-----4-----

Subscription 1:, Event: 1

Subscription 2:, Event: 1

Subscription 1:, Event: 2

Subscription 2:, Event: 2

-----6-----

Subscription 1:, Event: 3

Subscription 2:, Event: 3

Subscription 3:, Event: 3

由结果可知，在订阅观察者序列之后并没有发送事件，一直到调用connect()方法，connect()方法将激活可连接的观察者序列（connectable observable），并且连接的观察者序列发送事件给所有的订阅者。所以得到以上结果

当序列发送元素之后，你将经常需要确保将来的新的订阅者接受一些或者所有过去的元素。这时候我们就需要replay(_:)和replayAll()这两个操作符。确保所有的订阅者都能够获得相同的观察者序列发送的元素，即使是在观察者序列已经开发发送元素之后开始订阅的。

Replay Operator

Replay operator创建了一个新的观察者序列，根据缓存值的大小，用来记录由源观察者序列最后发送的几个元素。每一次新的观察者进行订阅，它将立马接受到缓冲中的元素（如果缓冲中有内容），而且保持接受最新的元素。就像一个正常的订阅者一样。返回的是可连接的观察者序列（connectable observable）

   let intSequence = Observable<Int>                          .interval(1, scheduler: MainScheduler.instance)                          .replay(1)                _ = intSequence            .subscribe(onNext: { print("Subscription 1:, Event: \($0)") })                delay(2) {            print("-----2-----")            _ = intSequence.connect()        }        delay(4) {            print("-----4-----")            _ = intSequence                .subscribe(onNext: { print("Subscription 2:, Event: \($0)") })        }        delay(6) {            print("-----6-----")            _ = intSequence                .subscribe(onNext: { print("Subscription 3:, Event: \($0)") })        }

执行结果：

-----2-----

Subscription 1:, Event: 0

-----4-----

Subscription 2:, Event: 0

Subscription 1:, Event: 1

Subscription 2:, Event: 1

Subscription 1:, Event: 2

Subscription 2:, Event: 2

-----6-----

Subscription 3:, Event: 2

Subscription 1:, Event: 3

Subscription 2:, Event: 3

Subscription 3:, Event: 3

注意：

1：由于replay创建了一个可连接的观察者序列（connectable observable），所以你需要通过connect()方法连接它和潜在的源观察者并开始接受元素（事件），如果你忘记了这一点，订阅者（观察者）将从未接受任何事件。

2: 如果你在观察者序列转换到可连接观察者序列之前使用Replay操作符，那么connectable observable将经常发送相同的完整序列给新的订阅者（observers），即使所有的订阅者是在可连接观察者序列已经开始发送元素之后订阅的，也会接受相同的序列。更多详情

ReplayAll Operator

一旦有新的订阅者将立马发送缓冲中的元素.这个操作符使用需要注意：使用的情景是你需要知道全部的缓冲元素的个数并且将保持合理化。使用replayAll()在序列中，可能不会终止而且产生许多的数据将迅速的阻塞你的内存。

     let intSequence = Observable<Int>                          .interval(1, scheduler: MainScheduler.instance)                          .replayAll()                _ = intSequence            .subscribe(onNext: { print("Subscription 1:, Event: \($0)") })        delay(2) {            print("-----2-----")            _ = intSequence.connect()        }                delay(4) {            print("-----4-----")            _ = intSequence                .subscribe(onNext: { print("Subscription 2:, Event: \($0)") })        }                delay(6) {            print("-----6-----")            _ = intSequence                .subscribe(onNext: { print("Subscription 3:, Event: \($0)") })        }

执行结果

-----2-----

Subscription 1:, Event: 0

Subscription 1:, Event: 1

-----4-----

Subscription 2:, Event: 0

Subscription 2:, Event: 1

Subscription 1:, Event: 2

Subscription 2:, Event: 2

Subscription 1:, Event: 3

Subscription 2:, Event: 3

-----6-----

Subscription 3:, Event: 0

Subscription 3:, Event: 1

Subscription 3:, Event: 2

Subscription 3:, Event: 3

Subscription 1:, Event: 4

Subscription 2:, Event: 4

Subscription 3:, Event: 4

先取缓存元素，再产生新事件。

Multicast Operator

将一个正常的sequence转换成一个connectable sequence，并且通过具体的subject发送出去，比如PublishSubject，或者replaySubject，behaviorSubject等，不同的Subject会有不同的结果(Converts the source Observable sequence into a connectable sequence, and broadcasts its emissions via the specified subject.)

      let subject = PublishSubject<Int>()                _ = subject            .subscribe(onNext: { print("Subject: \($0)") })                let intSequence = Observable<Int>                          .interval(1, scheduler: MainScheduler.instance)                          .multicast(subject)                _ = intSequence            .subscribe(onNext: { print("\tSubscription 1:, Event: \($0)") })                delay(2) {             print("-----2-----")            _ = intSequence.connect()        }                delay(4) {            print("-----4-----")            _ = intSequence                .subscribe(onNext: { print("\tSubscription 2:, Event: \($0)") })        }                delay(6) {            print("-----6-----")            _ = intSequence                .subscribe(onNext: { print("\tSubscription 3:, Event: \($0)") })        }

执行结果

-----2-----

Subject: 0

Subscription 1:, Event: 0

-----4-----

Subject: 1

Subscription 1:, Event: 1

Subscription 2:, Event: 1

Subject: 2

Subscription 1:, Event: 2

Subscription 2:, Event: 2

-----6-----