ReactiveCocoa(一)

時間 2019-11-12

原文原文鏈接

前言

以前總聽別人說什麼Reactive Cocoa + MVVM，可是沒有找到講解Reactive Cocoa相關的資料。結果進入新公司，項目裏面有部分代碼使用到了Reactive Cocoa,因此筆者在這記錄本身學習Reactive Cocoa的筆記，同時也但願你們經過閱讀這篇文章能學到點什麼。react

Reactive Cocoa簡介

Reactive Cocoa(簡稱RAC，PS:不是ARC(自動引用計數)),是由Github開源的一個應用於iOS和OS開發的新框架，cocoa是蘋果整套框架的簡稱，所以不少蘋果框架都喜歡以cocoa結尾。編程

Reactive Cocoa做用

在咱們iOS開發中，當某些事件響應的時候，須要處理某些業務邏輯，這些事情都以不一樣的方式來處理。
咱們以前熟悉的事件處理方式有：action、delegate、kvo、block以及notification。其實這些事件均可以使用RAC處理。
RAC爲事件提供了不少處理方法，並且利用RAC處理事件很方便，能夠把須要處理的事件和監聽事件的代碼放到一塊，這樣便於咱們管理，就不須要跳轉到對應的方法裏面。很是符合咱們開發中高聚合，低耦合的思想。

編程思想

在開發過程當中咱們要學習一個框架，仍是有必要先了解它的編程思想。數組

先了解一下咱們已知的編程思想：緩存

面向過程: 處理事情以過程爲中心，一步一步的實現。
面向對象: 萬物皆對象。

鏈式編程: 是將多個操做經過點號(.)鏈接起來成爲一句代碼，使代碼可讀性好。如：
add(1).add(2).add(3)

鏈式編程特色: 方法的返回值是block，block必須有返回值(對象自己),block參數就是咱們要操做的值
表明做: masonry框架

模仿masonry框架，仿寫一個加法計算器，練習鏈式編程思想網絡

// 建立一個NSObject的分類,  .h代碼：
@class CaculatorMaker;
@interface NSObject (Caculator)

+ (int)makeCaculator:(void(^)(CaculatorMaker *make))caculator;

@end


// .m代碼
@implementation NSObject (Caculator)

+ (int)makeCaculator:(void(^)(CaculatorMaker *make))caculator {
    CaculatorMaker *maker = [[CaculatorMaker alloc] init];

    caculator(maker);

    return maker.result;
}
@end


/**********************************************************/

//建立一個CaculatorMaker類， .h代碼：
@interface CaculatorMaker : NSObject

@property (nonatomic, assign) int result;

- (CaculatorMaker *(^)(int result))add;

@end


//.m代碼
- (CaculatorMaker *(^)(int result))add {
   return ^(int result){
      _result += result;
      return self;
   };
}


//調用：
- (void)viewDidLoad {
    [super viewDidLoad];
    int result = [NSObject makeCaculator:^(CaculatorMaker *make) {
        make.add(1).add(3);
    }];
    NSLog(@"%d",result);
}

響應式編程: 不須要考慮調用順序，只須要考慮調用結果，相似於蝴蝶效應，產生一個事件，會影響不少東西，這些事件就像流同樣發送出去，最後影響結果。框架
- 表明做: KVO的運用

函數式編程: 是把操做盡可能使用一系列的函數或者方法調用

函數式編程特色: 每一個方法必須有返回值(對象自己)，把block當作參數，block參數就是須要操做的值，block返回值就是操做結果

使用函數式編程實現一個加法計算器並自帶判斷是否等於某個值的功能函數式編程

//建立一個CaculatorMaker類，.h代碼：
@interface CaculatorMaker : NSObject

@property (nonatomic, assign) int result;
@property (nonatomic, assign, getter=isEqual) BOOL equal;

- (CaculatorMaker *)add:(int(^)(int result))caculator;
- (CaculatorMaker *)equal:(BOOL(^)(int result))caculator;

@end


//.m代碼：
@implementation CaculatorMaker

- (CaculatorMaker *)add:(int(^)(int result))caculator {
      _result = caculator(_result);
      return self;
}

- (CaculatorMaker *)equal:(BOOL(^)(int result))caculator {
      _equal = caculator(_result);
      return self;
}
@end



