所有文章

RxSwift 探索之旅 · 03

Subject、Relay 與使用時機

PublishSubject、BehaviorSubject、ReplaySubject 與 Relay 的差異,已棄用的 Variable,以及過度使用 Subject 的問題。

本篇目錄 · 14 個章節

Subject

接著介紹一個既是Observable又是Observer的東西,叫做Subject。

什麼是Subject?

如同前面介紹,他同時是Observable跟Observer,這是什麼意思呢?讓我們直接從程式碼認識它,Subject有很多種,這裡先以PublishSubject做範例,其餘類型在下一節介紹

// 1
let subject = PublishSubject<Int>()
// 2
subject
.subscribe(onNext: {
print($0)
})
.disposed(by: disposeBag)
// 3
subject.onNext(1)
subject.onNext(2)
subject.onNext(3)

執行結果

1
2
3
Completed
  1. 這是建構一個PublishSubject,跟建構一個物件一樣簡單,他有一個泛型參數,代表它能接收跟發送的類型,我們這邊就是帶入<Int>。
  2. Subject可以發送元素給他的訂閱者,這時Subject作為一個Observable的角色,所以也可以寫成
subject.asObservable()
.subscribe(onNext: {
print($0)
})
.disposed(by: disposeBag)
  1. Subject 可以接收.next, .completed, .error事件,所以,subject.onNext(1)表示,『Subject接收到數字1』,這也表示,這時的Subject作為一個Observer的角色,所以也可以寫成subject.asObserver().onNext(1)

順帶一提,PublishSubject最一開始會是空的,你要先訂閱,才能收到往後發出的新元素,就像是你向報商訂雜誌,你會從下一期才能得到雜誌,這也是為什麼上面範例會先訂閱再發送,大家可以嘗試把訂閱的程式碼往後搬到.onNext()後面,他就印不出數字了。

使用情境

再複習一次,Subject的特性是『它接收到.next事件後,可以再發送給它的訂閱者』,這很適合作為一個中間者的角色,可以用於接收資訊,在發送給訂閱者,下面我們來看看一個範例。

建立一個Subject來接收按鈕的點擊事件,接這在把訊息發送給Observer 1跟Observer 2;以圖示表示,就會像下面這張圖這樣,藍色代表訂閱,紅色代表發送事件,另外,為了表示在不同時間點訂閱,會收到不同的訊息,我刻意將observer 1跟2在不同時間點訂閱。

寫成程式碼大概會像這樣

let subject = PublishSubject<Void>()
// 1
button.rx.tap
.subscribe(onNext: { _ in
print("=== A Tap ===")
subject.onNext(())
})
.disposed(by: disposeBag)
// 2
delay(2) {
subject
.subscribe(onNext: {
print("B Tap")
})
.disposed(by: self.disposeBag)
}
// 3
delay(4) {
subject
.subscribe(onNext: {
print("C Tap")
})
.disposed(by: self.disposeBag)
}

執行結果

=== A Tap ===
=== A Tap ===
B Tap
=== A Tap ===
B Tap
C Tap
  1. 程式一開始執行,點擊按鈕只會得到A
  2. 過兩秒再點按鈕,會得到AB,因為此時subject被訂閱第一次了
  3. 過兩秒再點按鈕,會得到ABC,因為此時已經訂閱第二次了

補充 在subject在訂閱前,可以看到多一句delay,是因為要表現出延遲的效果,這裡意思就是說『2秒後進行再訂閱』,這邊我把它封裝起來,原本程式碼長這樣

func delay(_ delayTime: Double, _ closure: @escaping () -> Void) {
DispatchQueue.main.asyncAfter(deadline: .now() + delayTime) {
closure()
}
}

UIKit Extension

上面範例看到button.rx.tap,這是RxSwift對UIButton的事件封裝,像這邊就是對TouchUpInside事件的封裝,簡單來說,就是把非Rx的元件,經由封裝變成Rx,進入Rx世界後,我們就可以方便的使用各種transform、filter…等。

基本上大多數UIKit都有這樣的extension,要怎麼查到封裝實際上做了些什麼,其實很簡單,方法有兩個:

  1. 在 Xcode 按著『option』對著 tap 按一下,就能看到解釋 『Reactive wrapper for TouchUpInside control event.』
  2. 在 Xcode 按著『cmd + shift + o』,輸入UIButton+Rx,就可以看到source code,你就會發現不只tap,連title、image、backgroundImage…等都可以使用,有興趣的各位可以玩玩看

Subject還有其他兄弟姐妹,共有6種,看起來很多,但仔細看就會發現差不多那幾個字組合而已,Relay則在下一節說明。

  • PublishSubject
  • BehaviorSubject
  • ReplaySubject
  • AsyncSubject(這很少用到,就不提了)
  • PublishRelay
  • BehaviorRelay

