RAC学习理解记录（一）

作者: 一叶菜 | 来源:发表于2016-12-31 00:31 被阅读56次

最近在研究RAC，写些自己在学习过程中遇到的问题。如有疑问，欢迎大家多多指教~
对于RAC的介绍，就略过不讲，网上很多教程了。

RAC的导入

我们在使用 CocoaPods 导入 RAC 时，OC情况下推荐使用2.5版本的，因为后面版本是支持swift的。
pod 'ReactiveCocoa', '~>2.5'

我在导入的过程中报了错（具体啥错，忘啦~），记得用 target：
target '你的项目名称' do pod 'ReactiveCocoa', '~>2.5' end

然后开始愉快的 pod install吧，大功告成之后，我们需要把头文件 #import <ReactiveCocoa.h> 加入进来，你懂的。

接下来就是你 piapiapiapia~ 键盘的时候了。

先来些RAC的传送门

iOS RAC学习笔记从零起步（第一天至第四天系列）
RAC资源帖
 最快让你上手ReactiveCocoa之基础篇
 RAC稍深入-适合新手学习RAC
最快让你上手ReactiveCocoa之进阶篇（有些常用方法的介绍，较详细）

 这些呢，都需要手动敲代码慢慢研究的~

RACMulticastConnection 的简单使用

RACMulticastConnection使用步骤:
1.创建信号 + (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe
2.创建连接 RACMulticastConnection *connect = [signal publish];
3.订阅信号,注意：订阅的不在是之前的信号，而是连接的信号。     
  [connect.signal subscribeNext:nextBlock]
4.连接 [connect connect]

先看下面一段代码：

-(void)createRac
{
    RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        
        NSLog(@"发送数据一叶菜");
        [subscriber sendNext:@"一叶菜"];
        NSLog(@"发送数据了...");

        [subscriber sendCompleted];
        NSLog(@"发送数据完成");

        return [RACDisposable disposableWithBlock:^{
            NSLog(@"====信号被销毁");
        }];
    }];
    
    [signal subscribeNext:^(id x) {
        NSLog(@"===1接到数据：%@",x);
    }];
    
    [signal subscribeNext:^(id x) {
        NSLog(@"====2接收数据：%@",x);
    }];
    
    
    // RACMulticastConnection:解决重复请求问题
    // 1.创建信号
    RACSignal *connectSignal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        
        NSLog(@"====connectSignal=开始发送请求");
        [subscriber sendNext:@1];
        NSLog(@"=connectSignal发送数据了...");

        return [RACDisposable disposableWithBlock:^{
            NSLog(@"====connectSignal被销毁");
        }];
        return nil;
    }];
    
    RACMulticastConnection *connection = [connectSignal publish];
    [connection.signal subscribeNext:^(id x) {
        NSLog(@"==connection订阅者1信号==:%@",x);
    }];
    
    [connection.signal subscribeNext:^(id x) {
        NSLog(@"==connection订阅者2信号==:%@",x);
    }];
    [connection connect];
}

猜猜会打印出什么？

2016-12-31 00:21:08.989 buttonCaterogy[3459:111146] 发送数据一叶菜
2016-12-31 00:21:08.989 buttonCaterogy[3459:111146] ===1接到数据：一叶菜
2016-12-31 00:21:08.989 buttonCaterogy[3459:111146] 发送数据了...
2016-12-31 00:21:08.989 buttonCaterogy[3459:111146] 发送数据完成
2016-12-31 00:21:08.989 buttonCaterogy[3459:111146] ====信号被销毁
2016-12-31 00:21:08.990 buttonCaterogy[3459:111146] 发送数据一叶菜
2016-12-31 00:21:08.990 buttonCaterogy[3459:111146] ====2接收数据：一叶菜
2016-12-31 00:21:08.990 buttonCaterogy[3459:111146] 发送数据了...
2016-12-31 00:21:08.990 buttonCaterogy[3459:111146] 发送数据完成
2016-12-31 00:21:08.990 buttonCaterogy[3459:111146] ====信号被销毁
2016-12-31 00:21:08.991 buttonCaterogy[3459:111146] ====connectSignal=开始发送请求
2016-12-31 00:21:08.991 buttonCaterogy[3459:111146] ==connection订阅者1信号==:1
2016-12-31 00:21:08.991 buttonCaterogy[3459:111146] ==connection订阅者2信号==:1
2016-12-31 00:21:08.992 buttonCaterogy[3459:111146] =connectSignal发送数据了...
2016-12-31 00:21:08.995 buttonCaterogy[3459:111146] ====connectSignal被销毁

