ReactiveCocoa(以下簡稱 RAC)是一個函數響應式編程框架,它讓我們得以擺脫 Cocoa API 的束縛,提供另一套編碼思路與可能性。它能在宏觀層面提升代碼的易讀性與穩定性,讓程序員寫出富有「詩意」的代碼,因而備受業內推崇。本文略過 RAC 的基本概念與基礎用法(部分技術點可參考美團點評技術博客此前的幾篇:RACSignal、冷信號與熱信號系列、內存洩漏),著重介紹 RAC 數據流方面的內容,剖析核心元素與 RAC Operation 在數據流中扮演的角色,並從數據流視角切入,介紹 RACCommand 與 RACChannel。
繪製 UI 時,我們常希望能直接拿到所需數據,但大多數情況下,數據得經過多道工序處理後才能使用——好比 UI 用到的數據是流水線加工後、從最後一端产出的成品。眾所周知,流水線由多段管線組成,上端管線的加工品成為下端管線的待加工品,每段管線都有對應的工人來完成加工,直至成品誕生。RAC 為我們提供了構建數據流水線的能力,通過組合不同的加工管線來導出想要的數據。要搭好 RAC 的數據流水線,先得認識流水線的組成元素——RAC 管線。RAC 管線的運作,實質上就是一個信號被訂閱的完整過程。下面我們來拆解一個完整的訂閱過程,並由此認識 RAC 的核心元素。
RAC 的核心是 Signal,對應類為 RACSignal。它其實是一個信號源,會給它的訂閱者(Subscriber)發送一連串事件。一個 Signal 可比作流水線的一段管線,負責決定傳輸什麼樣的數據。Subscriber 是 Signal 的訂閱者,比作管線上的工人,拿到數據後對其加工處理;加工後的數據要麼進入下一條管線繼續處理,要麼直接當成品使用。藉著「RAC 管線」這個比方,我們詳細看看 Signal 的完整訂閱過程:
管線的設計——createSignal:
RACSignal *pipeline = [RACSignal createSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@(1)];
[subscriber sendNext:@(2)];
[subscriber sendNext:@(3)];
[subscriber sendCompleted]; // (1)
return [RACDisposable disposableWithBlock:^{ // (2)
NSLog(@"the pipeline has sent 3 values, and has been stopped");
}];
}];這裡 RAC 通過類簇方式,用 RACSignal 的 createSignal 創建了一個 RACDynamicSignal 對象(RACSignal 的子類),同時傳入 didSubscribeBlock 參數。在這個 block 裡,我們定義了該 Signal 將按何種方式、發送何種信號值。如文中的 pipeline signal 在順序發出 1、2、3 三個數據後,發出結束信號 (1),並安排好信號終止訂閱時的收尾工作 (2)——這好比我們預先設計好一段管線,設定它啟動後按何種邏輯傳送何種數據。但管線送出待加工數據後,需要有工人加工,於是 RAC 引入了 Subscriber。
管線工人——Subscriber:
RACSubscriber *worker = [RACSubscriber subscriberWithNext:nextBlock error:errorBlock completed:completedBlock];
Subscriber 一般稱作訂閱者,負責處理 Signal 傳出的數據。初始化時會傳入 nextBlock、errorBlock、completeBlock,正是這三個 block 用來處理不同類型的數據信號,處理後的數據或被拋往下一段管線,或被當成品交給使用方。Subscriber 好比管線上的工人,負責加工傳過來的各種信號值;不過一旦它收到 error 或 complete 信號,就會通過相關的 RACDisposal 主動取消這次訂閱,停止管線運作。管線有了、工人也有了,怎麼啟動?
啟動管線——subscribe:
RACDisposable *disposable = [pipeline subscribe:worker]
通過 RACDynamicSignal 的 subscribe 方法,pipeline signal(RACSignal)開始被 worker(RACSubscriber)訂閱。在 subscribe 內部,pipeline 會執行 createSignal 時傳入的 didSubscribeBlock,過程遵循先前對管線的設定;worker 將收到 3 個數據值與一個 complete 信號,並用 nextBlock 與 completeBlock 分別處理。管線啟動後返回一個 RACDisposable 對象,外部可隨時通過 [RACDisposable dispose] 停止這段管線;一旦停止,worker 就不再處理任何數據。詳細剖析可參看 https://tech.meituan.com/RACSignalSubscription.html。
以上三步構成了一個普通信號的訂閱流程。但我們平時用 RAC 時往往看不到後兩者,因為 RAC 把 Subscriber 的初始化與 [signal subscribe: subscriber] 統一封裝進了 [signal subscribeNext: error: completed:],成功屏蔽了 Subscriber 這個概念,進一步簡化了訂閱邏輯(PS:流水線的 worker 永遠在默默付出)。