PublishSubject

前面有稍微提到,PublishSubject定義『開始是空的,只會發送新的元素給訂閱者』,畫成圖會像下面這樣,訂閱者在數字1之後訂閱,只能等到再次發送數字2,才可以收到。

寫成程式碼如下,大家可以執行看看

let subject = PublishSubject<String>()
subject.onNext("1")
// 1, 2
subject
.debug("A")
.subscribe()
.disposed(by: disposeBag)
subject.onNext("2")
subject.onNext("3")
subject
.debug("B")
.subscribe()
.disposed(by: disposeBag)
// 3
subject.onError(NSError(domain: "Test", code: -1, userInfo: nil))

執行結果如下

A -> subscribed
A -> Event next(2)
A -> Event next(3)
B -> subscribed
A -> Event error(Error Domain=Test Code=-1 "(null)")
Unhandled error happened: Error Domain=Test Code=-1 "(null)"
A -> isDisposed
B -> Event error(Error Domain=Test Code=-1 "(null)")
Unhandled error happened: Error Domain=Test Code=-1 "(null)"
B -> isDisposed
  1. 我這邊不在用.subscribe(onNext, onError),而是改用.debug(),.debug()顧名思義是在除錯時候使用,他可以把訂閱的開始到結束都印出來,帶入的String代表他的名稱,實際使用上可以使用emoji,視覺上圖片比文字能更快速辨認(但it邦好像不能使用emoji…,這裡替換成數字跟英文字母)
  2. 因為我只是想列印,並沒有要處理任何事件,但如果Obsevable沒有訂閱者的話,它是不會發送任何元素的,所以這邊我們就寫.subscribe()就好。
  3. 因為B比較晚訂閱,所以他收不到前面的元素,又因為收到.error而disposed。

BehaviorSubject

如果你要一訂閱就拿到上一次的值,可以使用BehaviorSubject,它定義是這樣的『開始是預設值,發送目前的最後一個值給訂閱者』,也就是說你不管什麼時候訂閱,都會有元素可以收到(至少有預設值)。

寫成程式碼如下,在建構BehaviorSubject需要再多給一個預設值

let subject = BehaviorSubject<String>(value: "1")
subject
.debug("A")
.subscribe()
.disposed(by: disposeBag)
subject.onNext("2")
// 2
print("Subject value: \(try! subject.value())")
subject.onNext("3")
subject.onError(NSError(domain: "Test", code: -1, userInfo: nil))
subject
.debug("B")
.subscribe()
.disposed(by: disposeBag)
// 3
print("Subject value: \(try! subject.value())")

執行結果如下

A -> subscribed
A -> Event next(1)
A -> Event next(2)
Subject value: 2
A -> Event next(3)
A -> Event error(Error Domain=Test Code=-1 "(null)")
Unhandled error happened: Error Domain=Test Code=-1 "(null)"
A -> isDisposed
B -> subscribed
B -> Event error(Error Domain=Test Code=-1 "(null)")
Unhandled error happened: Error Domain=Test Code=-1 "(null)"
B -> isDisposed
Fatal error: 'try!' expression unexpectedly raised an error: Error
  1. Behavior多了.value()這個func可以使用,他可以取的目前最新的元素,考慮到有Observable可能是.error或是disposed,所以會throws RxError,這邊使用try!單純只是作為範例展示。
  2. B在.error 訂閱,你收到的不是.next(3),因為現在最後一個元素是.error哦!
  3. Subject value:在第一次會收到.next(2),第二次因為收到.error而throws錯誤

ReplaySubject

如果你要一訂閱就拿到上n次的值,那你要選擇ReplaySubject,它定義是『開始時給訂一個暫存大小(buffer size),發送時會將最後的n個元素存進暫存,並將暫存的元素發給訂閱者』,下圖就是以bufferSize = 2 的情況。

寫成程式碼如下,建構時需要給定bufferSize

let subject = ReplaySubject<String>.create(bufferSize: 2)
subject.onNext("1")
subject.onNext("2")
subject.onNext("3")
// 1
subject
.debug("A")
.subscribe()
.disposed(by: disposeBag)
subject.onNext("4")
subject.onNext("5")
subject.onError(NSError(domain: "Test", code: -1, userInfo: nil))
// 2
subject
.debug("B")
.subscribe()
.disposed(by: disposeBag)

執行結果如下

A -> subscribed
A -> Event next(2)
A -> Event next(3)
A -> Event next(4)
A -> Event next(5)
A -> Event error(Error Domain=Test Code=-1 "(null)")
Unhandled error happened: Error Domain=Test Code=-1 "(null)"
A -> isDisposed
B -> subscribed
B -> Event next(4)
B -> Event next(5)
B -> Event error(Error Domain=Test Code=-1 "(null)")
Unhandled error happened: Error Domain=Test Code=-1 "(null)"
B -> isDisposed
  1. A訂閱的時機點是在3之後,這時buffer存了2和3,所以他會從2開始接收。
  2. B訂閱時間點,他除了接收到buffer中元素,如果Observable已經結束,還會在收到.error(或 .completed),所以這裡才是接收到4、5和.error,這是跟前面兩種Subject比較不同的。

