初识RAC

RAC - ReactiveCocoa, 是github上的一套开源框架, 是一套函数响应式编程框架.

那么这套框架是干什么用的呢?

RAC中很重要的一个类叫做RACsignal, 当我们有数据产生时, 就创建一个信号, 这么说可能太抽象了

RACSignal在创建对象的时候, 不是用的alloc,init方法, 而是给我们提供了一个类方法:

+ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe

在这个类方法中, 有一个参数didSubscribe, 这是一个block, 这个block是一个参数为id类型, 遵守RACSubscriber协议的对象, 返回值为RACDisposable *类型的block.

创建信号时报错

第28行报错, 这是因为你的block是一个带返回值的block, 而你又什么都没有返回, 所以不管三七二十一, 先返回一个nil. 然后我在block中做一件事情, 打印一句话, 代码如下:

- (void)viewDidLoad {
    [super viewDidLoad];
    RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        NSLog(@"signal has been created");
        return nil;
    }];
}

代码写到这里, 这个block中的代码会执行吗? 显然不会, 那么, 这段代码什么时候执行呢?

这个时候就需要信号订阅:
- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock

这段代码中, 又有一个block参数, 这个block是一个参数为id类型的对象, 返回值为空的block, 信号订阅时, 我在这个block中什么也不做, 上面的打印同样能够执行:

执行block

我们来看一下这个内部是怎么实现的:

+ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe {
    return [RACDynamicSignal createSignal:didSubscribe];
}

+ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe {
    RACDynamicSignal *signal = [[self alloc] init];
    signal->_didSubscribe = [didSubscribe copy];
    return [signal setNameWithFormat:@"+createSignal:"];
}

其中signal->_didSubscribe = [didSubscribe copy];这句代码将didSubscribe这个block保存在对象的属性中.

那我们来看是不是在- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock这个方法中调用了block:

- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock {
    NSCParameterAssert(nextBlock != NULL);
    
    RACSubscriber *o = [RACSubscriber subscriberWithNext:nextBlock error:NULL completed:NULL];
    return [self subscribe:o];
}

在subscribe方法中,didSubscribe方法被调用了

调用者是`RACDynamicSignal` `didSubscribe`这个`block`的执行

从上图我们可以看到, didSubscribe这个block在信号订阅的时候被调用, 在调用的同时, 把subscriber这个参数传给block, 所以我们在

RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        NSLog(@"signal has been created");
        [subscriber sendNext:@"subscriber send"];
        return nil;
    }];

这个代码块内部是可以拿到subscriber这个对象的, 然后我再调用sendNext这个方法, 会出现什么情况呢?

`sendNext`触发block的调用

我们发现, subscribeNext:方法参数的block被调用了

那我们来看看sendNext这个方法内部做了什么?

执行`nextBlock`

这个方法执行了我当初保存在subscriber属性中的block, 并且将value参数也传给了这个nextBlock, 所以在nextBlock执行的时候, 可以获得x参数

`block`代码块的执行详情 将`block`代码块保存在属性中

好了, 我们一直没有关注+ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe这个方法中block参数的返回值是干嘛的, 那么我们就给这个block一个返回值:

`block`的返回值

可以看到的是: 这个返回值是RACDisposable类型的, 然后我们创建一个RACDisposable对象是用+ (instancetype)disposableWithBlock:(void (^)(void))block这个类方法, 同样参数也是一个block, 但是这个block很快就被调用了, 这是为什么呢?

subscriber生存周期结束

这个返回值

RACDisposable *disposable = [RACDisposable disposableWithBlock:^{
            NSLog(@"disposable");
        }];
        return disposable;

在subscribeNext:方法调用时, 赋值给了subscriber的disposable属性(可以先这么理解), 当subscriber生存周期结束时, 就会调

- (void)dealloc {
    [self.disposable dispose];
}

这时候

RACDisposable *disposable = [RACDisposable disposableWithBlock:^{
            NSLog(@"disposable");
        }];
        return disposable;

这段代码中的打印就会执行了.

但当subscriber被强引用时, dealloc方法不被调用, disposable也不会被调用.

强引用`subscriber`时, `disposable`不会被调用

如果subscriber被强引用时, 我又想取消订阅, 应该怎么做呢?
subscribeNext:这个方法是有返回值的, 这个返回值其实就是上面didSubscribeblock的返回值(可以先这么理解)
我用一个变量接收一样, 然后手动disposable即可:

手动`disposable`

那么RACDisposable是做什么用的呢?

这个类可以帮助我们取消订阅, 当信号发送完毕了或者失败了之后取消订阅, 并调用指定的代码.