可以發現,按上述流程,信號只有被訂閱時才會送出信號值——這種信號稱作冷信號(cold signal)。既然有冷信號,就有與之對應的熱信號(hot signal)。冷信號好比只有給管線分配了工人,管線才會開啟;熱信號則是管線一旦創建,無論有沒有配套工人,都會開始運作,可隨時依外部條件送出數據。送出時,若管線上有工人,數據被加工處理;若沒有,數據就被拋棄。下面仍從訂閱步驟對比冷熱信號(熱信號對應類 RACSubject):
創建信號。與冷信號不同,RACSubject 創建後會維護一個訂閱者數組(subscribers),隨時存儲加入的 Subscriber。此外有別於 RACDynamicSignal,RACSubject 創建時並不設定輸出數據,而是通過實現協議,允許外部直接用 [RACSubject sendNext:] 隨時輸出數據。
創建訂閱者。此過程與冷信號完全相同,即提前準備好 nextBlock、errorBlock、completedBlock。
RACSubscriber *worker = [RACSubscriber subscriberWithNext:nextBlock error:errorBlock completed:completedBlock];
訂閱。RACSubject(熱信號)與 RACDynamicSignal(冷信號)內部都繼承自父類 RACSignal 的 subscribe,但實現截然不同。RACDynamicSignal 的 subscribe 會執行 createSignal 時準備好的 didSubscribeBlock,並把 subscriber 傳給它,讓其按既定方式處理數據;而熱信號 RACSubject 僅僅把 subscriber 加進訂閱者數組,別的什麼都不做。
- (void)sendNext:(id)value {
[self enumerateSubscribersUsingBlock:^(id subscriber) {
[subscriber sendNext:value]; // (1)
}];
}熱信號沒有提前規劃訂閱時信號的輸出,因而需要由外部控制何時輸出何種數據值,於是 RACSubject 實現了協議,向外提供 [RACSubject sendNext:]、[RACSubject sendError:]、[RACSubject sendComplete:] 等方法。以 sendNext 為例,每當調用 [RACSubject sendNext] 時,RACSubject 就會遍歷自己的 subscribers 數組,調用各元素的 sendNextBlock (1)。
以上是冷、熱信號在執行層面的異同。有時為了消除副作用或其他原因,我們需要把冷信號轉成熱信號,讓它具備熱信號特性,這時可以用 [RACDynamicSignal multicast: RACSubject]——其原理正是利用了 RACSubject 可隨時 sendNext 的特性。具體轉換可參見:https://tech.meituan.com/talk-about-reactivecocoas-cold-signal-and-hot-signal-part-3.html。此外,RACSubject 有個子類 RACReplaySubject,相較 RACSubject,它能用 valuesReceived 數組保存之前信號發出的數據;當信號被下一個 Subscriber 訂閱時,能按順序把保存的數據值傳給新 Subscriber。
這一節大致介紹了 RACDynamicSignal、RACSubject、RACSubscriber、RACDisposal 在訂閱過程中的角色。事實上,調度器 RACSchedule 也是 RAC 中非常重要的基礎元素。RAC 對它的定義是「schedule: control when and where the work the product」,它對 GCD 做了一層很薄的包裝,能夠:1. 讓 RACSignal 送出的信號值在線程間靈活穿梭;2. 延遲或周期執行 block 內容;3. 添加同步、異步任務,並能靈活取消異步添加的未執行任務。RACSchedule 的用法會在下文提到。
RAC 流水線由多段管線組合而成。上節講了單條管線的運作,這一節主要談:1. RAC 管線間的銜接——RAC Operation;2. RAC 信號流的構建。
RAC Operation 作為信號值的中轉站,會返回一個新信號 N。如下圖,RAC Operation 對原信號 O 傳出的值進行加工,並把處理好的數值作為新信號 N 的輸出——這好比把原管線數據加工後拋往一段新管線,而一條 RAC 流水線正是由形形色色的 RAC Operation 組合而成。RAC 提供了許多 RACSignal Operation 供我們使用,其中 [RACSignal bind:] 是信號變換的核心。因此剖析 RAC Operation 時,我們主要針對 bind 及其衍生出的 flattenMap、map、flatten 展開,隨後再把 RAC 流水線套用到一個具體業務需求上,詳解整段信號流的構建。

