RAC使用測試Demo下載：github.com/FuWees/WPRACTestDemo
1.ReactiveCocoa簡介
ReactiveCocoa（簡稱為RAC）,是由Github開源的一個應用于iOS和OS開發(fā)的新框架,Cocoa是蘋果整套框架的簡稱，因此很多蘋果框架喜歡以Cocoa結尾。
2.ReactiveCocoa作用
ReactiveCocoa為事件提供了很多處理方法，而且利用RAC處理事件很方便，可以把要處理的事情，和監(jiān)聽的事情的代碼放在一起，這樣非常方便我們管理，就不需要跳到對應的方法里。非常符合我們開發(fā)中高聚合，低耦合的思想。
3.ReactiveCocoa編程思想
ReactiveCocoa結合了幾種編程風格：
函數(shù)式編程（Functional
Programming）：是把操作盡量寫成一系列嵌套的函數(shù)或者方法調(diào)用。
函數(shù)式編程特點：每個方法必須有返回值（本身對象）,把函數(shù)或者Block當做參數(shù),block參數(shù)（需要操作的值）block返回值（操作結果）
響應式編程（Reactive
Programming）：不需要考慮調(diào)用順序，只需要知道考慮結果，類似于蝴蝶效應，產(chǎn)生一個事件，會影響很多東西，這些事件像流一樣的傳播出去，然后影響結果，借用面向對象的一句話，萬物皆是流。
代表：KVO運用
所以，你可能聽說過ReactiveCocoa被描述為函數(shù)響應式編程（FRP）框架。
以后使用RAC解決問題，就不需要考慮調(diào)用順序，直接考慮結果，把每一次操作都寫成一系列嵌套的方法中，使代碼高聚合，方便管理。
4.ReactiveCocoa常見類。
4.1RACSiganl:信號類,一般表示將來有數(shù)據(jù)傳遞，只要有數(shù)據(jù)改變，信號內(nèi)部接收到數(shù)據(jù)，就會馬上發(fā)出數(shù)據(jù)。
注意：
?信號類(RACSiganl)，只是表示當數(shù)據(jù)改變時，信號內(nèi)部會發(fā)出數(shù)據(jù)，它本身不具備發(fā)送信號的能力，而是交給內(nèi)部一個訂閱者去發(fā)出。
?默認一個信號都是冷信號，也就是值改變了，也不會觸發(fā)，只有訂閱了這個信號，這個信號才會變?yōu)闊嵝盘枺蹈淖兞瞬艜|發(fā)。
如何訂閱信號：調(diào)用信號RACSignal的subscribeNext就能訂閱。
//
RACSignal使用步驟：
//1.創(chuàng)建信號+ (RACSignal *)createSignal:(RACDisposable
* (^)(id subscriber))didSubscribe
//2.訂閱信號,才會激活信號.
- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
//3.發(fā)送信號- (void)sendNext:(id)value
// RACSignal底層實現(xiàn)：
// 1.創(chuàng)建信號，首先把didSubscribe保存到信號中，還不會觸發(fā)。
// 2.當信號被訂閱，也就是調(diào)用signal的subscribeNext:nextBlock
// 2.2
subscribeNext內(nèi)部會創(chuàng)建訂閱者subscriber，并且把nextBlock保存到subscriber中。
// 2.1
subscribeNext內(nèi)部會調(diào)用siganl的didSubscribe
// 3.siganl的didSubscribe中調(diào)用[subscriber sendNext:@1];
// 3.1 sendNext底層其實就是執(zhí)行subscriber的nextBlock
// 1.創(chuàng)建信號
RACSignal *siganl = [RACSignal createSignal:^RACDisposable*(id subscriber) {
// block調(diào)用時刻：每當有訂閱者訂閱信號，就會調(diào)用block。
// 2.發(fā)送信號
[subscriber sendNext:@1];
//如果不在發(fā)送數(shù)據(jù)，最好發(fā)送信號完成，內(nèi)部會自動調(diào)用[RACDisposable disposable]取消訂閱信號。
[subscriber sendCompleted];
return [RACDisposabledisposableWithBlock:^{
// block調(diào)用時刻：當信號發(fā)送完成或者發(fā)送錯誤，就會自動執(zhí)行這個block,取消訂閱信號。
//執(zhí)行完Block后，當前信號就不在被訂閱了。
NSLog(@"信號被銷毀");
}];
}];
// 3.訂閱信號,才會激活信號.
[siganl subscribeNext:^(id x) {
// block調(diào)用時刻：每當有信號發(fā)出數(shù)據(jù)，就會調(diào)用block.
NSLog(@"接收到數(shù)據(jù):%@",x);
}];
4.2RACSubscriber:表示訂閱者的意思，用于發(fā)送信號，這是一個協(xié)議，不是一個類，只要遵守這個協(xié)議，并且實現(xiàn)方法才能成為訂閱者。通過create創(chuàng)建的信號，都有一個訂閱者，幫助他發(fā)送數(shù)據(jù)。
4.3RACDisposable:用于取消訂閱或者清理資源，當信號發(fā)送完成或者發(fā)送錯誤的時候，就會自動觸發(fā)它。
使用場景:不想監(jiān)聽某個信號時，可以通過它主動取消訂閱信號。
4.4RACSubject:信號提供者，自己可以充當信號，又能發(fā)送信號。
?使用場景:通常用來代替代理，有了它，就不必要定義代理了。
RACReplaySubject:重復提供信號類，RACSubject的子類。
?RACReplaySubject與RACSubject區(qū)別:
RACReplaySubject可以先發(fā)送信號，在訂閱信號，RACSubject就不可以。
?使用場景一:如果一個信號每被訂閱一次，就需要把之前的值重復發(fā)送一遍，使用重復提供信號類。
?使用場景二:可以設置capacity數(shù)量來限制緩存的value的數(shù)量,即只緩充最新的幾個值。
?RACSubject和RACReplaySubject簡單使用:
// RACSubject使用步驟
//1.創(chuàng)建信號[RACSubject subject]，跟RACSiganl不一樣，創(chuàng)建信號時沒有block。
//2.訂閱信號- (RACDisposable *)subscribeNext:(void
(^)(id x))nextBlock
//3.發(fā)送信號sendNext:(id)value
// RACSubject:底層實現(xiàn)和RACSignal不一樣。
// 1.調(diào)用subscribeNext訂閱信號，只是把訂閱者保存起來，并且訂閱者的nextBlock已經(jīng)賦值了。
// 2.調(diào)用sendNext發(fā)送信號，遍歷剛剛保存的所有訂閱者，一個一個調(diào)用訂閱者的nextBlock。
// 1.創(chuàng)建信號
RACSubject *subject = [RACSubject subject];
// 2.訂閱信號
[subject subscribeNext:^(id x) {
// block調(diào)用時刻：當信號發(fā)出新值，就會調(diào)用.
NSLog(@"第一個訂閱者%@",x);
}];
[subject subscribeNext:^(id x) {
// block調(diào)用時刻：當信號發(fā)出新值，就會調(diào)用.
NSLog(@"第二個訂閱者%@",x);
}];
// 3.發(fā)送信號
[subject sendNext:@"1"];
//
RACReplaySubject使用步驟:
// 1.創(chuàng)建信號[RACSubject subject]，跟RACSiganl不一樣，創(chuàng)建信號時沒有block。
// 2.可以先訂閱信號，也可以先發(fā)送信號。
// 2.1訂閱信號- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
// 2.2發(fā)送信號sendNext:(id)value
//
RACReplaySubject:底層實現(xiàn)和RACSubject不一樣。
// 1.調(diào)用sendNext發(fā)送信號，把值保存起來，然后遍歷剛剛保存的所有訂閱者，一個一個調(diào)用訂閱者的nextBlock。
// 2.調(diào)用subscribeNext訂閱信號，遍歷保存的所有值，一個一個調(diào)用訂閱者的nextBlock
//如果想當一個信號被訂閱，就重復播放之前所有值，需要先發(fā)送信號，在訂閱信號。
//也就是先保存值，在訂閱值。
// 1.創(chuàng)建信號
RACReplaySubject *replaySubject =[RACReplaySubject subject];
// 2.發(fā)送信號
[replaySubject sendNext:@1];
[replaySubject sendNext:@2];
// 3.訂閱信號
[replaySubject subscribeNext:^(id x) {
NSLog(@"第一個訂閱者接收到的數(shù)據(jù)%@",x);
}];
//訂閱信號
[replaySubject subscribeNext:^(id x) {
NSLog(@"第二個訂閱者接收到的數(shù)據(jù)%@",x);
}];
?RACSubject替換代理
//需求:
// 1.給當前控制器添加一個按鈕，modal到另一個控制器界面
// 2.另一個控制器view中有個按鈕，點擊按鈕，通知當前控制器
步驟一：在第二個控制器.h，添加一個RACSubject代替代理。
@interfaceTwoViewController : UIViewController
@property(nonatomic, strong) RACSubject *delegateSignal;
@end
步驟二：監(jiān)聽第二個控制器按鈕點擊
@implementationTwoViewController
-(IBAction)notice:(id)sender {
//通知第一個控制器，告訴它，按鈕被點了
//通知代理
//判斷代理信號是否有值
if (self.delegateSignal) {
//有值，才需要通知
[self.delegateSignal sendNext:nil];
}
}
@end
步驟三：在第一個控制器中，監(jiān)聽跳轉按鈕，給第二個控制器的代理信號賦值，并且監(jiān)聽.
@implementationOneViewController
-(IBAction)btnClick:(id)sender {
//創(chuàng)建第二個控制器
TwoViewController *twoVc =[[TwoViewController alloc] init];
//設置代理信號
twoVc.delegateSignal = [RACSubjectsubject];
//訂閱代理信號
[twoVc.delegateSignal subscribeNext:^(id x){
NSLog(@"點擊了通知按鈕");
}];
//跳轉到第二個控制器
[self presentViewController:twoVcanimated:YES completion:nil];
}
@end
4.5RACTuple:元組類,類似NSArray,用來包裝值.(好比數(shù)據(jù)庫表里的各列對應不同的屬性，那么它的每一行對應一個元組).
4.6RACSequence:RAC中的集合類，用于代替NSArray,NSDictionary,可以使用它來快速遍歷數(shù)組和字典。
使用場景：1.字典轉模型
RACSequence和RACTuple簡單使用
// 1.遍歷數(shù)組
NSArray *numbers = @[@1,@2,@3,@4];
//這里其實是三步
//第一步:把數(shù)組轉換成集合RACSequence numbers.rac_sequence
//第二步:把集合RACSequence轉換RACSignal信號類,numbers.rac_sequence.signal
//第三步:訂閱信號，激活信號，會自動把集合中的所有值，遍歷出來。
[numbers.rac_sequence.signalsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
// 2.遍歷字典,遍歷出來的鍵值對會包裝成RACTuple(元組對象)
NSDictionary *dict =@{@"name":@"xmg",@"age":@18};
[dict.rac_sequence.signalsubscribeNext:^(RACTuple *x) {
//解包元組，會把元組的值，按順序給參數(shù)里面的變量賦值
RACTupleUnpack(NSString *key,NSString*value) = x;
//相當于以下寫法
//NSString *key = x[0];
//NSString *value = x[1];
NSLog(@"%@ %@",key,value);
}];
// 3.字典轉模型
// 3.1 OC寫法
NSString *filePath = [[NSBundle mainBundle]pathForResource:@"flags.plist" ofType:nil];
NSArray *dictArr = [NSArrayarrayWithContentsOfFile:filePath];
NSMutableArray *items = [NSMutableArrayarray];
for (NSDictionary *dict in dictArr) {
FlagItem *item = [FlagItemflagWithDict:dict];
[items addObject:item];
}
// 3.2 RAC寫法
NSString *filePath = [[NSBundle mainBundle]pathForResource:@"flags.plist" ofType:nil];
NSArray *dictArr = [NSArrayarrayWithContentsOfFile:filePath];
NSMutableArray *flags = [NSMutableArrayarray];
_flags = flags;
// rac_sequence注意點：調(diào)用subscribeNext，并不會馬上執(zhí)行nextBlock，而是會等一會。
[dictArr.rac_sequence.signalsubscribeNext:^(id x) {
//運用RAC遍歷字典，x：字典
FlagItem *item = [FlagItemflagWithDict:x];
[flags addObject:item];
}];
NSLog(@"%@",NSStringFromCGRect([UIScreenmainScreen].bounds));
// 3.3 RAC高級寫法:
NSString *filePath = [[NSBundle mainBundle]pathForResource:@"flags.plist" ofType:nil];
NSArray *dictArr = [NSArrayarrayWithContentsOfFile:filePath];
// map:映射的意思，目的：把原始值value映射成一個新值
// array:把集合轉換成數(shù)組
//底層實現(xiàn)：當信號被訂閱，會遍歷集合中的原始值，映射成新值，并且保存到新的數(shù)組里。
NSArray *flags = [[dictArr.rac_sequencemap:^id(id value) {
return [FlagItem flagWithDict:value];
}] array];
4.7RACCommand:RAC中用于處理事件的類，可以把事件如何處理,事件中的數(shù)據(jù)如何傳遞，包裝到這個類中，他可以很方便的監(jiān)控事件的執(zhí)行過程。
使用場景:監(jiān)聽按鈕點擊，網(wǎng)絡請求
RACCommand簡單使用
//一、RACCommand使用步驟:
//1.創(chuàng)建命令initWithSignalBlock:(RACSignal* (^)(id input))signalBlock
//2.在signalBlock中，創(chuàng)建RACSignal，并且作為signalBlock的返回值
//3.執(zhí)行命令- (RACSignal *)execute:(id)input
//二、RACCommand使用注意:
//1.signalBlock必須要返回一個信號，不能傳nil.
//2.如果不想要傳遞信號，直接創(chuàng)建空的信號[RACSignal empty];
// 3.RACCommand中信號如果數(shù)據(jù)傳遞完，必須調(diào)用[subscriber sendCompleted]，這時命令才會執(zhí)行完畢，否則永遠處于執(zhí)行中。
// 4.RACCommand需要被強引用，否則接收不到RACCommand中的信號，因此RACCommand中的信號是延遲發(fā)送的。
//三、RACCommand設計思想：內(nèi)部signalBlock為什么要返回一個信號，這個信號有什么用。
// 1.在RAC開發(fā)中，通常會把網(wǎng)絡請求封裝到RACCommand，直接執(zhí)行某個RACCommand就能發(fā)送請求。
// 2.當RACCommand內(nèi)部請求到數(shù)據(jù)的時候，需要把請求的數(shù)據(jù)傳遞給外界，這時候就需要通過signalBlock返回的信號傳遞了。
//四、如何拿到RACCommand中返回信號發(fā)出的數(shù)據(jù)。
// 1.RACCommand有個執(zhí)行信號源executionSignals，這個是signal of signals(信號的信號),意思是信號發(fā)出的數(shù)據(jù)是信號，不是普通的類型。
// 2.訂閱executionSignals就能拿到RACCommand中返回的信號，然后訂閱signalBlock返回的信號，就能獲取發(fā)出的值。
//五、監(jiān)聽當前命令是否正在執(zhí)行executing
//六、使用場景,監(jiān)聽按鈕點擊，網(wǎng)絡請求
// 1.創(chuàng)建命令
RACCommand *command = [[RACCommand alloc]initWithSignalBlock:^RACSignal *(id input) {
NSLog(@"執(zhí)行命令");
//創(chuàng)建空信號,必須返回信號
//return [RACSignal empty];
// 2.創(chuàng)建信號,用來傳遞數(shù)據(jù)
return [RACSignalcreateSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@"請求數(shù)據(jù)"];
//注意：數(shù)據(jù)傳遞完，最好調(diào)用sendCompleted，這時命令才執(zhí)行完畢。
[subscriber sendCompleted];
return nil;
}];
}];
//強引用命令，不要被銷毀，否則接收不到數(shù)據(jù)
_conmmand = command;
// 3.訂閱RACCommand中的信號
[command.executionSignalssubscribeNext:^(id x) {
[x subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
}];
// RAC高級用法
//switchToLatest:用于signal of signals，獲取signal of signals發(fā)出的最新信號,也就是可以直接拿到RACCommand中的信號
[command.executionSignals.switchToLatestsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
// 4.監(jiān)聽命令是否執(zhí)行完畢,默認會來一次(會先檢測到之前的狀態(tài)是執(zhí)行完成)，可以直接跳過，skip表示跳過第一次信號。
[[command.executing skip:1]subscribeNext:^(id x) {
if ([x boolValue] == YES) {
//正在執(zhí)行
NSLog(@"正在執(zhí)行");
}else{
//執(zhí)行完成
NSLog(@"執(zhí)行完成");
}
}];
// 5.執(zhí)行命令
[self.conmmand execute:@1];
4.8RACMulticastConnection:用于當一個信號，被多次訂閱時，為了保證創(chuàng)建信號時，避免多次調(diào)用創(chuàng)建信號中的block，造成副作用，可以使用這個類處理。
使用注意:RACMulticastConnection通過RACSignal的-publish或者-muticast:方法創(chuàng)建.
RACMulticastConnection簡單使用:
//
RACMulticastConnection使用步驟:
//1.創(chuàng)建信號+ (RACSignal *)createSignal:(RACDisposable *
(^)(id subscriber))didSubscribe
//2.創(chuàng)建連接RACMulticastConnection*connect = [signal publish];
//3.訂閱信號,注意：訂閱的不在是之前的信號，而是連接的信號。[connect.signal subscribeNext:nextBlock]
//4.連接[connect connect]
//
RACMulticastConnection底層原理:
// 1.創(chuàng)建connect，connect.sourceSignal
-> RACSignal(原始信號)connect.signal -> RACSubject
// 2.訂閱connect.signal，會調(diào)用RACSubject的subscribeNext，創(chuàng)建訂閱者，而且把訂閱者保存起來，不會執(zhí)行block。
// 3.[connect
connect]內(nèi)部會訂閱RACSignal(原始信號)，并且訂閱者是RACSubject
// 3.1.訂閱原始信號，就會調(diào)用原始信號中的didSubscribe
// 3.2
didSubscribe，拿到訂閱者調(diào)用sendNext，其實是調(diào)用RACSubject的sendNext
// 4.RACSubject的sendNext,會遍歷RACSubject所有訂閱者發(fā)送信號。
// 4.1因為剛剛第二步，都是在訂閱RACSubject，因此會拿到第二步所有的訂閱者，調(diào)用他們的nextBlock
//需求：假設在一個信號中發(fā)送請求，每次訂閱一次都會發(fā)送請求，這樣就會導致多次請求。
//解決：使用RACMulticastConnection就能解決.
// 1.創(chuàng)建請求信號
RACSignal *signal = [RACSignal createSignal:^RACDisposable*(id subscriber) {
NSLog(@"發(fā)送請求");
return nil;
}];
// 2.訂閱信號
[signal subscribeNext:^(id x) {
NSLog(@"接收數(shù)據(jù)");
}];
// 2.訂閱信號
[signal subscribeNext:^(id x) {
NSLog(@"接收數(shù)據(jù)");
}];
// 3.運行結果，會執(zhí)行兩遍發(fā)送請求，也就是每次訂閱都會發(fā)送一次請求
// RACMulticastConnection:解決重復請求問題
// 1.創(chuàng)建信號
RACSignal *signal = [RACSignal createSignal:^RACDisposable*(id subscriber) {
NSLog(@"發(fā)送請求");
[subscriber sendNext:@1];
return nil;
}];
// 2.創(chuàng)建連接
RACMulticastConnection *connect = [signalpublish];
// 3.訂閱信號，
//注意：訂閱信號，也不能激活信號，只是保存訂閱者到數(shù)組，必須通過連接,當調(diào)用連接，就會一次性調(diào)用所有訂閱者的sendNext:
[connect.signal subscribeNext:^(id x) {
NSLog(@"訂閱者一信號");
}];
[connect.signal subscribeNext:^(id x) {
NSLog(@"訂閱者二信號");
}];
// 4.連接,激活信號
[connect connect];
4.9RACScheduler:信號調(diào)度器，是一個線性執(zhí)行隊列，rac中的信號可以在RACScheduler上執(zhí)行任務、發(fā)送結果，底層用GCD封裝的。
4.9.1包含6個實例化方法：都是用來生成一個queue的
//是一個會立即執(zhí)行傳入的代碼塊的調(diào)度器
+(RACScheduler *)immediateScheduler;
//immediateScheduler底層實現(xiàn)就是生成了一個RACImmediateScheduler的單例。
RACImmediateScheduler是繼承自RACScheduler
//獲得主線程調(diào)度器
+(RACScheduler *)mainThreadScheduler;
//獲取當前線程調(diào)度器
+
(RACScheduler *)currentScheduler;
//以下3個方法實質(zhì)都是是創(chuàng)建了一個Global Dispatch Queue，對應的屬于Concurrent Dispatch Queue。
+(RACScheduler*)schedulerWithPriority:(RACSchedulerPriority)priority
name:(NSString *)name;//方法可以指定線程的優(yōu)先級和名字
+
(RACScheduler *)schedulerWithPriority:(RACSchedulerPriority)priority;//方法只能執(zhí)行優(yōu)先級，名字為默認的
+
(RACScheduler *)scheduler;//方法創(chuàng)建出來的queue的優(yōu)先級是默認的，名字也是默認的
4.9.2幾個常用的用于調(diào)度、執(zhí)行任務的方法:
//會立刻執(zhí)行傳入的block
-(RACDisposable *)schedule:(void(^)(void))block;
//會將當前線程休眠到指定時間后執(zhí)行block
-(RACDisposable *)after:(NSDate *)date schedule:(void(^)(void))block;
//當前線程休眠date時間之后執(zhí)行，然后每隔interval時間重復執(zhí)行,leeway這個參數(shù)是為dispatch source指定一個期望的定時器事件精度，讓系統(tǒng)能夠靈活地管理并喚醒內(nèi)核。例如系統(tǒng)可以使用leeway值來提前或延遲觸發(fā)定時器，使其更好地與其它系統(tǒng)事件結合。創(chuàng)建自己的定時器時，應該盡量指定一個leeway值。不過就算指定leeway值為0，也不能完完全全期望定時器能夠按照精確的納秒來觸發(fā)事件
-(RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)intervalwithLeeway:(NSTimeInterval)leeway schedule:(void(^)(void))block;
4.9.3RACScheduler的使用舉例：
//1.線程的切換：
deliverOn：在設置的調(diào)度中發(fā)送信號值,但操作封包依然在原來的調(diào)度里進行
//創(chuàng)建信號
RACSignal * signal = [RACSignal createSignal:^RACDisposable*(id subscriber) {
NSLog(@"sendTestSignal%@",[NSThread currentThread]);
[subscriber sendNext:@1];
[subscriber sendCompleted];
return [RACDisposable disposableWithBlock:^{
}];
}];
//訂閱信號
//要想放在主線程執(zhí)行只要將[RACScheduler scheduler]更換為[RACScheduler mainThreadScheduler]
[[self.testSignaldeliverOn:[RACScheduler scheduler]] subscribeNext:^(id x) {
NSLog(@"receiveSignal%@",[NSThread currentThread]);
}];
打印結果如下
2016-09-02 09:48:59.697 Signal processing[1686:22894]sendTestSignal{number = 1, name = main}
2016-09-0209:48:59.697 Signal processing[1686:24680] receiveSignal{number = 3, name = (null)}
subscribeOn：在設置的調(diào)度中發(fā)送信號和執(zhí)行封包里的操作
[[[RACSignal createSignal:^RACDisposable *(idsubscriber) {
NSLog(@"sendSignal%@",[NSThread currentThread]);
[subscriber sendNext:@1];
return [RACDisposabledisposableWithBlock:^{
}];
}]subscribeOn:[RACScheduler scheduler]] subscribeNext:^(id x) {
NSLog(@"receiveSignal%@",[NSThread currentThread]);
}];
打印結果如下
2016-09-02 09:54:47.819 Signal processing[1778:54504] sendSignal
0x7fde7adb4e00>{number = 2, name = (null)}
2016-09-02 09:54:47.819 Signal processing[1778:54504]
receiveSignal{number = 2, name = (null)}
2.與時間相關的操作會用到
timeout：超時，可以讓一個信號在一定的時間后，自動報錯。（我們項目中網(wǎng)絡請求超時問題沒有處理）
RACSignal*signal = [[RACSignal createSignal:^RACDisposable *(idsubscriber) {
return nil;
}]
timeout:1 onScheduler:[RACScheduler
currentScheduler]];
[signalsubscribeNext:^(id x) {
NSLog(@"%@",x);
}error:^(NSError *error) {
// 1秒后會自動調(diào)用
NSLog(@"%@",error);
}];
interval定時：每隔一段時間發(fā)出信號
[[RACSignalinterval:1 onScheduler:[RACScheduler currentScheduler]] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
在RACSignal+Operations很作操作方法中都會調(diào)用RACScheduler的實例化方法，我們外部直接去調(diào)用的比較少，大多都被封裝進去了，比如：
-
(RACSignal *)delay:(NSTimeInterval)interval；
+(RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler*)scheduler
-(RACSignal *)timeout:(NSTimeInterval)interval onScheduler:(RACScheduler*)scheduler { }
-(RACSignal *)deliverOn:(RACScheduler *)scheduler { }
-(RACSignal *)subscribeOn:(RACScheduler *)scheduler { }
RACScheduler底層原理參考：
http://www.open-open.com/lib/view/open1487381068466.html
http://www.lxweimin.com/p/980ffdf3ed8c
5.ReactiveCocoa常見操作方法介紹
5.1 ReactiveCocoa操作須知:
所有的信號（RACSignal）都可以進行操作處理，因為所有操作方法都定義在RACStream.h中，因此只要繼承RACStream就有了操作處理方法
5.2ReactiveCocoa操作思想:
?運用的是Hook（鉤子）思想，Hook是一種用于改變API(應用程序編程接口：方法)執(zhí)行結果的技術.
?Hook用處：截獲API調(diào)用的技術。
Hook原理：在每次調(diào)用一個API返回結果之前，先執(zhí)行你自己的方法，改變結果的輸出。
5.3ReactiveCocoa核心方法bind
//假設想監(jiān)聽文本框的內(nèi)容，并且在每次輸出結果的時候，都在文本框的內(nèi)容拼接一段文字“輸出：”
//方式一:在返回結果后，拼接。
[_textField.rac_textSignalsubscribeNext:^(id x) {
NSLog(@"輸出:%@",x);
}];
//方式二:在返回結果前，拼接，使用RAC中bind方法做處理。
// bind方法參數(shù):需要傳入一個返回值是RACStreamBindBlock的block參數(shù)
//
RACStreamBindBlock是一個block的類型，返回值是信號，參數(shù)（value,stop），因此參數(shù)的block返回值也是一個block。
//
RACStreamBindBlock:
//參數(shù)一(value):表示接收到信號的原始值，還沒做處理
//參數(shù)二(*stop):用來控制綁定Block，如果*stop = yes,那么就會結束綁定。
//返回值：信號，做好處理，在通過這個信號返回出去，一般使用RACReturnSignal,需要手動導入頭文件RACReturnSignal.h。
// bind方法使用步驟:
// 1.傳入一個返回值RACStreamBindBlock的block。
// 2.描述一個RACStreamBindBlock類型的bindBlock作為block的返回值。
// 3.描述一個返回結果的信號，作為bindBlock的返回值。
//注意：在bindBlock中做信號結果的處理。
//底層實現(xiàn):
// 1.源信號調(diào)用bind,會重新創(chuàng)建一個綁定信號。
// 2.當綁定信號被訂閱，就會調(diào)用綁定信號中的didSubscribe，生成一個bindingBlock。
// 3.當源信號有內(nèi)容發(fā)出，就會把內(nèi)容傳遞到bindingBlock處理，調(diào)用bindingBlock(value,stop)
// 4.調(diào)用bindingBlock(value,stop)，會返回一個內(nèi)容處理完成的信號（RACReturnSignal）。
// 5.訂閱RACReturnSignal，就會拿到綁定信號的訂閱者，把處理完成的信號內(nèi)容發(fā)送出來。
//注意:不同訂閱者，保存不同的nextBlock，看源碼的時候，一定要看清楚訂閱者是哪個。
//這里需要手動導入#import ，才能使用RACReturnSignal。
[[_textField.rac_textSignalbind:^RACStreamBindBlock{
//什么時候調(diào)用:
// block作用:表示綁定了一個信號.
return ^RACStream *(id value, BOOL*stop){
//什么時候調(diào)用block:當信號有新的值發(fā)出，就會來到這個block。
// block作用:做返回值的處理
//做好處理，此處可以實現(xiàn)一些比較猥瑣的操作，然后通過信號返回出去.
return [RACReturnSignalreturn:[NSString stringWithFormat:@"輸出:%@",value]];
};
}] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
5.4ReactiveCocoa操作方法之映射(flattenMap,Map)
flattenMap，Map用于把源信號內(nèi)容映射成新的內(nèi)容。
flattenMap簡單使用
//監(jiān)聽文本框的內(nèi)容改變，把結構重新映射成一個新值.
//flattenMap作用:把源信號的內(nèi)容映射成一個新的信號，信號可以是任意類型。
// flattenMap使用步驟:
// 1.傳入一個block，block類型是返回值RACStream，參數(shù)value
// 2.參數(shù)value就是源信號的內(nèi)容，拿到源信號的內(nèi)容做處理
// 3.包裝成RACReturnSignal信號，返回出去。
// flattenMap底層實現(xiàn):
// 0.flattenMap內(nèi)部調(diào)用bind方法實現(xiàn)的,flattenMap中block的返回值，會作為bind中bindBlock的返回值。
// 1.當訂閱綁定信號，就會生成bindBlock。
// 2.當源信號發(fā)送內(nèi)容，就會調(diào)用bindBlock(value, *stop)
// 3.調(diào)用bindBlock，內(nèi)部就會調(diào)用flattenMap的block，flattenMap的block作用：就是把處理好的數(shù)據(jù)包裝成信號。
// 4.返回的信號最終會作為bindBlock中的返回信號，當做bindBlock的返回信號。
// 5.訂閱bindBlock的返回信號，就會拿到綁定信號的訂閱者，把處理完成的信號內(nèi)容發(fā)送出來。
[[_textField.rac_textSignalflattenMap:^RACStream *(id value) {
// block什么時候:源信號發(fā)出的時候，就會調(diào)用這個block。
// block作用:改變源信號的內(nèi)容。
//返回值：綁定信號的內(nèi)容.
return
[RACReturnSignal return:[NSString stringWithFormat:@"輸出:%@",value]];
}] subscribeNext:^(id x) {
//訂閱綁定信號，每當源信號發(fā)送內(nèi)容，做完處理，就會調(diào)用這個block。
NSLog(@"%@",x);
}];
Map簡單使用:
//監(jiān)聽文本框的內(nèi)容改變，把結構重新映射成一個新值.
//Map作用:把源信號的值映射成一個新的值
// Map使用步驟:
// 1.傳入一個block,類型是返回對象，參數(shù)是value
// 2.value就是源信號的內(nèi)容，直接拿到源信號的內(nèi)容做處理
// 3.把處理好的內(nèi)容，直接返回就好了，不用包裝成信號，返回的值，就是映射的值。
// Map底層實現(xiàn):
// 0.Map底層其實是調(diào)用flatternMap,Map中block中的返回的值會作為flatternMap中block中的值。
// 1.當訂閱綁定信號，就會生成bindBlock。
// 3.當源信號發(fā)送內(nèi)容，就會調(diào)用bindBlock(value, *stop)
// 4.調(diào)用bindBlock，內(nèi)部就會調(diào)用flattenMap的block
// 5.flattenMap的block內(nèi)部會調(diào)用Map中的block，把Map中的block返回的內(nèi)容包裝成返回的信號。
// 5.返回的信號最終會作為bindBlock中的返回信號，當做bindBlock的返回信號。
// 6.訂閱bindBlock的返回信號，就會拿到綁定信號的訂閱者，把處理完成的信號內(nèi)容發(fā)送出來。
[[_textField.rac_textSignalmap:^id(id value) {
//當源信號發(fā)出，就會調(diào)用這個block，修改源信號的內(nèi)容
//返回值：就是處理完源信號的內(nèi)容。
return
[NSString stringWithFormat:@"輸出:%@",value];
}]subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
?FlatternMap和Map的區(qū)別
?1.FlatternMap中的Block返回信號。
?2.Map中的Block返回對象。
?3.開發(fā)中，如果信號發(fā)出的值不是信號，映射一般使用Map
?4.開發(fā)中，如果信號發(fā)出的值是信號，映射一般使用FlatternMap。
?總結：signalOfsignals用FlatternMap。
//創(chuàng)建信號中的信號
RACSubject *signalOfsignals = [RACSubjectsubject];
RACSubject *signal = [RACSubject subject];
[[signalOfsignals flattenMap:^RACStream *(id value) {
//當signalOfsignals的signals發(fā)出信號才會調(diào)用
return value;
}] subscribeNext:^(id x) {
//只有signalOfsignals的signal發(fā)出信號才會調(diào)用，因為內(nèi)部訂閱了bindBlock中返回的信號，也就是flattenMap返回的信號。
//也就是flattenMap返回的信號發(fā)出內(nèi)容，才會調(diào)用。
NSLog(@"%@aaa",x);
}];
//信號的信號發(fā)送信號
[signalOfsignals sendNext:signal];
//信號發(fā)送內(nèi)容
[signal sendNext:@1];
5.5 ReactiveCocoa操作方法之組合。
concat:按一定順序拼接信號，當多個信號發(fā)出的時候，有順序的接收信號。
RACSignal *signalA= [RACSignal createSignal:^RACDisposable *(id subscriber){
[subscriber sendNext:@1];
[subscriber sendCompleted];
return nil;
}];
RACSignal *signalB = [RACSignalcreateSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@2];
return nil;
}];
//把signalA拼接到signalB后，signalA發(fā)送完成，signalB才會被激活。
RACSignal *concatSignal =[signalA concat:signalB];
//以后只需要面對拼接信號開發(fā)。
//訂閱拼接的信號，不需要單獨訂閱signalA，signalB
//內(nèi)部會自動訂閱。
//注意：第一個信號必須發(fā)送完成，第二個信號才會被激活
[concatSignalsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
// concat底層實現(xiàn):
// 1.當拼接信號被訂閱，就會調(diào)用拼接信號的didSubscribe
// 2.didSubscribe中，會先訂閱第一個源信號（signalA）
// 3.會執(zhí)行第一個源信號（signalA）的didSubscribe
// 4.第一個源信號（signalA）didSubscribe中發(fā)送值，就會調(diào)用第一個源信號（signalA）訂閱者的nextBlock,通過拼接信號的訂閱者把值發(fā)送出來.
// 5.第一個源信號（signalA）didSubscribe中發(fā)送完成，就會調(diào)用第一個源信號（signalA）訂閱者的completedBlock,訂閱第二個源信號（signalB）這時候才激活（signalB）。
// 6.訂閱第二個源信號（signalB）,執(zhí)行第二個源信號（signalB）的didSubscribe
// 7.第二個源信號（signalA）didSubscribe中發(fā)送值,就會通過拼接信號的訂閱者把值發(fā)送出來.
then:用于連接兩個信號，當?shù)谝粋€信號完成，才會連接then返回的信號。
?//注意使用then，之前信號的值會被忽略掉.
?//底層實現(xiàn)：1、先過濾掉之前的信號發(fā)出的值。2.使用concat連接then返回的信號
[[[RACSignal createSignal:^RACDisposable*(id subscriber) {
[subscriber sendNext:@1];
[subscriber sendCompleted];
return nil;
}]then:^RACSignal *{
return [RACSignal createSignal:^RACDisposable*(id subscriber) {
[subscriber sendNext:@2];
return nil;
}];
}]subscribeNext:^(id x) {
//只能接收到第二個信號的值，也就是then返回信號的值
NSLog(@"%@",x);
}];
merge:把多個信號合并為一個信號，任何一個信號有新值的時候就會調(diào)用
注意區(qū)別concat：concat的信號有先后順序，必須要前面的信號先發(fā)出后面的信號才會被激活
//創(chuàng)建多個信號
RACSignal *signalA= [RACSignal createSignal:^RACDisposable *(id subscriber){
[subscriber sendNext:@1];
return nil;
}];
RACSignal *signalB = [RACSignalcreateSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@2];
return nil;
}];
//合并信號,任何一個信號發(fā)送數(shù)據(jù)，都能監(jiān)聽到.
RACSignal *mergeSignal = [signalAmerge:signalB];
[mergeSignal subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
//底層實現(xiàn)：
// 1.合并信號被訂閱的時候，就會遍歷所有信號，并且發(fā)出這些信號。
// 2.每發(fā)出一個信號，這個信號就會被訂閱
// 3.也就是合并信號一被訂閱，就會訂閱里面所有的信號。
// 4.只要有一個信號被發(fā)出就會被監(jiān)聽。
zipWith:把兩個信號壓縮成一個信號，只有當兩個信號同時發(fā)出信號內(nèi)容時，并且把兩個信號的內(nèi)容合并成一個元組，才會觸發(fā)壓縮流的next事件。
RACSignal *signalA =[RACSignal createSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@1];
return nil;
}];
RACSignal *signalB = [RACSignalcreateSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@2];
return nil;
}];
//壓縮信號A，信號B
RACSignal *zipSignal = [signalAzipWith:signalB];
[zipSignal subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
//底層實現(xiàn):
// 1.定義壓縮信號，內(nèi)部就會自動訂閱signalA，signalB
// 2.每當signalA或者signalB發(fā)出信號，就會判斷signalA，signalB有沒有發(fā)出個信號，有就會把最近發(fā)出的信號都包裝成元組發(fā)出。
combineLatest:將多個信號合并起來，并且拿到各個信號的最新的值,必須每個合并的signal至少都有過一次sendNext，才會觸發(fā)合并的信號。
RACSignal*signalA = [RACSignal createSignal:^RACDisposable *(idsubscriber) {
[subscriber sendNext:@1];
return nil;
}];
RACSignal*signalB = [RACSignal createSignal:^RACDisposable *(idsubscriber) {
[subscriber sendNext:@2];
return nil;
}];
RACSignal*combineSignal = [signalA combineLatestWith:signalB];
[combineSignalsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
?//底層實現(xiàn)：
?// 1.當組合信號被訂閱，內(nèi)部會自動訂閱signalA，signalB,必須兩個信號都發(fā)出內(nèi)容，才會被觸發(fā)。
?// 2.并且把兩個信號組合成元組發(fā)出。
Zip和combineLatest區(qū)別：
?Zip的合并行為是按順序取出各個信號，然后合并成元組后信號后發(fā)出。比如有信號A和信號B，合并信號為zipSingle,zipSingle發(fā)出的條件必須是A和B都有對應順序下的最新值發(fā)出。比如A發(fā)了信號1和信號2,而B只發(fā)了信號3，那么此時組合信號只會觸發(fā)一次，因為A雖說發(fā)了2次信號，但是B只發(fā)了一次，第一次的信號從A和B中都能取到，所以會有組合信號發(fā)出，第二次B信號取不到，故第二次的組合信號不成立，不會觸發(fā)組合信號，只有B再發(fā)送一次信號時能能觸發(fā)第二次組合信號。
?CombineLatest的合并行為是，只要A和B兩個子信號都觸發(fā)過一次以上，就會觸發(fā)該組合信號，并且后續(xù)只要A或者B中的一個信號有新信號發(fā)出都會觸發(fā)該組合信號，并且該組合信號合并的規(guī)則是一直取A或者B中當前最新的值合并成元組。
?實際開發(fā)中，我們下拉刷新需要等到所有接口返回再刷新UI的時候應該用zip而不是combinLatest.
reduce聚合:用于信號發(fā)出的內(nèi)容是元組，把信號發(fā)出元組的值聚合成一個值
RACSignal*signalA = [RACSignal createSignal:^RACDisposable *(idsubscriber) {
[subscriber sendNext:@1];
return nil;
}];
RACSignal*signalB = [RACSignal createSignal:^RACDisposable *(idsubscriber) {
[subscriber sendNext:@2];
return nil;
}];
//常見的用法，（先組合在聚合）。combineLatest:(id)signals
reduce:(id (^)())reduceBlock
//
reduce中的block簡介:
//reduceblcok中的參數(shù)，有多少信號組合，reduceblcok就有多少參數(shù)，每個參數(shù)就是之前信號發(fā)出的內(nèi)容
//
reduceblcok的返回值：聚合信號之后的內(nèi)容。
RACSignal*reduceSignal = [RACSignal combineLatest:@[signalA,signalB] reduce:^id(NSNumber*num1 ,NSNumber *num2){
return [NSString stringWithFormat:@"%@%@",num1,num2];
}];
[reduceSignalsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
//底層實現(xiàn):
// 1.訂閱聚合信號，每次有內(nèi)容發(fā)出，就會執(zhí)行reduceblcok，把信號內(nèi)容轉換成reduceblcok返回的值。
5.6 ReactiveCocoa操作方法之過濾。
?filter:過濾信號，使用它可以獲取滿足條件的信號.
//過濾:
//每次信號發(fā)出，會先執(zhí)行過濾條件判斷.
[_textField.rac_textSignalfilter:^BOOL(NSString *value) {
return value.length > 3;
}];
?ignore:忽略完某些值的信號.
//內(nèi)部調(diào)用filter過濾，忽略掉ignore的值
[[_textField.rac_textSignalignore:@"1"] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
?distinctUntilChanged:當上一次的值和當前的值有明顯的變化就會發(fā)出信號，否則會被忽略掉。
//過濾，當上一次和當前的值不一樣，就會發(fā)出內(nèi)容。
//在開發(fā)中，刷新UI經(jīng)常使用，只有兩次數(shù)據(jù)不一樣才需要刷新
[[_textField.rac_textSignaldistinctUntilChanged] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
?take:從開始一共取N次的信號
//
1、創(chuàng)建信號
RACSubject*signal = [RACSubject subject];
//
2、處理信號，訂閱信號
[[signaltake:1] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
//
3.發(fā)送信號
[signalsendNext:@1];
[signalsendNext:@2];
?takeLast:取最后N次的信號,前提條件，訂閱者必須調(diào)用完成，因為只有完成，就知道總共有多少信號.
//
1、創(chuàng)建信號
RACSubject*signal = [RACSubject subject];
//
2、處理信號，訂閱信號
[[signaltakeLast:1] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
//
3.發(fā)送信號
[signalsendNext:@1];
[signalsendNext:@2];
[signalsendCompleted];//必須調(diào)完成
?takeUntil:(RACSignal *):獲取信號直到某個信號執(zhí)行完成
//監(jiān)聽文本框的改變直到當前對象被銷毀
[_textField.rac_textSignaltakeUntil:self.rac_willDeallocSignal];
?skip:(NSUInteger):跳過幾個信號,不接受。
//表示輸入第一次，不會被監(jiān)聽到，跳過第一次發(fā)出的信號
[[_textField.rac_textSignalskip:1] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
?switchToLatest:用于signalOfSignals（信號的信號），有時候信號也會發(fā)出信號，會在signalOfSignals中，獲取signalOfSignals發(fā)送的最新信號。
RACSubject*signalOfSignals = [RACSubject subject];
RACSubject*signal = [RACSubject subject];
//獲取信號中信號最近發(fā)出信號，訂閱最近發(fā)出的信號。
//注意switchToLatest：只能用于信號中的信號
[signalOfSignals.switchToLatestsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
[signalOfSignalssendNext:signal];
[signal sendNext:@1];
5.7 ReactiveCocoa操作方法之秩序。
?doNext:執(zhí)行Next之前，會先執(zhí)行這個Block
?doCompleted:執(zhí)行sendCompleted之前，會先執(zhí)行這個Block
[[[[RACSignalcreateSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@1];
[subscriber sendCompleted];
return nil;
}]doNext:^(id x) {
//執(zhí)行[subscriber sendNext:@1];之前會調(diào)用這個Block
NSLog(@"doNext");;
}]doCompleted:^{
//執(zhí)行[subscriber sendCompleted];之前會調(diào)用這個Block
NSLog(@"doCompleted");;
}]subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
5.8 ReactiveCocoa操作方法之線程。
deliverOn:內(nèi)容傳遞切換到制定線程中，副作用在原來線程中,把在創(chuàng)建信號時block中的代碼稱之為副作用。
subscribeOn:內(nèi)容傳遞和副作用都會切換到制定線程中。
上文RACScheduler均有代碼演示。
5.9 ReactiveCocoa操作方法之時間。
timeout：超時，可以讓一個信號在一定的時間后，自動報錯。
interval定時：每隔一段時間發(fā)出信號
delay延遲發(fā)送next。
上文均有代碼演示。
5.10 ReactiveCocoa操作方法之重復。
retry重試：只要失敗，就會重新執(zhí)行創(chuàng)建信號中的block,直到成功.
__blockint i = 0;
[[[RACSignal createSignal:^RACDisposable*(id subscriber) {
if (i == 10) {
[subscriber sendNext:@1];
}else{
NSLog(@"接收到錯誤");
[subscriber sendError:nil];
}
i++;
return nil;
}] retry] subscribeNext:^(id x) {
NSLog(@"%@",x);
} error:^(NSError *error) {
}];
replay重放：當一個信號被多次訂閱,反復播放內(nèi)容（類似的還有replayLast，replayLazily）
具體用法比較：見文檔。
throttle節(jié)流:當某個信號發(fā)送比較頻繁時，可以使用節(jié)流，在某一段時間不發(fā)送信號內(nèi)容，過了一段時間獲取信號的最新內(nèi)容發(fā)出。
需求場景：
在我們做搜索框的時候，有時候需求的時實時搜索，即用戶每每輸入字符，view都要求展現(xiàn)搜索結果。這時如果用戶搜索的字符串較長，那么由于網(wǎng)絡請求的延時可能造成UI顯示錯誤，并且多次不必要的請求還會加大服務器的壓力，這顯然是不合理的，此時我們就需要用到節(jié)流。
[[[self.textFild rac_textSignal]throttle:1] subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
主要技術參考資料：