我们可以很明显的看到,当我们用`RACSignal`创建信号，订阅2次信号时， `发送数据一叶菜`、`发送数据了...`、`发送数据完成`和`====信号被销毁`，每次都会执行;
而且我们每次订阅信号时，都会执行创建信号block， 在信号`sendNext`后，会立刻跑进订阅信号`subscribeNext`那里，执行订阅block,然后回来执行`发送数据了...`，
注意是每一次订阅都会调用创建信号中的block。
而当用`RACMulticastConnection`的 `signal` 订阅2次时，`=connectSignal=开始发送请求`和`====connectSignal被销毁`,只执行了一次。

 这就说明了RACMulticastConnection的原理及对应使用场景:
 我们在创建RACMulticastConnection后，订阅connect.signal并不会
 立刻执行发送信号执行block,它是把订阅者保存起来，然后等到[connect connect]，
 遍历RACSubject所有订阅者发送信号。
 假设在一个信号中发送请求，每次订阅一次都会发送请求，这样就会导致多次请求。
我们也就更好的理解了这句话：
RACMulticastConnection:用于当一个信号，被多次订阅时，为了保证创建信号时，避免多次调用创建信号中的block，造成副作用，可以使用这个类处理。

RACCommand简单使用

RACCommand是重中之重啊，当你学会RACCommand时，你的数据请求就可以封装到这里啦~

一、RACCommand使用步骤:
 1.创建命令 initWithSignalBlock:(RACSignal * (^)(id input))signalBlock
 2.在signalBlock中，创建RACSignal，并且作为signalBlock的返回值
 3.执行命令 - (RACSignal *)execute:(id)input
 记得最后一定要执行`excute:` ，不然订阅信号是不会执行的。

我们先看下面一段代码：


-(void)initRACCommand
{
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
        NSLog(@"====command 创建信号");
//        return [RACSignal empty];
        
        return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
            [subscriber sendNext:@"RACCommand 发送数据"];
            NSLog(@"===发送数据了...");
            [subscriber sendCompleted];
            NSLog(@"===发送完成...");

            return nil;
        }];
    }] ;
    
    [command.executionSignals subscribeNext:^(id x) {
        NSLog(@"===command订阅信号x:%@",x);
        [x subscribeNext:^(id x) {
            NSLog(@"===x订阅信号:%@",x);
        }];
    }];
    [command execute:@1];
}

打印的信息：

2016-12-31 11:26:45.818 buttonCaterogy[5247:178605] ====command 创建信号
2016-12-31 11:26:45.827 buttonCaterogy[5247:178605] ===command订阅信号x:<RACDynamicSignal: 0x608000033fa0> name: 
2016-12-31 11:26:45.828 buttonCaterogy[5247:178605] ===x订阅信号:RACCommand 发送数据
2016-12-31 11:26:45.828 buttonCaterogy[5247:178605] ===发送数据了...
2016-12-31 11:26:45.828 buttonCaterogy[5247:178605] ===发送完成...

我们在订阅RACCommand信号后，可以看到先打印出来的===command订阅信号x:<RACDynamicSignal: 0x608000033fa0> name: 是RACDynamicSignal,接下来再用这个x 去订阅信号，即

[x subscribeNext:^(id x) {
            NSLog(@"===x订阅信号:%@",x);
        }];

才返回我们在SignalBlock里面创建的信号:===x订阅信号:RACCommand 发送数据

首先呢，RACCommand 的SignalBlock返回的是一个信号，如果你只是想直接发送数据请求，不返回信号的话，可以直接返回空的信号[RACSignal empty]，在返回前执行你不需要返回信号只发其他命令的操作。但是呢，我们的数据请求，是不是一般都会返回数据，如果我有返回的数据，那么我怎么把返回的数据传递出去呢？对了，就是创建一个RACSignal，通过它创建的信号把数据发送sendNext出去，那么我们在command.executionSignals里返回的RACDynamicSignal里再执行一次订阅信号，就可以拿到我们刚才发出去的数据了，是不是很巧妙？
这就可以解释了我们为什么要在SignalBlock里面创建信号了。

再去体会一下下面的说法：
 1.RACCommand有个执行信号源executionSignals，这个是signal of signals(信号的信号),意思是信号发出的数据是信号，不是普通的类型。
 2.订阅executionSignals就能拿到RACCommand中返回的信号，然后订阅signalBlock返回的信号，就能获取发出的值。

如果你不想在command.executionSignals里返回的RACDynamicSignal里再执行一次订阅信号，
可以直接用switchToLatest拿到最新的信号：

   [command.executionSignals.switchToLatest subscribeNext:^(id x) {
        
        NSLog(@"===Latest信号：%@",x);
    }];

2016-12-31 12:18:02.378 buttonCaterogy[6395:221451] ===Latest信号：RACCommand 发送数据

 打印出的结果是一样的