先解讀 bind 及其衍生的幾個 Operation:
(1) bind 會返回一個新信號 N。整體思路是對原信號 O 訂閱,每當 O 產生一個值,就將其轉變為一個中間信號 M,並馬上訂閱 M,最後把 M 的輸出作為新信號 N 的輸出。管線圖如下:

具體看源碼(為方便理解,去掉了 RACDisposable、@synchronized、@autoreleasepool 相關代碼)。當新信號 N 被外部訂閱時,會進入 N 的 didSubscribeBlock (1),隨後訂閱原信號 O (2);當 O 有值輸出後,就用 bind 傳入的 bindBlock 將其變換為中間信號 M (3),並馬上訂閱 M (4),最後把 M 的輸出作為新信號 N 的輸出 (5)。可以說 ReactiveCocoa 是依據 Monad 概念搭建起來的,而 bind 正是 monad 的重要實現函數。
- (RACSignal *)bind:(RACStreamBindBlock (^)(void))block {
return [RACSignal createSignal:^(id subscriber){ // (1)
RACStreamBindBlock bindingBlock = block();
[self subscribeNext:^(id x) { // (2)
BOOL stop = NO;
id middleSignal = bindingBlock(x, &stop); // (3)
if (middleSignal != nil) {
RACDisposable *disposable = [middleSignal subscribeNext:^(id x) { // (4)
[subscriber sendNext:x]; // (5)
} error:^(NSError *error) {
[subscriber sendError:error];
} completed:^{
[subscriber sendCompleted];
}];
}
} error:^(NSError *error) {
[subscriber sendError:error];
} completed:^{
[subscriber sendCompleted];
}];
return nil
}];
}看完代碼,再回到 bind 的管線圖。每當 original signal 送出一個紅球信號,bind 內部就生成一個對應的 middle signal:第一個 middle signal 送綠球,第二個送紫球,第三個送藍球。由於 bind 中中間信號的輸出直接作為新信號輸出,所以圖中 new signal 輸出的就是綠球、紫球、藍球——它相當於所有 middle signal 輸出值的集合。
(2) flattenMap 在 RAC 使用中較為常見。它其實是對 bind 的包裝,為 bind 提供 bindBlock,因此二者實質相同(管線圖可參考 bind),都是把原信號傳出的值 map 成中間信號、馬上訂閱,再將中間信號輸出作為新信號輸出。不過 flattenMap 在 bindBlock 基礎上加了安全檢查 (1),所以更推薦用 flattenMap 而非 bind。
- (instancetype)flattenMap:(RACStream *(^)(id value))block {
Class class = self.class;
return [self bind:^{
return ^(id value, BOOL *stop) {
id stream = block(value) ?: [class empty];
NSCAssert([stream isKindOfClass:RACStream.class], @"Value returned from -flattenMap: is not a stream: %@", stream); // (1)
return stream;
};
}];
}(3) map 可把原信號輸出的數據通過自定義方法轉換成所需數據,並把變化後的數據作為新信號輸出。它實際調用了 flattenMap,只是中間信號直接返回 mapBlock 處理的值 (1)。此外,我們常用的 filter 內部也用了 flattenMap——同樣是把 filter 後的結果用中間信號包裝並訂閱,再把中間信號輸出作為新信號輸出,以此達到輸出 filter 結果的目的。
- (instancetype)map:(id(^)(id value))block {
Class class = self.class;
return [self flattenMap:^(id value) {
return [class return:block(value)]; // (1)
}];
}
(4) flatten 主要作用於「信號的信號」。原信號 O 作為信號的信號,被訂閱時輸出的數據必然也是個信號(signalValue),這往往不是我們想要的。當執行 [O flatten] 時,因為 flatten 內部調用了 flattenMap (1),其中間信號就是原信號 O 輸出的 signalValue (2)。依前面的經驗,flattenMap 中新信號 N 的輸出就是各中間信號 M 輸出的集合,因此 flatten 後新信號 N 被訂閱時輸出的值,就是原信號 O 各子信號輸出值的集合——好比把多管線匯聚成單管線,將原信號「壓平」。

