RAC实战6---RACMulticastConnection

假设用RAC做网络请求

    RACSignal * signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        NSLog(@"发送网络请求");
        
        [subscriber sendNext:@"得到网络请求数据"];
        
        return nil;
    }];
    
    [signal subscribeNext:^(id x) {
        NSLog(@"1 - %@",x);
    }];
    
    [signal subscribeNext:^(id x) {
        NSLog(@"2 - %@",x);
    }];
    
    [signal subscribeNext:^(id x) {
        NSLog(@"3 - %@",x);
    }];

我们先运行一次看看log打印就知道问题所在了。

2019-05-06 15:10:56.402721+0800 FirstRAC[14765:2309424] 发送网络请求
2019-05-06 15:10:56.402879+0800 FirstRAC[14765:2309424] 1 - 得到网络请求数据
2019-05-06 15:10:56.403048+0800 FirstRAC[14765:2309424] 发送网络请求
2019-05-06 15:10:56.403158+0800 FirstRAC[14765:2309424] 2 - 得到网络请求数据
2019-05-06 15:10:56.403295+0800 FirstRAC[14765:2309424] 发送网络请求
2019-05-06 15:10:56.403400+0800 FirstRAC[14765:2309424] 3 - 得到网络请求数据

从打印的数据可以发现进行了三次网络请求，但是在实际开发过程中，我们并不想要请求三次，我们只想请求一次就够了。这个时候就可以用RACMulticastConnection这个类了，RACMulticastConnection其实是一个连接类，连接类的意思就是当一个信号被多次订阅，他可以帮我们避免多次调用创建信号中的block，基本用法如下：

RACSignal * signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        NSLog(@"发送网络请求");
        
        [subscriber sendNext:@"得到网络请求数据"];
        
        return nil;
    }];
    
    RACMulticastConnection *connect = [signal publish];
    
    [connect.signal subscribeNext:^(id x) {
        NSLog(@"1 - %@",x);
    }];
    
    [connect.signal subscribeNext:^(id x) {
        NSLog(@"2 - %@",x);
    }];
    
    [connect.signal subscribeNext:^(id x) {
        NSLog(@"3 - %@",x);
    }];
    
    [connect connect];

运行结果

2019-05-06 15:20:52.145623+0800 FirstRAC[14870:2316911] 发送网络请求
2019-05-06 15:20:52.145784+0800 FirstRAC[14870:2316911] 1 - 得到网络请求数据
2019-05-06 15:20:52.145890+0800 FirstRAC[14870:2316911] 2 - 得到网络请求数据
2019-05-06 15:20:52.146008+0800 FirstRAC[14870:2316911] 3 - 得到网络请求数据

其中需要注意的是一定要记得[connect connect]; 否则是不会进行连接的，也就没有任何效果(无输出)。另外 [connect connect];之后再subscribeNext:也不会有结果。

RACMulticastConnection实现原理

1、创建信号这个步骤就不用在多说了（保存了一个block，didSubscribe）
2、通过RACMulticastConnection *connect = [signal publish];把信号转化成为一个连接类。

- (RACMulticastConnection *)publish {
    RACSubject *subject = [[RACSubject subject] setNameWithFormat:@"[%@] -publish", self.name];
    RACMulticastConnection *connection = [self multicast:subject];
    return connection;
}
- (RACMulticastConnection *)multicast:(RACSubject *)subject {
    [subject setNameWithFormat:@"[%@] -multicast: %@", self.name, subject.name];
    RACMulticastConnection *connection = [[RACMulticastConnection alloc] initWithSourceSignal:self subject:subject];
    return connection;
}

publish方法首先创建了一个RACSubject对象，然后multicast方法创建RACMulticastConnection对象,这个对象用RACSignal和RACSubject对象初始化了自己的成员变量。

- (instancetype)initWithSourceSignal:(RACSignal *)source subject:(RACSubject *)subject {
    NSCParameterAssert(source != nil);
    NSCParameterAssert(subject != nil);

    self = [super init];

    _sourceSignal = source;
    _serialDisposable = [[RACSerialDisposable alloc] init];
    _signal = subject;
    
    return self;
}
_sourceSignal保存的是我们创建的RACSignal对象signal，_signal保存的是RACSubject对象subject。

3.订阅信号。在订阅的时候的时候就不是原来的signal了，所以创建signal的时候传入的block并不会执行。connect.signal中的signal是在publish方法里生成的RACSubject对象，见上面的代码 _signal = subject;所以其subscribeNext:方法就是订阅信号。
4.最后的connect方法中，用之前保存在_sourceSignal中的signal订阅我们保存在_signal中的subject,也就是说在这里才是真正的订阅了我们的信号，执行了创建signal时候传入的block，调用block的参数正是这个subject，所以发送数据的其实是我们在publish中保存的subject，所以就完成了一次创建多次订阅了。之前subject被订阅了三次，所以那3个block都被执行，创建信号的block被执行一次。

- (RACDisposable *)connect {
    BOOL shouldConnect = OSAtomicCompareAndSwap32Barrier(0, 1, &_hasConnected);

    if (shouldConnect) {
        self.serialDisposable.disposable = [self.sourceSignal subscribe:_signal];
    }

    return self.serialDisposable;
}

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

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

    if (self.didSubscribe != NULL) {
        RACDisposable *schedulingDisposable = [RACScheduler.subscriptionScheduler schedule:^{
            RACDisposable *innerDisposable = self.didSubscribe(subscriber);
            [disposable addDisposable:innerDisposable];
        }];

        [disposable addDisposable:schedulingDisposable];
    }
    
    return disposable;
}

整个过程如图:

参考
https://www.jianshu.com/p/b94a0454e582 (这篇写的比较详细)