关于RACCommand的强引用

RACCommand需要被强引用，否则接收不到RACCommand中的信号，
因此RACCommand中的信号是延迟发送的。

我们来看下面一段代码：

-(void)initRACCommand
{
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
        NSLog(@"====command 创建信号");
//        return [RACSignal empty];
        
        return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
            [subscriber sendNext:@"RACCommand 发送数据"];
            NSLog(@"===发送数据了...");
            [subscriber sendCompleted];
            NSLog(@"===发送完成...");

            return nil;
        }];
    }] ;
 
    // RAC高级用法
    // switchToLatest:用于signal of signals，获取signal of signals发出的最新信号,也就是可以直接拿到RACCommand中的信号
    [command.executionSignals.switchToLatest subscribeNext:^(id x) {
        
        NSLog(@"===Latest信号：%@",x);
    }];
    
    NSLog(@"command 执行前");
    [command execute:@1];
    NSLog(@"command 开始执行了...");
    NSLog(@"command 执行了1...");
    
    [self initRacTupe];

    NSLog(@"command 执行了2...");
}

-(void)initRacTupe
{
    NSArray *numbers = @[@1,@2,@3,@4];
    [numbers.rac_sequence.signal subscribeNext:^(id x) {
        NSLog(@"==数字%@",x);
    }];
    
    NSDictionary *dict = @{@"name":@"liuwenjing",@"age":@18};
    [dict.rac_sequence.signal subscribeNext:^(RACTuple *x) {
        RACTupleUnpack(NSString *key,NSString *value) = x;
        NSLog(@"====key:%@,value:%@",key,value);
    }];
}

2016-12-31 12:35:06.503 buttonCaterogy[6855:236379] command 执行前
2016-12-31 12:35:06.504 buttonCaterogy[6855:236379] ====command 创建信号
2016-12-31 12:35:06.505 buttonCaterogy[6855:236379] command 开始执行了...
2016-12-31 12:35:06.506 buttonCaterogy[6855:236379] command 执行了1...
2016-12-31 12:35:06.506 buttonCaterogy[6855:236379] command 执行了2...
2016-12-31 12:35:06.506 buttonCaterogy[6855:236629] ==数字1
2016-12-31 12:35:06.506 buttonCaterogy[6855:236676] ====key:name,value:liuwenjing
2016-12-31 12:35:06.506 buttonCaterogy[6855:236629] ==数字2
2016-12-31 12:35:06.506 buttonCaterogy[6855:236676] ====key:age,value:18
2016-12-31 12:35:06.506 buttonCaterogy[6855:236629] ==数字3
2016-12-31 12:35:06.507 buttonCaterogy[6855:236629] ==数字4
2016-12-31 12:35:06.515 buttonCaterogy[6855:236379] ===Latest信号：RACCommand 发送数据
2016-12-31 12:35:06.515 buttonCaterogy[6855:236379] ===发送数据了...
2016-12-31 12:35:06.515 buttonCaterogy[6855:236379] ===发送完成...

我们在[command execute:@1];执行前、后分别有打印，从打印的结果可以看到，在发出[command execute:@1];后，程序立刻跑进[[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input)创建信号那里，但没有接着走SignalBlock里的发送信号，而是回来执行command 开始执行了...,command 执行了1...,command 执行了2...,[ initRacTupe],当initRacTupe执行完后，又回到创建信号那里去发送信号。

由此可见：RACCommand中的信号是延迟发送的。

具体实例

我们可以看一下 iOS MVVM+RAC 从框架到实战这里面的例子，会对RAC有个很好的理解。下载了它的源码后，配合作者的文章研究一下

81BC6724-8138-4BB5-AB65-F32977829136.png
LSCircleListViewController这个类，它有一个LSCircleListViewModel类的viewModel属性

FCABAE2C-379E-4E44-A35C-70677CA1916C.png

在yd_bindViewModel方法里使用self.viewModel的cellClickSubject订阅信号

FB63CC46-C00F-4215-AE7F-C815F7F61817.png

yd_bindViewModel方法，来自于YDViewController基类，订阅viewDidLoad方法

B64C9B5E-7FBA-467B-8673-F05E5E9FB998.png

这里可以看出，我们可以在alloc或者allocWithZone方法里，用rac_signalForSelector实现viewDidLoad等方法的订阅，当然也就可以实现其他方法的订阅，比如改写一些方法的实现啦。
回到之前看到在yd_bindViewModel方法里使用self.viewModel的cellClickSubject订阅信号，可想而知cellClickSubject是一个信号

3572FDE3-F0DC-4853-B213-F67F847D7A5D.png

RAC学习理解记录（一）

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读