RAC中将冷信号转为热信号

我在之前一篇文章说到过冷信号带来的问题, 有时候通过将其转为热信号就可以避免, 这篇文章将会介绍如何将一个冷信号转为热信号。

直接上代码吧

RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
    [subscriber sendNext:@"signal"];
    return nil;
}];
RACSubject *subject = [RACSubject subject];
[subject subscribeNext:^(id  _Nullable x) {
    NSLog(@"%@",x);
}];
[signal1 subscribe:subject];

首先RACSubject 是遵守 RACSubscriber 协议的，所以我们可以将 subject 当作 subscriber 传入subscribe方法中。subscripe 的实现如下

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

可以看到 self.didSubscribe(subscriber); 这里调用了signal 的 didSubscribe 这个block ，并且将 subscriber(也就是subject) 作为参数传入。看过上篇文章你就会知道，第一段代码中block会被执行，也就是 [subscriber sendNext:@"signal"]; 也会被执行，这里的subscriber其实还是我们创建的subject，这样的话，第一段代码其实可以简化为

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

不过平时我们不会这么去使用，RACSignal+Operationsn 这个类别中提供了更多优良姿势，下面一一介绍。

方式2: multicast

用法如下：

RACSignal *signal1 = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
    [subscriber sendNext:@"signal1"];
    return nil;
}];
RACSubject *subject1 = [RACSubject subject];
RACMulticastConnection *connection = [signal1 multicast:subject1];
[connection.signal subscribeNext:^(id  _Nullable x) {
    NSLog(@"%@",x);
}];
[connection connect];

首先我们看一下 muticast 的实现

- (RACMulticastConnection *)multicast:(RACSubject *)subject {
	[subject setNameWithFormat:@"[%@] -multicast: %@", self.name, subject.name];
	RACMulticastConnection *connection = [[RACMulticastConnection alloc] initWithSourceSignal:self subject:subject];
	return connection;
}
- (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;
}

其实就是生成了一个 RACMulticastConnection 实例，并将 signal(sourceSignal) 和 subject(signal) 分别保存起来。
所以，下面对 connection.signal 的订阅就是对subject的订阅。

接下来再来看一下 connect 的实现

- (RACDisposable *)connect {
	BOOL shouldConnect = OSAtomicCompareAndSwap32Barrier(0, 1, &_hasConnected);
	if (shouldConnect) {
		self.serialDisposable.disposable = [self.sourceSignal subscribe:_signal];
	}
	return self.serialDisposable;
}

可以看到 [self.sourceSignal subscribe:_signal]; 这里其实就是 [signal subscripe:subject] 不再多说。
这里有必要说一下 OSAtomicCompareAndSwap32Barrier
原型如下

bool OSAtomicCompareAndSwap32Barrier( int32_t __oldValue, int32_t __newValue, volatile int32_t *__theValue );

如果 __theValue 的值是 __oldValue 该方法会将 __theValue 由 __oldValue 换为 __newValue 并且返回YES,而如果 __theValue 的值已经是 __newValue，则不做交换并且返回NO。因此 connect 方法中 subscribe 方法只会被执行一次。

除了connect之外，RACMulticastConnection 类中还提供了一个autoconnect方法，实现如下

- (RACSignal *)autoconnect {
	__block volatile int32_t subscriberCount = 0;
	return [[RACSignal
		createSignal:^(id<RACSubscriber> subscriber) {
			OSAtomicIncrement32Barrier(&subscriberCount);
			RACDisposable *subscriptionDisposable = [self.signal subscribe:subscriber];
			RACDisposable *connectionDisposable = [self connect];
			return [RACDisposable disposableWithBlock:^{
				[subscriptionDisposable dispose];
				if (OSAtomicDecrement32Barrier(&subscriberCount) == 0) {
					[connectionDisposable dispose];
				}
			}];
		}]
		setNameWithFormat:@"[%@] -autoconnect", self.signal.name];
}

他会返回一个RACDynamicSignal ，但这个信号被订阅时执行connect方法，因此使用autoconnect的姿势如下：

RACSignal *signal1 = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
    [subscriber sendNext:@"signal1"];
    return nil;
}];
RACSubject *subject1 = [RACSubject subject];
RACMulticastConnection *connection = [signal1 multicast:subject1];
RACSignal *autoSignal = [connection autoconnect];
[autoSignal subscribeNext:^(id  _Nullable x) {
    NSLog(@"%@",x);
}];

RACMulticastConnection 用于将一个信号的订阅分享给多个订阅者，你需要使用 [RACSignal publish] 或者 [RACSignal multicast:] 来实例RACMulticastConnection对象，并且使用 connect 或 autoconnect 来执行订阅

