有很多在给人介绍Reactive的几个开源项目(ReactiveCocoa, RxSwift)的使用，我就不想在这个方面写什么了。我是一个实践主义者，所以我从我的角度来谈谈这种方案：解决了什么样的问题，怎么实现的，以及适合应用的场景。同时也加深自己对Reactive的理解。
这里我们来看看是怎么实现的，关于pure function和monad的部分我也不准备介绍了，毕竟我在这方面还不是特别熟悉。
signal observer
首先我们来想一下一个最简单信号的流程。当一个信号被订阅时(subscribe)，发出信号后会触发订阅者(observer)执行下一步(sendNext)。那么一个最简单的信号(signal)和订阅者(observer)的协议就如下。
protocol Observer {
func send(next: AnyObject)
func send(error: NSError)
func sendComplete()
}
protocol Signal {
func subscribe(_ observer: �Observer)
}
那么现在实现一个最简单的UIButton的信号。
class ButtonSignal: Signal {
var observer: Observer?
init(button: UIButton) {
button .addTarget(self, action: #selector(onButton(sender:)), for: .touchUpInside)
}
@objc func onButton(sender: UIButton) {
self.observer?.send(next: sender)
}
func subscribe(_ observer: Observer) {
self.observer = observer
}
}
class ButtonSignal: Signal {
var observer: Observer?
init(button: UIButton) {
button .addTarget(self, action: #selector(onButton(sender:)), for: .touchUpInside)
}
func onButton(sender: UIButton) {
self.observer?.send(next: sender)
}
func subscribe(_ observer: Observer) {
self.observer = observer
}
}
然后实现一个最简单的订阅者。
class ButtonObserver: Observer {
func send(next: AnyObject) {
print("send next!")
}
func sendComplete() {
print("send complete")
}
func send(error: NSError) {
print("send \(error)")
}
}
最后连接起来
signal = ButtonSignal(button: button)
signal?.subscribe(ButtonObserver())
那么问题来了，难道我们要为每个信号都创建一个类吗。当然不是，我们可以创建一个通用的信号和订阅者。
class BlockSignal: Signal {
typealias CreateBlock = (Observer)->Void
var block: CreateBlock
init(block:@escaping CreateBlock) {
self.block = block
}
func subscribe(_ observer: Observer) {
self.block(observer)
}
}
class BlockObserver: Observer {
var next: (AnyObject)->Void
var complete: ()->Void
var error: (NSError)->Void
init(next: @escaping (AnyObject)->Void,
complete: @escaping ()->Void,
error: @escaping (NSError)->Void) {
self.next = next
self.complete = complete
self.error = error
}
@objc func send(next: AnyObject) {
self.next(next)
}
func sendComplete() {
self.complete()
}
func send(error: NSError) {
self.error(error)
}
}
同时在使用的过程时通过block来创建具体信号。
signal = BlockSignal(block: { (observer) in
self.button.addTarget(observer,
action: #selector(BlockObserver.send(next:)),
for: .touchUpInside)
})
observer = BlockObserver(next: { (sender) in
print("send next!")
}, complete: {
print("send complete")
}) { (error) in
print("send error")
}
signal?.subscribe(observer!)
以上就是最简单的信号量和订阅者实现。这里为了简洁的说明问题，所以没有考虑到内存方面的问题。
dispose
上节说了内存方面的问题。还有一个问题就是如何取消订阅呢。那么这里需要有模块负责释放(dispose)。
那么将接口改为
protocol Disposable {
func dispose()
}
protocol Signal {
func subscribe(_ observer: Observer) -> Disposable
}
实现也按照block形式
class BlockDisposable: Disposable {
var block: ()->Void
init(block: @escaping ()->Void) {
self.block = block
}
func dispose() {
self.block()
}
}
class BlockSignal: Signal {
func subscribe(_ observer: Observer) -> Disposable {
return self.block(observer)
}
}
使用时和上面基本一致
signal = BlockSignal(block: { (observer) in
self.button.addTarget(observer,
action: #selector(BlockObserver.send(next:)),
for: .touchUpInside)
return BlockDisposable(block: {
self.button.removeTarget(observer,
action: #selector(BlockObserver.send(next:)),
for: .touchUpInside)
})
})
需要解除订阅的时候
self.disposable = signal?.subscribe(observer!)
self.disposable?.dispose()
之后
到目前为止，可以说signal-observer部分已经完全实现了。
其中冷信号和热信号也非常简单
protocol Subject: Observer, Signal {}
Scheduler也比较简单，将执行放到对应的队列中即可。
下篇结合我的角度来聊聊应用场景。