代碼如下:
- (instancetype)flatten {
return [self flattenMap:^(RACSignal *signalValue){ // (1)
return [signalValue]; // (2)
}];
}(5) switchToLatest 與 flatten 相同,也是為了「壓平」信號的信號。但不同的是:flatten 是在多管線匯聚後,把原信號 O 各子信號的輸出作為新信號 N 輸出;而 switchToLatest 僅把 O 輸出的最新信號 L 的輸出作為 N 輸出。管線圖如下:

看代碼:當 O 送出信號 A 後,新信號 N 會馬上訂閱 A,但這裡用了 [A takeUntil: O] (1)。意思是,如果之後 O 又送出子信號 B,那麼 N 對 A 的訂閱就停止;若 O 再送出 C,N 又會停止對 B 的訂閱。也就是說,N 訂閱的永遠是 O 派送的最新信號。
- (RACSignal*)switchToLatest {
return [RACSignal createSignal:^(id subscriber) {
RACMulticastConnection *connection = [self publish];
[[connection.signal flattenMap:^(RACSignal *signalValue) {
return [signalValue takeUntil:[connection.signal concat:[RACSignal never]]]; // (1)
}] subscribe:subscriber];
RACDisposable *connectionDisposable = [connection connect];
return [RACDisposable disposableWithBlock:^{
}];
}];
}另外作為鋪墊,這裡再提兩個操作:
(6) scanWithStart 可把上次 reduceBlock 處理後的結果作為參數傳入當次 reduceBlock,常用於信號輸出值的聚合處理。scanWithStart 內部仍用到核心操作 bind:它在 bindBlock 中對 value 操作,並把上次的結果 running 作為參數帶入 (1);一旦本次 reduceBlock 執行完,就把結果存進 running 供下次使用,最後再把本次結果用信號包裝後傳出去 (2)。

代碼如下:
- (instancetype)scanWithStart:(id)startingValue reduceWithIndex:(id(^)(id,id,NSUInteger))reduceBlock {
Class class = self.class;
return [self bind:^{
__block id running = startingValue;
__block NSUInteger index = 0;
return ^(id value, BOOL *stop) {
running = reduceBlock(running, value, index++); // (1)
return [class return:running]; // (2)
};
}];
}(7) throttle 接收一個時間間隔 interval 作為參數:若 Signal 發出 next 事件後,interval 時間內不再發出 next,那麼它返回的 Signal 會把這個 next 事件發出。也就是說,它會捨棄發送頻繁的 next 事件,只保留一段「靜默」時間之前的那個 next 事件。這個操作常用於處理輸入框等信號(用戶打字很快),因為它只保留用戶最後輸入的文字並返回新 Signal,把最後文字作為 next 事件參數發出。管線流圖如下:

