RACSubject 信号提供者!!,自己可以充当信号,又能够发送信号!!

首先回顾一下

     RACDisposable:它可以帮助我们取消订阅.信号发送完毕了 ,失败了.
     
     RACSubscriber(协议):订阅者(发送信号!)
     
     RACSubject :信号提供者!!,自己可以充当信号,又能够发送信号!!
     

RACSubject：这个类叫做信号提供者,自己可以充当信号,又能够发送信号!!

@interface RACSubject<ValueType> : RACSignal<ValueType> <RACSubscriber>

编程思想：《面向协议的开发》
     
OC里边没有多继承这一说，那么我(RACSubject)想继承另一个类(RACSignal)里的功能：
就需要 我(RACSubject) 遵守 订阅者协议< RACSubscriber >，实现订阅者协议的方法，就可以了。
     
就是面向协议的开发的应用场景。

还是三步走:

1.创建信号
2.订阅信号
3.发送数据

//1.创建信号
    RACSubject *subject = [RACSubject subject];
    
    //2.订阅信号
    //不同的信号订阅的方式不一样！！因为类型不一样，所以调用的方法不一样。
    //RACSubject处理订阅 ：拿到之前的_subscribers 保存订阅者
    [subject subscribeNext:^(id  _Nullable x) {
      
        NSLog(@"接收到的数据 x 是 %@",x);
        
    }];
    
    
    
    //3.发送数据
    //遍历出所有的订阅者，其实还是调用的nextBlock
    [subject sendNext:@"数据A"];

打印的结果：

2017-06-15 16:18:54.468 RAC-demo[41104:6465743] 接收到的数据 x 是 数据A

多订阅者

//1.创建信号
    RACSubject *subject = [RACSubject subject];
    
    //2.订阅信号
    //不同的信号订阅的方式不一样！！因为类型不一样，所以调用的方法不一样。
    //RACSubject处理订阅 ：拿到之前的_subscribers 保存订阅者
    [subject subscribeNext:^(id  _Nullable x) {
      
        NSLog(@"订阅1⃣️ 接收到的数据 x 是 %@",x);
        
    }];
    [subject subscribeNext:^(id  _Nullable x) {
        
        NSLog(@"订阅2⃣️ 接收到的数据 x 是 %@",x);
        
    }];
    
  
    //3.发送数据
    //遍历出所有的订阅者，其实还是调用的nextBlock
    [subject sendNext:@"数据A"];

打印的结果：

2017-06-15 17:04:56.804 RAC-demo[41379:6621767] 订阅1⃣️ 接收到的数据 x 是 数据A

2017-06-15 17:04:56.805 RAC-demo[41379:6621767] 订阅2⃣️ 接收到的数据 x 是 数据A

实现原理

1、创建信号
订阅管理者(_disposable)、保存订阅者的数组(_subscribers)

" cmd "点"subject"进去
" [RACSubject subject] "

// This should only be used while synchronized on `self`.
@property (nonatomic, strong, readonly) NSMutableArray *subscribers;

// Contains all of the receiver's subscriptions to other signals.
@property (nonatomic, strong, readonly) RACCompoundDisposable *disposable;

+ (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;
}

- (void)dealloc {
    [self.disposable dispose];
}
作者在重写的init方法里面进行了创建信号订阅管理者(_disposable)、保存订阅者的数组(_subscribers)，
便于多个订阅者订阅
"_disposable"、"_subscribers"

2、订阅信号
RACSubject处理订阅 ：拿到之前的_subscribers 保存订阅者

"cmd"点"subscribeNext "进去
" [subject subscribeNext:^(id  _Nullable x) {}] "

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

保存Block
nextBlock

注意" [self subscribe:o] "
"cmd"点"subscribe "进去
此处的"self"代表的是"RACSubject"

- (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;
}

保存所有订阅者
[subscribers addObject:subscriber];

#@synchronized上锁的原因是：@synchronized（） 的作用是:
#创建一个互斥锁，保证在同一时间内没有其它线程对self对象进行修改，起到线程的保护作用，
#一般在公用变量的时候使用，如单例模式或者操作类的static变量中使用。

这里把订阅管理者disposable返回出去便于 手动 取消订阅

3、发送数据
遍历出所有的订阅者，其实还是调用的nextBlock

"cmd"点"sendNext"进去
"[subject sendNext:@"数据A"]"

- (void)sendNext:(id)value {
    [self enumerateSubscribersUsingBlock:^(id<RACSubscriber> subscriber) {
        [subscriber sendNext:value];
    }];
}
看到"enumerateSubscribersUsingBlock"就知道这是个循环，
就是要把之前保存的订阅者一个一个找出发送信号
#下边这个方法证实了这个的想法：
- (void)enumerateSubscribersUsingBlock:(void (^)(id<RACSubscriber> subscriber))block {
    NSArray *subscribers;
    @synchronized (self.subscribers) {
        subscribers = [self.subscribers copy];
    }

    for (id<RACSubscriber> subscriber in subscribers) {
        block(subscriber);
    }
}

#block(subscriber);
block一调用就近到了"[subscriber sendNext:value];"方法
#pragma mark RACSubscriber

- (void)sendNext:(id)value {
    @synchronized (self) {
        void (^nextBlock)(id) = [self.next copy];
        if (nextBlock == nil) return;

        nextBlock(value);
    }
}
#看到了熟悉的
nextBlock(value);
这就表示在这里进行了发送数据把保存的nextBlock一执行就实现了数据返回后的处理了。

流程图示：

实现原理图示.png