//調用:
CaculatorMaker *maker = [[CaculatorMaker alloc] init];
BOOL isEqual = [[[maker add:^int(int result) {
    result += 5;
    return result;
}] equal:^BOOL(int result) {
    return result == 5;
}] isEqual];

NSLog(@"%d",isEqual);

Reactive Cocoa編程思想函數

Reactive Cocoa結合了幾種編程思想:學習
- 響應式編程思想
- 函數式編程思想
因此，你有可能據說Reactive Cocoa被描述爲函數響應式編程(FRP)。
之後使用Reactive Cocoa解決問題時，就不須要考慮調用順序，直接考慮結果，把每次操做都寫成一系列嵌套方法或者函數，使代碼高聚合，易於管理。atom

Reactive Cocoa基礎類

我的認爲在Reactive Cocoa中最核心的類就是RACSignal,搞定這個類基本就可使用Reactive Cocoa開發了。

RACSignal

RACSignal:信號類，通常表示未來有數據傳遞，只要數據改變，信號內部接收到數據，就會立刻發出數據。

RACSignal簡單使用：

// RACSignal使用步驟：
// 1.建立信號 + (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe
// 2.訂閱信號,纔會激活信號. - (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
// 3.發送信號 - (void)sendNext:(id)value


// RACSignal底層實現：
// 1.建立信號，首先把didSubscribe保存到信號中，還不會觸發。
// 2.當信號被訂閱，也就是調用signal的subscribeNext:nextBlock
// 2.2 subscribeNext內部會建立訂閱者subscriber，而且把nextBlock保存到subscriber中。
// 2.1 subscribeNext內部會調用siganl的didSubscribe
// 3.siganl的didSubscribe中調用[subscriber sendNext:@1];
// 3.1 sendNext底層其實就是執行subscriber的nextBlock

// 1.建立信號
RACSignal *siganl = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {

    // block調用時刻：每當有訂閱者訂閱信號，就會調用block。

    // 3.發送信號
    [subscriber sendNext:@1];

    // 若是不在發送數據，最好發送信號完成，內部會自動調用[RACDisposable disposable]取消訂閱信號。
    [subscriber sendCompleted];

    return [RACDisposable disposableWithBlock:^{

        // block調用時刻：當信號發送完成或者發送錯誤，就會自動執行這個block,取消訂閱信號。

        // 執行完Block後，當前信號就不在被訂閱了。

        NSLog(@"信號被銷燬");

    }];
}];

// 2.訂閱信號,纔會激活信號.
[siganl subscribeNext:^(id x) {
    // block調用時刻：每當有信號發出數據，就會調用block.
    NSLog(@"接收到數據:%@",x);
}];

注意：

信號類(RACSignal),只是表示當數據改變時，信號內部會發出數據，它自己不具有發送信號的能力，而是交給內部一個訂閱者發送出去。
默認一個信號都是冷信號，也就是值改變了，也不會觸發，只有訂閱了這個信號，這個信號纔會變爲熱信號，值改變了纔會觸發。
如何訂閱信號：調用信號類RACSignal的subscribeNext就能訂閱。

RACSubscriber

RACSubscriber:表示訂閱者的意思,用於發送信號，這是一個協議，不是一個類，只要遵照這個協議，而且實現方法才能成爲訂閱者。經過create建立的信號，都有一個訂閱者，幫助他發送數據。

RACDisposable

RACDisposable:用於取消訂閱或者清理資源，當信號發送完成或者發送錯誤的時候，就會自動觸發它。

使用場景：當不想監聽某個信號時，能夠經過它來主動取消訂閱信號

RACSubject

RACSubject:信號提供者，本身能夠充當信號，又能夠發送信號。

使用場景：一般用來代替代理，有了它，就不須要定義代理了

RACSubject簡單使用

// RACSubject使用步驟
// 1.建立信號 [RACSubject subject]，跟RACSiganl不同，建立信號時沒有block。
// 2.訂閱信號 - (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
// 3.發送信號 sendNext:(id)value

// RACSubject:底層實現和RACSignal不同。
// 1.調用subscribeNext訂閱信號，只是把訂閱者保存起來，而且訂閱者的nextBlock已經賦值了。
// 2.調用sendNext發送信號，遍歷剛剛保存的全部訂閱者，一個一個調用訂閱者的nextBlock。