在RAC中, 还有一个类非常重要, 也很特殊, 叫做RACSubject, 这个类即可以创建信号, 也可以发送信号. 代码如下:

    RACSubject *subject = [RACSubject subject];
    [subject subscribeNext:^(id  _Nullable x) {
        NSLog(@"subject has been subscribed %@", x);
    }];
    [subject sendNext:@"subject has been sended"];

• 在创建信号的时候: 这个框架重写了init方法:

+ (instancetype)subject {
    return [[self alloc] init];
}

- (instancetype)init {
    self = [super init];
    if (self == nil) return nil;

    _disposable = [RACCompoundDisposable compoundDisposable];
    _subscribers = [[NSMutableArray alloc] initWithCapacity:1];
    
    return self;
}

• 他创建了一个可变数组. 这个可变数组是用来添加subscriber的

- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
    NSCParameterAssert(subscriber != nil);

    RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
    subscriber = [[RACPassthroughSubscriber alloc] initWithSubscriber:subscriber signal:self disposable:disposable];

    NSMutableArray *subscribers = self.subscribers;
    @synchronized (subscribers) {
        [subscribers addObject:subscriber];
    }
    
    [disposable addDisposable:[RACDisposable disposableWithBlock:^{
        @synchronized (subscribers) {
            // Since newer subscribers are generally shorter-lived, search
            // starting from the end of the list.
            NSUInteger index = [subscribers indexOfObjectWithOptions:NSEnumerationReverse passingTest:^ BOOL (id<RACSubscriber> obj, NSUInteger index, BOOL *stop) {
                return obj == subscriber;
            }];

            if (index != NSNotFound) [subscribers removeObjectAtIndex:index];
        }
    }]];

    return disposable;
}

• 然后在发送信号的时候, 会遍历这个数组, 把里面的subscriber一一取出来, 分别发送信号:

`subject`发送信号

所以, 用RACSubject的好处就是: 可以订阅多个信号, 最后发送信号的时候一起调用.

订阅多个信号

现在总结一下RACSignal和RACSubject

RACSignal

RACSubject的本质其实和RACSignal是一样的, 那为什么它又可以创建信号, 又可以订阅信号呢?

在OC中, 是没有多继承的概念的, 要想实现多继承的效果, 可以先继承一个类, 然后再实现一个或者多个协议, 这样就实现了多继承的效果

"多继承"

那么, 说了这么多, 这个RAC有什么用呢?

用处大了, 因为它可以实现KVO , 代理, 通知, block的功能, 集多种功能于一身, 当你用了RAC之后, 你可以利用RAC实现以上设计模式能实现的功能.

比如现在有一个简单的需求:
一个自定义的view上面有一个button, 点击button之后把button的背景颜色传给控制器的view. 这是典型的逆向传值, 通知, 代理, block都能用. 那用RAC怎么做呢?

• 首先是创建信号, 信号的创建需要在什么地方呢, 值从哪里传, 信号创建就在哪里, 用一个懒加载创建subject对象:

- (RACSubject *)subject {
    if (!_subject) {
        _subject = [RACSubject subject];
    }
    return _subject;
}

• 然后在button点击的时候将颜色信号传出去:

- (IBAction)buttonClick:(UIButton *)sender {
    
    [self.subject sendNext:sender.backgroundColor];
}

• 最后, 值往哪里传, 哪里就订阅信号:

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [self.yfView.subject subscribeNext:^(id  _Nullable x) {
        self.view.backgroundColor = x;
    }];
    
}

就这么简单的几步, 就完成了需求, 非常简单方便, 效果如下:

实现效果

好， 现在看另外一个重要的类， 叫做RACReplaySubject

`RACReplaySubject`是继承自`RACSubject`的

RACReplaySubject是继承自RACSubject的

有效代码

所以订阅信号里的block是可以执行的. 那么这个类和RACSubject有什么不同之处呢?

同样有效的代码

当我们将订阅信号和发送信号交换一下位置, 发现订阅的block依然可以执行, 这是跟RACSubject不同的地方. 但这是为什么呢?

这个只是初始RAC, 我也在从0开始学习, 有错误的地方, 还请大家批评指正,共同提高.

首先来看创建RACReplaySubject对象的时候, 有什么不一样

创建可变数组

可以看出的是, 这个类重写了init方法, 创建了一个名为valuesRecieved的数组.

然后, 在发送信号的过程中:

数组保存发送的信号

在发送信号的时候, 刚才创建的那个valuesReceived数组就把需要发送的信号保存在数组里. 保存在数组中干嘛呢? 且看:

真正地订阅信号 订阅信号的具体实现

从上图可以看出, 在订阅信号的时候, 会先将valuesReceived数组中保存的信号来一波遍历, 然后取出来, 自己发送掉. 这样, 就算先发送信号, 在订阅信号, 也可以完成, 因为订阅信号的内部自己也发送了信号.