前面從代碼層面具體剖析了幾個 RAC Operation。接著我們借一個具體需求,把這些管線拼成一條數據流。假設一個搜索業務:用戶在 searchBar 輸入文本,停止輸入超過 0.3 秒後,認為 searchBar 內容就是用戶的意向搜索關鍵字 searchKey,以它為參數執行搜索。搜索內容多樣,可能包括單聊消息、群聊消息、公眾號消息、聯系人等,來源與方式各異——有的從本地取,有的去服務器查,返回速度參差不齊。我們不能等全部數據到手才顯示結果頁,而應有部分數據返回就拋到主線程渲染。這個需求從數據輸入到最後顯示,可具象成一條數據流,各處對數據的操作都能用上面提到的 RAC Operation 完成。組合後的數據流圖如下:

從數據流圖來看,RAC 有點像太極:太極生兩儀,兩儀生四象,四象生八卦,八卦生萬物。我們能用它的百變性去契合產品的業務需求。按圖,可以輕易寫出對應代碼:
[[[self.searchBar rac_textSignal] throttle:0.3] subscribeNext:^(NSString *keyString) {
RACSignal *searchSignal = [self.viewModel createSearchSignalWithString:keyString];
[[[searchSignal
scanWithStart:[NSMutableArray array] reduce:^NSMutableArray *(NSMutableArray *running, NSArray *next) {
[running addObjectsFromArray:next];
return running;
}]
deliverOnMainThread]
subscribeNext:^(id x) {
// UI Processing
}];
}];可以看到,用 RAC 構建數據流後,聲明式代碼顯得優雅而清晰易讀,看似複雜的業務需求,一兩句代碼就輕鬆搞定。反觀常規做法,光一個 throttle 對應的操作就可能讓邏輯代碼散落各處,另一個 scanWithStart 也得引入不少中間變量,無疑大大抬高了維護成本。數據流的設計會讓編碼者感覺自己更像代碼的設計者,而非搬運工,讓人樂此不疲。
本節先從源碼層級剖析了幾個 RAC Operation,相信理解了這些 Operation 的信號銜接細節後,閱讀其他 Operation 都不再是難事。之後用 RAC 數據流處理了一個具體業務。事實上 RAC 提供了極其豐富的操作,通過組合基本能應對日常業務邏輯。當然需求多樣而奇特,或許特定場景下找不到現成的 RAC Operation,那麼有需要時,我們也可以直接擴展 RACSignal 操作或添加自定義 UIKit 的 RAC 擴展,讓代碼「more functional, more elegant」。可以毫不誇張地說,阻礙 RAC 發揮的瓶頸只有想象力:接到需求後,仔細推敲數據走向、設計好相關操作,只要把數據流圖繪出來,剩下的代碼工作也就信手拈來。
介紹完 RAC 數據流後,我們再從數據流角度看看 RAC 的另外兩個常用元素:RACCommand 與 RACChannel。
RACCommand 是 RAC 很重要的組成部分,通常用來表示某個 action 的執行。它提供 executionSignals、executing、error 等一連串公開信號,方便外界觀察 action 的執行過程與結果。executionSignals 是 signal of signals,若直接訂閱它,得到的是當前執行的信號而非執行信號輸出的數據,所以一般配合 flatten 或 switchToLatest 使用。errors:RACCommand 的錯誤並非通過 sendError 實現,而是通過 errors 屬性傳遞出來。executing:表示該 command 當前是否正在執行。它常用於監聽按鈕點擊、網絡請求等。
使用時,我們通常生成一個 RACCommand 對象,並傳入一個返回 signal 的 block。每次 RACCommand execute 執行時,都會通過傳入的 signal block 生成一個執行信號 E (1),並把它加入 RACCommand 內部的 activeExecutionSignals 數組 (2),同時把信號 E 由冷信號轉成熱信號 (3),最後訂閱該熱信號 (4) 並返回 (5)。
- (RACSignal *)execute:(id)input {
RACSignal *signal = self.signalBlock(input); // (1)
RACMulticastConnection *connection = [[signal
subscribeOn:RACScheduler.mainThreadScheduler]
multicast:[RACReplaySubject subject]]; // (3)
@weakify(self);
[self addActiveExecutionSignal:connection.signal]; // (2)
[connection.signal subscribeError:^(NSError *error) {
@strongify(self);
[self removeActiveExecutionSignal:connection.signal];
} completed:^{
@strongify(self);
[self removeActiveExecutionSignal:connection.signal];
}];
[connection connect]; // (4)
return [connection.signal]; // (5)
}那 RACCommand 又是如何監控執行過程的呢?