// 1.建立信號
RACSubject *subject = [RACSubject subject];

// 2.訂閱信號
[subject subscribeNext:^(id x) {
    // block調用時刻：當信號發出新值，就會調用.
    NSLog(@"第一個訂閱者%@",x);
}];
[subject subscribeNext:^(id x) {
    // block調用時刻：當信號發出新值，就會調用.
    NSLog(@"第二個訂閱者%@",x);
}];

// 3.發送信號
[subject sendNext:@"1"];

RACSubject代替代理

// 需求:
// 1.給當前控制器添加一個按鈕，modal到另外一個控制器界面
// 2.另外一個控制器view中有個按鈕，點擊按鈕，通知當前控制器

步驟一：在第二個控制器.h，添加一個RACSubject代替代理。
@interface TwoViewController : UIViewController

@property (nonatomic, strong) RACSubject *delegateSignal;

@end

步驟二：監聽第二個控制器按鈕點擊
@implementation TwoViewController
- (IBAction)notice:(id)sender {
// 通知第一個控制器，告訴它，按鈕被點了

 // 通知代理
 // 判斷代理信號是否有值
if (self.delegateSignal) {
    // 有值，才須要通知
    [self.delegateSignal sendNext:nil];
}
}
@end

步驟三：在第一個控制器中，監聽跳轉按鈕，給第二個控制器的代理信號賦值，而且監聽.
@implementation OneViewController 
- (IBAction)btnClick:(id)sender {

// 建立第二個控制器
TwoViewController *twoVc = [[TwoViewController alloc] init];

// 設置代理信號
twoVc.delegateSignal = [RACSubject subject];

// 訂閱代理信號
[twoVc.delegateSignal subscribeNext:^(id x) {

    NSLog(@"點擊了通知按鈕");
}];

// 跳轉到第二個控制器
[self presentViewController:twoVc animated:YES completion:nil];

}
@end

RACReplaySubject

RACReplaySubject:重複提供信號類，RACSubject的子類。

RACReplaySubject與RACSubject區別：RACReplaySubject能夠先發送信號，在訂閱信號，RACSubject就不能夠。
使用場景一：若是一個信號每被訂閱一次，就須要把以前的值重複發送一遍，使用重複提供信號類。
使用場景二：能夠設置capacity數量來限制緩存的value的數量,即只緩充最新的幾個值。

RACReplaySubject簡單使用

// RACReplaySubject使用步驟:
// 1.建立信號 [RACSubject subject]，跟RACSiganl不同，建立信號時沒有block。
// 2.能夠先訂閱信號，也能夠先發送信號。
// 2.1 訂閱信號 - (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
// 2.2 發送信號 sendNext:(id)value

// RACReplaySubject:底層實現和RACSubject不同。
// 1.調用sendNext發送信號，把值保存起來，而後遍歷剛剛保存的全部訂閱者，一個一個調用訂閱者的nextBlock。
// 2.調用subscribeNext訂閱信號，遍歷保存的全部值，一個一個調用訂閱者的nextBlock

// 若是想當一個信號被訂閱，就重複播放以前全部值，須要先發送信號，在訂閱信號。
// 也就是先保存值，在訂閱值。

// 1.建立信號
RACReplaySubject *replaySubject = [RACReplaySubject subject];

// 2.發送信號
[replaySubject sendNext:@1];
[replaySubject sendNext:@2];

// 3.訂閱信號
[replaySubject subscribeNext:^(id x) {

    NSLog(@"第一個訂閱者接收到的數據%@",x);
}];

// 訂閱信號
[replaySubject subscribeNext:^(id x) {

    NSLog(@"第二個訂閱者接收到的數據%@",x);
}];

RACTuple

RACTuple:元組類,相似NSArray,用來包裝值.

RACSequence

RACSequence:RAC中的集合類，用於代替NSArray,NSDictionary,可使用它來快速遍歷數組和字典。

使用場景：字典轉模型

`RACSequence`和`RACTuple`簡單使用：

// 1.遍歷數組
NSArray *numbers = @[@1,@2,@3,@4];