方式3: publish

在 RACSignal+Operations 这个类别中提供了publish方法来生成RACMulticastConnection示例，实现如下：

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

该方法只是对 multicast 方法的一个简单封装(在内部创建一个subject并对其multicast)，使用 publish 更为方便快捷。使用如下：

RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
     [subscriber sendNext:@"signal1"];
     return nil;
}];
RACMulticastConnection *connection = [signal publish];
[connection.signal subscribeNext:^(id  _Nullable x) {
     NSLog(@"%@",x);
}];//相当于 [subject subscribeNext:...]
[connection connect]; //相当于 [subject sendNext:@"signal1"]

在 RACSignal+Operations 中除了 multicast 与 publish 方法外，还提供了 replay 、replayLast、replayLazily 这三个方法。其实他们都是对 multicast 方法的封装

方式4: replay

实现如下

- (RACSignal *)replay {
	RACReplaySubject *subject = [[RACReplaySubject subject] setNameWithFormat:@"[%@] -replay", self.name];
	RACMulticastConnection *connection = [self multicast:subject];
	[connection connect];
	return connection.signal;
}

publish中操作的是RACSubject并且没有执行connect方法然后返回的是connection实例，而replay是对RACReplaySubject的操作，并且执行了connect方法，返回值是RACReplaySubject的实例。那么我们接受到replay的返回值其实就是拿到了由冷信号转换得到的RACReplaySubject，由于执行过connect方法，所以这个热信号已经进行过sendnext，后续只需要对其订阅即可触发。使用如下：

RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
     [subscriber sendNext:@"signal1"];
     return nil;
}];
RACReplaySubject *rpSubjecxt = [signal replay]; //内部已执行 [rpSubjecxt sendNext:@"signal1"]
[rpSubjecxt subscribeNext:^(id  _Nullable x) {
    NSLog(@"%@",x);
}];

方式5: replayLast

- (RACSignal *)replayLast {
	RACReplaySubject *subject = [[RACReplaySubject replaySubjectWithCapacity:1] setNameWithFormat:@"[%@] -replayLast", self.name];
	RACMulticastConnection *connection = [self multicast:subject];
	[connection connect];
	return connection.signal;
}

可以看到 replayLast 的实现与replay想比只是在对RACReplaySubject的初始化方法，这里将RACReplaySubject中valuesReceived数组的capacity设为1, 所以当这个RACReplaySubject被订阅时只会执行“在他之前的的最后一个” sendNext。 replayLast 顾名思义只会重复订阅之前最后的一条sendNext。

方式6: replayLazily

- (RACSignal *)replayLazily {
	RACMulticastConnection *connection = [self multicast:[RACReplaySubject subject]];
	return [[RACSignal
		defer:^{
			[connection connect];
			return connection.signal;
		}]
		setNameWithFormat:@"[%@] -replayLazily", self.name];
}

和replay不同的是这里将 connect 操作套在了 defer 方法里面(defer将RACReplaySubject用RACDynamicSignal包裹起来)。

我们来看defer的实现

+ (RACSignal *)defer:(RACSignal<id> * (^)(void))block {
	NSCParameterAssert(block != NULL);
	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
		return [block() subscribe:subscriber];
	}] setNameWithFormat:@"+defer:"];
}

只有 defer 方法返回的信号被订阅之后才会执行 return [block() subscribe:subscriber]; ，
将 return [block() subscribe:subscriber]; 展开就是

[connection connect];
return [connection.signal subscripe:subscriber];

因此 replayLazily 返回的信号只有在被订阅的时候才会执行 [connection.signal subscripe:subscriber]， replayLazily 叫做 replayLazily 再合适不过。

replayLazily 的使用如下:

RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        [subscriber sendNext:@"signal1"];
        [subscriber sendNext:@"signal2"];
        return nil;
    }];
RACSignal *rplaSignal = [signal replayLazily]; 
[rplaSignal subscribeNext:^(id  _Nullable x) {
     NSLog(@"%@",x);
}]; // rplaSignal 被订阅时 才会执行内部的 `[connection.signal(RACReplaySubject) subscripe:subscriber]` 操作

总结

通过冷信号subscribe一个热信号即可通过将热信号当作subscriber(订阅者)来进行sendNext等操作，也就是将冷信号转为了热信号；
multicast就是基于上述原理来实现的；
publish replay replayLast replayLazily 都是基于 multicast 的封装,满足上的不同使用场景。

方式1: subscribe

方式2: multicast

方式3: publish

方式4: replay

方式5: replayLast

方式6: replayLazily

总结