如上圖,RACCommand 內部維護了一個 activeExecutionSignals 數組。前面提到,每當 [RACCommand execute:] 後,就會把一個執行信號加入該數組。RACCommand 設置了兩個對 activeExecutionSignals 的觀察信號。第一個用於監控 RACCommand 是否正在執行(參考上圖下端數據流):activeExecutionSignals 是內部執行信號的合集,一旦其元素變化,就根據執行信號數量判斷 RACCommand 當前是否正在執行 (1)。
RACSignal *immediateExecuting = [RACObserve(self, activeExecutionSignals) map:^(NSArray *activeSignals) {
return @(activeSignals.count > 0); // (1)
}];
_executing = [[[[immediateExecuting deliverOn:RACScheduler.mainThreadScheduler] startWith:@NO] distinctUntilChanged] replayLast];第二個觀察信號用於監控當前正在執行的信號及其產生的 error(參考上圖上端數據流)。每當 activeExecutionSignals 有新執行信號加入,newActiveExecutionSignals 就有相應信號輸出(它輸出的是信號,因此是信號的信號)。由於 newActiveExecutionSignals 之後要轉成 executionSignals、error 信號並分別被外界訂閱,為避免產生多餘副作用,這裡用 publish 把 activeExecutionSignals 對應的觀察信號由冷信號轉成熱信號 (1),之後 executionSignals 把 newActiveExecutionSignals 的輸出值拋到主線程 (2)。當我們訂閱 executionSignals 時,拿到的就是當前正在執行的信號;若關心的是當前執行信號的輸出值,得用 [executionSignals flatten] 把它「壓平」後才能拿到所有輸出值。
RACSignal *newActiveExecutionSignals = [[[[[self rac_valuesAndChangesForKeyPath:@keypath(self.activeExecutionSignals) options:NSKeyValueObservingOptionNew observer:nil] reduceEach:^(id _, NSDictionary *change) {
NSArray *signals = change[NSKeyValueChangeNewKey];
return [signals.rac_sequence signalWithScheduler:RACScheduler.immediateScheduler];
}] concat] publish] // (1)
autoconnect];
_executionSignals = [[newActiveExecutionSignals map:^(RACSignal *signal) {
return [signal catchTo:[RACSignal empty]];
}] deliverOn:RACScheduler.mainThreadScheduler]; // (2)同時,若執行信號拋出錯誤,newActiveExecutionSignals 會通過 flattenMap 直接將錯誤包裝成錯誤信號拋往主線程並通知訂閱者。
RACMulticastConnection *errorsConnection = [[[newActiveExecutionSignals flattenMap:^(RACSignal *signal) {
return [[signal
ignoreValues]
catch:^(NSError *error) {
return [RACSignal return:error];
}];
}] deliverOn:RACScheduler.mainThreadScheduler] publish];
_errors = [errorsConnection.signal setNameWithFormat:@"%@ -errors", self];
[errorsConnection connect];因此,RACCommand 主要是對成員變量 activeExecutionSignals 數組的變化進行觀察,並把觀察結果轉變成外部感興趣的信號,從而使 RACCommand 的執行過程與結果可被外部監控。我們常把 RACCommand 與 UI 響應配合使用,比如按鈕被點擊後執行一個網絡請求的 command:可以通過 command.executing 信號決定是否彈小菊花,通過 command.executionSignals 拿到當前執行的信號並得到結果,也能從 command.error 信號裡取出要反饋給用戶的錯誤提示,使用起來十分方便。
RACChannel 相對陌生,但它同樣能在信號流中扮演重要角色。它提供雙向綁定功能,一個 RACChannel 的兩端各配一個 RACChannelTerminal,分別是 leadingT 和 followingT。我們可以把二者想象成一根水管的兩頭:只要任一端輸入信號值,另一端都會輸出相同的信號值。有了這個概念,再來看 RACChannelTerminal。首先:
@interface RACChannelTerminal : RACSignal
可以看到,RACChannelTerminal 因繼承了 RACSignal 而具備信號特性,可被訂閱。比如在 RACChannel 中 [leadingT subscribeNext:],此時 leadingT 扮演 signal 的角色,被訂閱時輸出的就是 followingT 送出的值。同時 RACChannelTerminal 又實現了 RACSubscriber 協議,這意味著它也能像訂閱者一樣調用 sendNext:、sendError:、sendComplete 方法。如果 followingT 被訂閱了,那麼一旦 leadingT sendNext:value,信號值 value 就會穿過 leadingT 與 followingT,被 followingT 的訂閱者捕獲。正因 RACChannelTerminal 具備這種「既可被訂閱、又可主動輸出信號值」的屬性,當它被放到 RACChannel 兩端時,就能讓兩端信號相互影響。
通常我們很少直接用 RACChannel,最常用的是 RACChannelTo,下面詳細了解:

借著上面的 RACChannelTo 數據流圖,我們拿 RAC 提供的示例代碼舉例。RACChannelTo 宏實際生成了一個 RACKVOChannel,它內部把一端的 leadingT 與相關 keypath 上的 integerProperty 綁定,並把另一端 followingT(對應示例代碼中的 integerChannelT)暴露出來。當我們拿到 integerChannelT 後,用 [integerChannelT sendNext:@5] (1),信號值就會傳到 RACKVOChannel 的另一端,影響 integerProperty(參考圖中紅色管線);同時當 integerChannelT 被訂閱時,只要另一端 integerProperty 變化產生對應信號值 A,integerChannelT 就會把 A 傳給它的訂閱者(參考圖中藍色管線)。
RACChannelTerminal *integerChannelT = RACChannelTo(self, integerProperty, @42);
[integerChannelT sendNext:@5]; // (1)
[integerChannelT subscribeNext:^(id value) { // (2)
NSLog(@"value: %@", value);
}];
事實上,RAC 為很多類提供了 RACChannel 相關擴展,如:
[NSUserDefaults rac_channelTerminalForKey:]
[UIDatePicker rac_newDateChannelWithNilValue:]
[UISegmentedControl rac_newSelectedSegmentIndexChannelWithNilValue:]
[UISlider rac_newValueChannelWithNilValue:]
[UITextField rac_newTextChannel:]
這些函數都會返回一個對應的 RACChannelTerminal。有了它,一方面我們能觀察對應控件內核心變量的變化並作出響應,另一方面也能直接改變控件裡的核心變量。比如我們可以用 [UITextField rac_newTextChannel:] 返回的 RACChannelTerminal,實現控件與 viewModel 中數據的雙向綁定:
RACChannelTerminal *textFieldChannelT = textField.rac_newTextChannel;
RAC(self.viewModel, property) = textFieldChannelT;
[RACObserve(self.viewModel, property) subscribe:textFieldChannelT];
整體而言,RACChannelTerminal 用起來十分順手,只要契合業務,RACChannel 就能提供巨大價值。
本文從源碼層面剖析了 RAC 信號的訂閱過程,介紹了各核心元素在其中的角色,之後著重講解 RAC 數據流的構建與使用價值。文中沒有對所有 RAC Operation 做覆蓋式介紹,而是挑出幾個重要的,借助源碼與數據流圖闡明其內部運作細節,希望能從底層闡述構建原理,幫助大家更好地理解和運用 RAC。正如一句老話所說:「開車不需要知道離合器是怎麼工作的,但如果知道原理,車子能開得更平穩。」