Relay

接著介紹跟Subject很像的Relay,它也算是Subject的一種。

PublishRelay

定義『只接受.next事件,不接受.error或.completed』,換句話說,它不會中斷,從source code來看,PublishRelay其實就是PublishSubject再包一層,因為只能接收.next,所以語法變成.accept了。

public func accept(_ event: Element) {
self._subject.onNext(event)
}

看一下範例程式

let subject = PublishRelay<String>()
subject.accept("1")
subject
.debug("A")
.subscribe()
.disposed(by: disposeBag)
subject.accept("2")
subject.accept("3")

執行結果如下,是不是跟PublishSubject很像呢!

A -> subscribed
A -> Event next(2)
A -> Event next(3)

BehaviorRelay

定義的部分跟PublishRelay一樣,BehaviorRelay就是BehaviorSubject的封裝,跟BehaviorSubject一樣有.value()可以使用,但因為Relay不會.error或disposed的問題,自然也不用處理意外狀況。

範例程式如下

let subject = BehaviorRelay<String>(value: "1")
subject
.debug("A")
.subscribe()
.disposed(by: disposeBag)
subject.accept("2")
print(“Relay value: \(subject.value)”)

執行結果如下

A -> subscribed
A -> Event next(1)
A -> Event next(2)
Relay value: 2

怎麼沒有ReplayRelay

不知道有沒有人跟我一樣好奇,怎麼沒看到ReplayRelay,於是我找到這篇 Add ReplayRelay by lordzsolt · Pull Request #2111 · ReactiveX/RxSwift · GitHub 有興趣的人可以細看大神討論內容,結論就是目前已經合併到develop了,就看什麼時候release囉!

編按(2026):後來 RxSwift 6.0 已加入 ReplayRelay。

Variable(已棄用)

Variable如同他名字一樣,可以透過setting和getting去改變或是取得現在的值,就跟一般的變數沒兩樣,這顯然跟第一篇說的Rx世界有點違背。

所以在5.x版已被棄用,擷取Shai Mishali大神所說,這是RxSwift早期為了讓大家可以從Imperative到Rx的一個過渡期,一個好意但卻被濫用,導致初衷不在,為了阻止這一切,從4.x版開始警告,也在5.x版正式棄用,且建議以 BehaviorRelay或BehaviorSubject代替。

淺談使用時機

Relay在某些情況很好用,比如說在非Rx跟Rx之間的轉換,又或是說,Imperative世界與Rx世界的橋樑,假設像下方這樣

let image = BehaviorRelay<[UIImage]>(value: [])
// 把一組圖片轉成Rx
image.accept(images)
// 清空image
image.accept([])
// 新增一張圖片
var current = image.value
current.append(newImage)
image.accept(current)

過度使用Subject

Erik Meijer是一個對Rx有莫大貢獻的大神,在網路上能找到許多關於他的影片跟文章,他曾經說過

Subjects are the “mutable variables” of the Rx world and in most cases you do not need them. – Erik Meijer

大意就是說,Subjects是個可變的變數,當你使用Subject或Relay請確定是不是真的需要它,這其他文章也可以看到類似討論 Why Does E.Meijer not like Subjects? 跟 Top mistakes in RxSwift you want to avoid - Code in a suit。

在第一篇提過,Rx世界是Stateless,所有東西就是input跟output,大多數情況都可以用.create搭配其他operator解決,但因為Subject跟Relay太好用了,剛開始我們常常會這樣

Observable
.subscribe(onNext: {
observerA.onNext(...)
observerB.onNext(...)
observerC.onNext(...)
})
.disposed(by: disposeBag)

或是

relay.accept(a)
relay.accept(b)
relay.accept(c)

你會發現,Subject在同個class或是不同class被到處被onNext(),Relay被到處.accept(),這樣我們又回到Imperative思維,並且在Imperative上包一層的感覺,反而更不舒服,寫久了會很亂,也會常常出錯。

我自己在不得已的時候還是會用,但要『切記做好封裝』,封裝成class,對內設為private,想怎麼用都可以,對外是Observable,給外部使用,大概會像這樣

private let imageRelay = BehaviorRelay<[UIImage]>(value: [])
private(set) lazy var image = imageRelay.asObservable()

或是這樣

let image: Observable<[UIImage]>
init() {
let imageRelay = BehaviorRelay<[UIImage]>(value: [])
image = imageRelay.asObservable()
}