// 這裏實際上是三步
// 第一步: 把數組轉換成集合RACSequence numbers.rac_sequence
// 第二步: 把集合RACSequence轉換RACSignal信號類,numbers.rac_sequence.signal
// 第三步: 訂閱信號，激活信號，會自動把集合中的全部值，遍歷出來。
[numbers.rac_sequence.signal subscribeNext:^(id x) {

    NSLog(@"%@",x);
}];


// 2.遍歷字典,遍歷出來的鍵值對會包裝成RACTuple(元組對象)
NSDictionary *dict = @{@"name":@"xmg",@"age":@18};
[dict.rac_sequence.signal subscribeNext:^(RACTuple *x) {

    // 解包元組，會把元組的值，按順序給參數裏面的變量賦值
    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 = [NSArray arrayWithContentsOfFile:filePath];

NSMutableArray *items = [NSMutableArray array];

for (NSDictionary *dict in dictArr) {
    FlagItem *item = [FlagItem flagWithDict:dict];
    [items addObject:item];
}

// 3.2 RAC寫法
NSString *filePath = [[NSBundle mainBundle] pathForResource:@"flags.plist" ofType:nil];

NSArray *dictArr = [NSArray arrayWithContentsOfFile:filePath];

NSMutableArray *flags = [NSMutableArray array];

_flags = flags;

// rac_sequence注意點：調用subscribeNext，並不會立刻執行nextBlock，而是會等一會。
[dictArr.rac_sequence.signal subscribeNext:^(id x) {
    // 運用RAC遍歷字典，x：字典

    FlagItem *item = [FlagItem flagWithDict:x];

    [flags addObject:item];

}];

NSLog(@"%@",  NSStringFromCGRect([UIScreen mainScreen].bounds));


// 3.3 RAC高級寫法:
NSString *filePath = [[NSBundle mainBundle] pathForResource:@"flags.plist" ofType:nil];

NSArray *dictArr = [NSArray arrayWithContentsOfFile:filePath];
// map:映射的意思，目的：把原始值value映射成一個新值
// array: 把集合轉換成數組
// 底層實現：當信號被訂閱，會遍歷集合中的原始值，映射成新值，而且保存到新的數組裏。
NSArray *flags = [[dictArr.rac_sequence map:^id(id value) {

    return [FlagItem flagWithDict:value];

}] array];

RACCommand

RACCommand:RAC中用於處理事件的類，能夠把事件如何處理,事件中的數據如何傳遞，包裝到這個類中，他能夠很方便的監控事件的執行過程。

使用場景：監聽按鈕點擊，網絡請求

RACCommand簡單使用

// 1、RACCommand使用步驟:
// 1.建立命令 initWithSignalBlock:(RACSignal * (^)(id input))signalBlock
// 2.在signalBlock中，建立RACSignal，而且做爲signalBlock的返回值
// 3.執行命令 - (RACSignal *)execute:(id)input

// 2、RACCommand使用注意:
// 1.signalBlock必需要返回一個信號，不能傳nil.
// 2.若是不想要傳遞信號，直接建立空的信號[RACSignal empty];
// 3.RACCommand中信號若是數據傳遞完，必須調用[subscriber sendCompleted]，這時命令纔會執行完畢，不然永遠處於執行中。
// 4.RACCommand須要被強引用，不然接收不到RACCommand中的信號，所以RACCommand中的信號是延遲發送的。

// 3、RACCommand設計思想：內部signalBlock爲何要返回一個信號，這個信號有什麼用。
// 1.在RAC開發中，一般會把網絡請求封裝到RACCommand，直接執行某個RACCommand就能發送請求。
// 2.當RACCommand內部請求到數據的時候，須要把請求的數據傳遞給外界，這時候就須要經過signalBlock返回的信號傳遞了。

// 4、如何拿到RACCommand中返回信號發出的數據。
// 1.RACCommand有個執行信號源executionSignals，這個是signal of signals(信號的信號),意思是信號發出的數據是信號，不是普通的類型。
// 2.訂閱executionSignals就能拿到RACCommand中返回的信號，而後訂閱signalBlock返回的信號，就能獲取發出的值。

// 5、監聽當前命令是否正在執行executing

// 6、使用場景,監聽按鈕點擊，網絡請求


// 1.建立命令
RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {


    NSLog(@"執行命令");

    // 建立空信號,必須返回信號
    //        return [RACSignal empty];

    // 2.建立信號,用來傳遞數據
    return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {

        [subscriber sendNext:@"請求數據"];

        // 注意：數據傳遞完，最好調用sendCompleted，這時命令才執行完畢。
        [subscriber sendCompleted];

        return nil;
    }];

}];

