Observer
Observer信息的处理逻辑封装, Observer的主要代码如下:
//Observer.swift
public final class Observer {
public typealias Action = (Event) -> Void
private let _send: Action
public init(_ action: @escaping Action) { self._send = action ... }
public func send(_ event: Event) { _send(event) }
public func send(value: Value) { _send(.value(value)) }
public func sendXXX() //其实都是send(_ event: Event)}
Observer内部保持了一个处理Event的闭包, 初始化Observer就是在设置这个闭包, 而调用Observer.send则是在执行这个闭包.
需要注意的点: Observer封装了Event的处理逻辑.
Signal
有了信息的载体和信息的处理逻辑, 接下来需要的是: 将信息发送出去.
在ReactiveSwift中, 想要发送信息共有四种途径, 这里我们先介绍第一种: Signal.(事实上, 四种途径最终都是通过Signal来完成的, 所以, 其实只有一种.)
Signal是ReactiveSwift中热信号的实现, "热"的意思是它是一直活动着的, 会主动将产出的事件Event向外发送, 而不会等到有人订阅后才开始发送. 这意味着如果订阅的时机晚于发送的时机, 那么订阅者是不会收到订阅时机之前的事件的.
举个栗子: 春晚现场直播从晚8点一直播到12点, 这段时间产出的节目就是Value事件, 12点一到产出的就是Completed事件. 很明显, 不管有没有人看春晚, 春晚现场都不关心, 节目来了就上, 时间一到就散. 但如果你想看直播, 最好的时机当然是8点, 若是9点才打开电视, 那9点之前的节目你肯定就错过了.
Signal的使用:
note: 这里的Value和Error都是泛型, 你需要在创建的时候进行指定
//public static func pipe(disposable: Disposable? = nil) -> (output: Signal, input: Observer)
let signalTuple = Signal.pipe()
let (signal, observer) = Signal.pipe()
通常, 你应该只通过Signal.pipe()函数来初始化一个热信号. 这个函数会返回一个元组, 元组的第一个值是output(类型为Signal), 第二个值是input(类型为Observer). 我们通过output来订阅信号, 通过input来向信号发生信息.
需要注意的点: output的作用是管理信号状态并保存由订阅者提供的Observer对象(Observer._send封装了Event的处理逻辑), 而input的作用则是在接收到Event后依次执行这些被保存的Observer._send.
来看一段订阅Signal的基础代码:
func bindSignal2_1(){
//1.创建signal(output)和innerObserver(input)
let (signal, innerObserver) = Signal.pipe()
//2.创建Observer
let outerObserver1 = Signal.Observer(value: { (value) in
print("did received value: (value)")
})
//2.还是创建Observer
let outerObserver2 = Signal.Observer { (event) in
switch event {
case let .value(value):
print("did received value: (value)")
default: break }
}
signal.observe(outerObserver1)//3.向signal中添加Observer signal.observe(outerObserver2)//3.还是向signal中添加Observer
innerObserver.send(value: 1)//4.向signal发生信息(执行signal保存的所有Observer对象的Event处理逻辑)
innerObserver.sendCompleted()//4.还是执向signal发生信息
}
实际开发中我们肯定不会这样写, 太繁琐了. 它的意义在于告诉各位: 1)每订阅一次Signal实际上就是在向Signal中添加一个Observer对象. 2)即使每次订阅信号的处理逻辑都是一样的, 但它们仍然是完全不同的的两个Observer对象.
把上面的代码改的简洁一点:
typealias NSignal = ReactiveSwift.Signaloverride
func viewDidLoad() {
super.viewDidLoad()
//1.创建signal(output)和innerObserver(input)
let (signal, innerObserver) = NSignal.pipe()
signal.observeValues { (value) in //2&3.创建Observer并添加到Signal中 print("did received value: (value)") } signal.observeValues { (value) in //2&3.还是创建Observer并添加到Signal中 print("did received value: (value)") } innerObserver.send(value: 1) //4. ... innerObserver.sendCompleted() //4. ...}
介绍下Signal.observeValues, 这是Signal.observe的一个便利函数, 作用是创建一个只处理Value事件的Observer并添加到Signal中, 类似的还有只处理Failed事件的Signal.observeFailed和所有事件都能处理的**Signal.observeResult.
热信号相关代码：
typealias NSignal = ReactiveSwift.Signal
//ViewModel.swift
class ViewModel {
let signal: NSignal
let innerObserver: NSignal.Observer
init() { (signal, innerObserver) = NSignal.pipe() }
}
//View1.swift
class View1 {
func bind(viewModel: ViewModel) {
viewModel.signal.observeValues { (value) in
print("View1 received value: (value)")
}
}
}
//View2.swift
class View2 {
func bind(viewModel: ViewModel) {
viewModel.signal.observeValues { (value) in
print("View2 received value: (value)")
}
}
}
//View3.swift
class View3 {
func bind(viewModel: ViewModel) {
viewModel.signal.observeValues { (value) in
print("View3 received value: (value)")
}
viewModel.signal.observeInterrupted {
print("View3 received interrupted")
}
}}
override func viewDidLoad() {
super.viewDidLoad()
let view1 = View1()
let view2 = View2()
let view3 = View3()
let viewModel = ViewModel()
view1.bind(viewModel: viewModel)//订阅时机较早
viewModel.innerObserver.send(value: 1)
view2.bind(viewModel: viewModel)//订阅时机较晚
viewModel.innerObserver.send(value: 2)
viewModel.innerObserver.sendCompleted()//发送一个非Value事件 信号无效
view3.bind(viewModel: viewModel)//信号无效后才订阅
viewModel.innerObserver.send(value: 3)//信号无效后发送事件 }
view2的订阅时间晚于value1的发送时间, 所以view2收不到value1对应的事件, 这部分对应上面我说的热信号并不关心订阅者的情况, 一旦有事件即会发送.
第二部分则是Signal自身的特性: 收到任何非Value的事件后信号便无效了. 所以你会看到虽然view1和view2的订阅都早于value3的发送时间, 但因为value3在信号发送前先发送了completed事件, 所以view1和view2都不会收到value3事件, 同理, view3也不会收到value3事件(它只会收到一个interrupted, 如果它关心的话).
KVO
public func signal(forKeyPath keyPath: String) -> Signal
tableView: UITableView
dynamic var someValue = 0
reactive.signal(forKeyPath: "someValue").observeValues { [weak self] (value) in //code}
tableView.reactive.signal(forKeyPath: "contentSize").observeValues {[weak self] (contentSize) in
if let contentSize = contentSize as? CGSize, let strongSelf = self {
let isHidden = contentSize.height < strongSelf.tableView.height
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now(),
execute: { strongSelf.tableView.mj_footer.isHidden = isHidden
}) }}
KVO的Reactive版本, 对于NSObject的子类可以直接使用, 对于Swift的原生类需要加上dynamic修饰.
Map
let (signal, innerObserver) = NSignal.pipe()
signal.map { return "xxx" + String($0) }
//map就不解释了
.observeValues { (value) in
print(value)
}
innerObserver.send(value: 1)innerObserver.sendCompleted()
打印：
xxx1
On：
public func on(
event: ((Event) -> Void)? = nil,
failed: ((Error) -> Void)? = nil,
completed: (() -> Void)? = nil,
interrupted: (() -> Void)? = nil,
terminated: (() -> Void)? = nil,
disposed: (() -> Void)? = nil,
value: ((Value) -> Void)? = nil) -> Signal
D😈emo：
let (signal, innerObserver) = NSignal.pipe()
signal.on( value: { (value) in
print("on value: (value)")
}).observeValues { (value) in
print("did received value: (value)"
)}
innerObserver.send(value: 1)
innerObserver.sendCompleted()
打印:
on value: 1
did received value: 1
on: 在信号发送事件和订阅者收到事件之间插入一段事件处理逻辑, 你可以把它看做map的简洁版. (这个函数的参数很多, 但默认都有给nil, 所以你只需要关心自己需要的部分即可, 比如这里我只想在Value事件间插入逻辑)
take(until:)
public func take(until trigger: Signal) -> Signal
let (signal, innerObserver) = NSignal.pipe()
let (takeSignal, takeObserver) = NSignal.pipe()signal.take(until: takeSignal).observeValues { (value) in
print("received value: (value)")
}
innerObserver.send(value: 1)
innerObserver.send(value: 2)
takeObserver.send(value: ())
innerObserver.send(value: 3)
takeObserver.sendCompleted()
innerObserver.sendCompleted()
打印: received value: 1 received value: 2
take(until:): 在takeSignal发送Event之前, signal可以正常发送Event, 一旦takeSignal开始发送Event, signal就停止发送, takeSignal相当于一个停止标志位.
take(first:)
publicfunc take(first count: Int) -> Signal
let (signal, innerObserver) = NSignal.pipe()
signal.take(first: 2).observeValues { (value) in
print("received value: (value)")
}
innerObserver.send(value: 1)
innerObserver.send(value: 2)
innerObserver.send(value: 3)
innerObserver.send(value: 4)
innerObserver.sendCompleted()
打印: received value: 1 received value: 2
take(first:): 只取最初N次的Event.
类似的还有signal.take(last: ): 只取最后N次的Event.
参考资料： ReactiveSwift(上)