// 強引用命令，不要被銷燬，不然接收不到數據
_conmmand = command;

// 3.訂閱RACCommand中的信號
[command.executionSignals subscribeNext:^(id x) {

    [x subscribeNext:^(id x) {

        NSLog(@"%@",x);
    }];

}];

// RAC高級用法
// switchToLatest:用於signal of signals，獲取signal of signals發出的最新信號,也就是能夠直接拿到RACCommand中的信號
[command.executionSignals.switchToLatest subscribeNext:^(id x) {

    NSLog(@"%@",x);
}];

// 4.監聽命令是否執行完畢,默認會來一次，能夠直接跳過，skip表示跳過第一次信號。
[[command.executing skip:1] subscribeNext:^(id x) {

    if ([x boolValue] == YES) {
        // 正在執行
        NSLog(@"正在執行");

    }else{
        // 執行完成
        NSLog(@"執行完成");
    }

}];
   // 5.執行命令
[self.conmmand execute:@1];

RACMulticastConnection

RACMulticastConnection:用於當一個信號被屢次訂閱時，爲了保證建立信號時，避免屢次調用建立信號中的block，形成反作用，可使用這個類處理。

使用注意：RACMulticastConnection經過RACSignal的-publish或者-muticast:方法建立。

RACMulticastConnection簡單使用

// RACMulticastConnection使用步驟:
// 1.建立信號 + (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe
// 2.建立鏈接 RACMulticastConnection *connect = [signal publish];
// 3.訂閱信號,注意：訂閱的不在是以前的信號，而是鏈接的信號。 [connect.signal subscribeNext:nextBlock]
// 4.鏈接 [connect connect]

// RACMulticastConnection底層原理:
// 1.建立connect，connect.sourceSignal -> RACSignal(原始信號)  connect.signal -> RACSubject
// 2.訂閱connect.signal，會調用RACSubject的subscribeNext，建立訂閱者，並且把訂閱者保存起來，不會執行block。
// 3.[connect connect]內部會訂閱RACSignal(原始信號)，而且訂閱者是RACSubject
// 3.1.訂閱原始信號，就會調用原始信號中的didSubscribe
// 3.2 didSubscribe，拿到訂閱者調用sendNext，實際上是調用RACSubject的sendNext
// 4.RACSubject的sendNext,會遍歷RACSubject全部訂閱者發送信號。
// 4.1 由於剛剛第二步，都是在訂閱RACSubject，所以會拿到第二步全部的訂閱者，調用他們的nextBlock


// 需求：假設在一個信號中發送請求，每次訂閱一次都會發送請求，這樣就會致使屢次請求。
// 解決：使用RACMulticastConnection就能解決.

// 1.建立請求信號
   RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    NSLog(@"發送請求");
    return nil;
}];
// 2.訂閱信號
[signal subscribeNext:^(id x) {
    NSLog(@"接收數據");
}];
// 2.訂閱信號
[signal subscribeNext:^(id x) {
    NSLog(@"接收數據");
}];

// 3.運行結果，會執行兩遍發送請求，也就是每次訂閱都會發送一次請求

// RACMulticastConnection:解決重複請求問題
// 1.建立信號
RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    NSLog(@"發送請求");
    [subscriber sendNext:@1];

    return nil;
}];

// 2.建立鏈接
RACMulticastConnection *connect = [signal publish];

// 3.訂閱信號，
// 注意：訂閱信號，也不能激活信號，只是保存訂閱者到數組，必須經過鏈接,當調用鏈接，就會一次性調用全部訂閱者的sendNext:
[connect.signal subscribeNext:^(id x) {
    NSLog(@"訂閱者一信號");
}];

[connect.signal subscribeNext:^(id x) {
    NSLog(@"訂閱者二信號");
}];

// 4.鏈接,激活信號
[connect connect];