RXSwift的教程太多, ReactiveSwift的教程又太少
账号停止维护, 提问/讨论请移步掘金账号
前言
大概是这样, Swift4.0出了, 重新梳理Swift知识, 对比了下RXSwift和ReactiveSwift, 喜欢ReactiveSwift多一些, 想了想, 出份基础教程.
建议新人朋友只看如何使用, 至于实现概述看看最后的总结和图了解一下思路就行了.
目录
- Event
- Observer
- Signal
- SignalProducer
- Property/MutableProperty
- Action/CocoaAction
- Hello ReactiveSwift
Event
在ReactiveSwift中, 信息的载体(value/error)对应的是一个枚举Event, Event的定义如下:
//Event.swift
public enum Event {
case value(Value)
case failed(Error)
case completed
case interrupted
}
前三个状态顾名思义就不解释了, 第四个状态interrupted表示事件被打断, 除非你去订阅一个已经无效的信号, 否则这个状态不会出现, 所以不用太多关注这个状态.
需要注意的点: 当信号发送非Value的Event时, 那么这个信号就无效了. 无效的原因可能是failed(失败), completed(寿终正寝), interrupted(早就无效了).
Observer
上面说过Event是信息的载体, 而这里的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的使用和Signal的实现概述, 大家主要关注使用部分即可.
-
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的基础代码:
override func viewDidLoad() {
super.viewDidLoad()
//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发生信息
}
//输出: did received value: 1
did received value: 1
这段代码简单的演示了如何创建并订阅一个Signal, 但事实上, 实际开发中我们肯定不会这样写, 太繁琐了. 它的意义在于告诉各位: 1)每订阅一次Signal实际上就是在向Signal中添加一个Observer对象. 2)即使每次订阅信号的处理逻辑都是一样的, 但它们仍然是完全不同的的两个Observer对象.
我们来把上面的代码改的简洁一点:
typealias NSignal = ReactiveSwift.Signal
override 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.
吐槽: ReactiveSwift中职责区分十分明确, 这意味着做一件简单的事情可能会需要多个部件共同协作, 这对使用者来说比较繁琐, 所以ReactiveSwift提供了很多的便利函数来进行简化, 但过多的便利函数密密麻麻一堆让人看得心烦, 于是被刚接触的朋友们吐槽"复杂", "不简洁". 但通常我们只需要记着几个常用函数即可做好大部分事情, 其实ReactiveSwift非常简洁.
回到代码来, 接下来介绍下"热"信号的相关代码:
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)//信号无效后发送事件
}
输出: View1 received value: 1
View1 received value: 2
View2 received value: 2
View3 received interrupted
这里我们可以看到, view2的订阅时间晚于value1的发送时间, 所以view2收不到value1对应的事件, 这部分对应上面我说的热信号并不关心订阅者的情况, 一旦有事件即会发送.
第二部分则是Signal自身的特性: 收到任何非Value的事件后信号便无效了. 所以你会看到虽然view1和view2的订阅都早于value3的发送时间, 但因为value3在信号发送前先发送了completed事件, 所以view1和view2都不会收到value3事件, 同理, view3也不会收到value3事件(它只会收到一个interrupted, 如果它关心的话).
接下来介绍一些Signal常用的函数, 这些函数会在文末的demo中出现.
- KVO
public func signal(forKeyPath keyPath: String) -> Signal
let 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
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<(), NoError>) -> 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:)
public func 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.
- merge
public static func merge(_ signals: Signal...) -> Signal
let (signal1, innerObserver1) = NSignal.pipe()
let (signal2, innerObserver2) = NSignal.pipe()
let (signal3, innerObserver3) = NSignal.pipe()
Signal.merge(signal1, signal2, signal3).observeValues { (value) in
print("received value: \(value)")
}
innerObserver1.send(value: 1)
innerObserver1.sendCompleted()
innerObserver2.send(value: 2)
innerObserver2.sendCompleted()
innerObserver3.send(value: 3)
innerObserver3.sendCompleted()
输出: received value: 1
received value: 2
received value: 3
merge: 把多个信号合并为一个新的信号，任何一个信号有Event的时就会这个新信号就会Event发送出来.
- combineLatest
public static func combineLatest(_ signals: S) -> Signal<[Value], Error>
let (signal1, innerObserver1) = NSignal.pipe()
let (signal2, innerObserver2) = NSignal.pipe()
let (signal3, innerObserver3) = NSignal.pipe()
Signal.combineLatest(signal1, signal2, signal3).observeValues { (tuple) in
print("received value: \(tuple)")
}
innerObserver1.send(value: 1)
innerObserver2.send(value: 2)
innerObserver3.send(value: 3)
innerObserver1.send(value: 11)
innerObserver2.send(value: 22)
innerObserver3.send(value: 33)
innerObserver1.sendCompleted()
innerObserver2.sendCompleted()
innerObserver3.sendCompleted()
输出: received value: (1, 2, 3)
received value: (11, 2, 3)
received value: (11, 22, 3)
received value: (11, 22, 33)
combineLatest: 把多个信号组合为一个新信号，新信号的Event是各个信号的最新的Event的组合.
"组合"意味着每个信号都至少有发送过一次Event, 毕竟组合的每个部分都要有值. 所以, 如果有某个信号一次都没有发送过Event, 那么这个新信号什么也不会发送, 不论其他信号发送了多少Event.
另外, 新信号只会取最新的Event的来进行组合, 而不是数学意义上的组合.
- zip
public static func zip(_ signals: S) -> Signal<[Value], Error>
let (signal1, innerObserver1) = NSignal.pipe()
let (signal2, innerObserver2) = NSignal.pipe()
let (signal3, innerObserver3) = NSignal.pipe()
Signal.zip(signal1, signal2, signal3).observeValues { (tuple) in
print("received value: \(tuple)")
}
innerObserver1.send(value: 1)
innerObserver2.send(value: 2)
innerObserver3.send(value: 3)
innerObserver1.send(value: 11)
innerObserver2.send(value: 22)
innerObserver3.send(value: 33)
innerObserver1.send(value: 111)
innerObserver2.send(value: 222)
innerObserver1.sendCompleted()
innerObserver2.sendCompleted()
innerObserver3.sendCompleted()
输出: received value: (1, 2, 3)
received value: (11, 22, 33)
zip: 新信号的Event是各个信号的最新的Event的进行拉链式组合.
有人把这个叫压缩, 但我觉得拉链式组合更贴切一些. 拉链的左右齿必须对齐才能拉上, 这个函数也是一样的道理. 只有各个信号发送Event的次数相同(对齐)时, 新信号才会发送组合值. 同理, 如果有信号未发送那么什么也不会发生.
我个人常用的Signal的相关函数就是这些, 其他的自己不怎么用的函数就不介绍了, 接下来介绍下Signal的实现概述, 不关心的朋友请直接跳过.
- Signal的实现概述
让我们点开Signal.swift, 你应该会看到Signal只有一个孤零零的core属性一个设置core属性的初始化函数以及一个调用core.observe的observe函数. 正如源码注释中所说: Signal只是Core的一个壳. 所以接下来我们主要介绍的其实是Core. 我们来看看Core的主要定义:
private final class Core {
private let disposable: CompositeDisposable
private let stateLock: Lock //状态锁
private let sendLock: Lock //事件锁
private var state: State //信号状态 最重要就是它了
...略
}
private enum State {
case alive(Bag, hasDeinitialized: Bool)
case terminating(Bag, TerminationKind)
case terminated
}
public struct Bag {//Bag可以认为是数组的一层封装
fileprivate var elements: ContiguousArray = []
...略
}
Core里面最重要的属性就是这个State. State的作用有两个: 一个是指示信号的状态, 另一个就是上文我提到过的保存信号订阅者添加进来的Observer对象.
我们来看看添加Observer对象部分的代码:
fileprivate func observe(_ observer: Observer) -> Disposable? {
var token: Bag.Token?
stateLock.lock()
//1. 信号处于state.alive状态 将新的observer对象添加到state.alive的数组中
if case let .alive(observers, hasDeinitialized) = state {
var newObservers = observers
token = newObservers.insert(observer)
self.state = .alive(newObservers, hasDeinitialized: hasDeinitialized)
}
stateLock.unlock()
//2. 如果1顺利执行 token会被赋值(即信号处于alive状态) 返回一个Disposable对象 否则直接向observer对象发送interrupted事件
if let token = token {
return AnyDisposable { [weak self] in
self?.removeObserver(with: token)
}
} else {
observer.sendInterrupted()
return nil
}
}
上面我说过Observer是Event的处理逻辑封装, 这里我们添加并保存了Observer(也就是保存了Event的处理逻辑), 接下来需要的就是在合适的时机执行这些Observer内部的处理逻辑. 这部分代码对应Core.send(_ event: Event):
private func send(_ event: Event) {
...lock部分代码 略
if event.isTerminating {
//1. 收到非Value的Event, 将信号状态从.alive切换到.terminating 并将.alive中的Observer数组移到.terminating中(如果此时信号处于.alive的话)
if case let .alive(observers, _) = state {
self.state = .terminating(observers, .init(event))
}
//2. 依次执行.terminating的数组中Observer.send函数(如果有的话)
tryToCommitTermination()
} else {
//1. 收到Value的Event, 依次执行.alive的数组中Observer.send函数(如果此时信号处于.alive的话)
if case let .alive(observers, _) = self.state {
for observer in observers {
observer.send(event)
}
}
//2. 收到Value的Event 依次执行.terminating的数组中Observer.send函数(如果此时信号处于.terminating的话)
if case .terminating = state {
tryToCommitTermination()
}
}
}
private func tryToCommitTermination() {
...lock部分代码 略
if case let .terminating(observers, terminationKind) = state {
//1.切换状态到.terminated
//2.依次执行.terminating的数组中Observer.send函数(如果有的话)
state = .terminated
if let event = terminationKind.materialize() {
for observer in observers {
observer.send(event)
}
}
}
}
我去掉了Core.send函数和lock相关的代码, 这样看起来会简单些, 大家对照注释应该比较好理解, 这里我主要说说State的切换. 先把State定义贴过来:
private enum State {
case alive(Bag, hasDeinitialized: Bool)
case terminating(Bag, TerminationKind)
case terminated
...一些函数 略
}
可以看到第三个状态terminated是不带关联数组的, 这意味着当信号切换到terminated状态时, 那么那些被保存的Observer对象也就跟着释放了, 所以, 当不再需要使用信号时, 总是应该向信号发送一个非Value事件确保资源释放.
事实上, 在ReactiveSwift5.0中Signal和State会保持一个引用环确保常驻内存, 如果你不发送非Value事件的话, 资源是不会被释放的. 但在最新的ReactiveSwift中, 这个引用环被去掉了, 你不用担心资源释放的问题. 但不再需要信号的时候调用一下sendCompleted()总是一个好习惯.
现在我们知道了信号状态的切换, Observer的添加, Observer.send的执行, 那么最后就只剩下将这一切连接起来了, 显然, 这个连接函数就是Signal.pipe():
//Signal.pipe()
public static func pipe(disposable: Disposable? = nil) -> (output: Signal, input: Observer) {
var observer: Observer!
let signal = self.init { innerObserver, lifetime in
observer = innerObserver
lifetime += disposable
}
return (signal, observer)
}
//Signal.init()
public init(_ generator: (Observer, Lifetime) -> Void) {
core = Core(generator)
}
//Core.init()
fileprivate init(_ generator: (Observer, Lifetime) -> Void) {
//1. 设置信号初始状态为alive 同时初始化alive中的数组
state = .alive(Bag(), hasDeinitialized: false)
...初始化lock 略
//2. 创建一个Observer对象并将该对象的_send闭包设置为Core.send函数
generator(Observer(action: self.send, interruptsOnDeinit: true), Lifetime(disposable))
}
这里我们看到, pipe()函数会通过一个generator: (Observer, Lifetime)闭包去创建Core对象, 然后通过这个Core对象去创建Signal, pipe()函数通过generator闭包捕获了Core.init()中的innerObserver对象, 而这个InnerObserver对象的_send指向的其实是Core.send函数. 最后pipe()将创建完成Signal和InnerObserver打包返回.
这也是为什么上文我说: pipe().output(即Signal)的作用是管理信号状态并保存由订阅者提供的Observer对象, 而pipe().input(即InnerObserver)的作用则是在接收到Event后依次执行这些被保存的Observer._send.
我们把上面的流程用一张图来表示:
这张图其实也可用来标示OC的RACSubject或者RXSwift的RXSubject的大体工作流程, 毕竟三者都是State, 观察者数组, send函数, observer/subscribe函数, 只是加不加壳罢了.
SignalProducer
SignalProducer是ReactiveSwift中冷信号的实现, 是第二种发送事件的途径.
上文说到热信号是活动着的事件发生器, 相对应的, 冷信号则是休眠中的事件发生器. 也就是说冷信号需要一个唤醒操作, 然后才能发送事件, 而这个唤醒操作就是订阅它. 因为订阅后才发送事件, 显然, 冷信号不存在时机早晚的问题. 仍以春晚举例:
冷信号相当于春晚的视频文件而不是现场直播, 正常情况下, 视频文件肯定是不会自动播放的, 但你只要一双击, 它就被启动播放然后输出节目了.
照例, 我还是给出两份代码, 大家懂个意思就行:
//1. 通过SignalProducer.init(startHandler: (Observer, Lifetime) -> Void)创建SignalProducer
let producer = SignalProducer { (innerObserver, lifetime) in
lifetime.observeEnded({
print("信号无效了 你可以在这里进行一些清理工作")
})
//2. 向外界发送事件
innerObserver.send(value: 1)
innerObserver.send(value: 2)
innerObserver.sendCompleted()
}
//3. 创建一个观察者封装事件处理逻辑
let outerObserver = Signal.Observer(value: { (value) in
print("did received value: \(value)")
})
//4. 添加观察者到SignalProducer
producer.start(outerObserver)
输出: did received value: 1
did received value: 2
信号无效了 你可以在这里进行一些清理工作
typealias Producer = ReactiveSwift.SignalProducer
let producer = Producer { (innerObserver, _) in
//没什么想清理的
innerObserver.send(value: 1)
innerObserver.send(value: 2)
innerObserver.sendCompleted()
}
producer.startWithValues { (value) in
print("did received value: \(value)")
}
producer.startWithFailed(action: )
producer.startWithResult(action: )
producer.startWithXXX...各种便利函数
和Signal的订阅方式如出一辙, 只是名字换了一下, Signal.observeXXX换成了SignalProducer.startXXX.
大家都是事件发生器, 所以API方面Signal和SignalProducer都是一样的, 上面的map, on, merge, comblinelast...等等, SignalProducer也有一份, 作用也都一样, 我就不多说了, 这里简单给两段代码说说可能遇到的坑.
func fetchData(completionHandler: (Int, Error?) -> ()) {
print("发起网络请求")
completionHandler(1, nil)
}
let producer = Producer {[unowned self] (innerObserver, _) in
self.fetchData(completionHandler: { (data, error) in
innerObserver.send(value: data)
innerObserver.sendCompleted()
})
}
producer.startWithValues { (value) in
print("did received value: \(value)")
}
producer.startWithValues { (value) in
print("did received value: \(value)")
}
输出: 发起网络请求
did received value: 1
发起网络请求
did received value: 1
也许你只是想两个观察者共享一次网络请求带回的Event, 但事实上这里会发生两次网络请求, 但这不是一个bug, 这是一个feature.
SignalProducer的一个特性是, 每次被订阅就会执行一次初始化时保存的闭包. 所以如果你有类似一次执行, 多处订阅的需求, 你应该选择Signal而不是SignalProducer. 所以, 符合需求的代码可能是这样:
let signalTuple = NSignal.pipe()
signalTuple.output.observeValues { (value) in
print("did received value: \(value)")
}
signalTuple.output.observeValues { (value) in
print("did received value: \(value)")
}
self.fetchData { (data, error) in
signalTuple.input.send(value: data)
signalTuple.input.sendCompleted()
}
输出: 发起网络请求
did received value: 1
did received value: 1
到目前为止, 示例代码中给到的都是NoError类型的信号, 在实际开发中, 这显然是不可能的, 毕竟错误是不可避免的. 通常我们的项目会声明一个类似APIError的错误类型来表示这些错误, 所以你可能会有这样的声明:
struct APIError: Swift.Error {
let code: Int
var reason = ""
}
typealias NSignal = ReactiveSwift.Signal
typealias APISignal = ReactiveSwift.Signal
typealias Producer = ReactiveSwift.SignalProducer
typealias APIProducer = ReactiveSwift.SignalProducer
这样的声明很好, 能让ReactiveSwift写起来像RXSwift一样"简洁". 但这里需要加上下面的代码才能更好的工作:
extension SignalProducer where Error == APIError {
@discardableResult
func startWithValues(_ action: @escaping (Value) -> Void) -> Disposable {
return start(Signal.Observer(value: action))
}
}
这是因为默认的SignalProducer是没有startWithValues函数的, ReactiveSwift会在Extension里给它加上startWithValues函数, 但是这只对NoError有效, 所以当你在自定义Error时, 请记得加上类似的代码.
基本使用介绍完了, 照例是SignalProducer的实现概述, 不关心朋友的请直接跳过.
- SignalProducer的实现概述
和Signal类似, SignalProducer也是一个壳, 壳的内部装着的是SignalProducerCore, 这个类有三个子类SignalCore, GeneratorCore和TransformerCore. 其中SignalCore和GeneratorCore用于普通操作的SignalProducer, 而TransformerCore则是在map, take, filterMap...之类的操作才会用上. 这里我主要介绍使用率较高的SignalCore, 下面看看它的定义:
//SignalProducerCore
internal class SignalProducerCore {
//Instance作用:
//1.持有一个热信号Signal 用于保存订阅者添加的Observer对象
//2.持有一个() -> Void闭包 用于执行回调(对子类SignalCore来说 这个闭包的作用则是向上面的Signal.core.state.Observes数组发送Event)
struct Instance {
let signal: Signal
let observerDidSetup: () -> Void
let interruptHandle: Disposable
}
//抽象方法 留待子类实现
func makeInstance() -> Instance {
fatalError()
}
//抽象方法 留待子类实现(对子类SignalCore来说 这个函数就是订阅Signal或者是添加Observer对象到Signal中)
func start(_ generator: (_ upstreamInterruptHandle: Disposable) -> Signal.Observer) -> Disposable {
fatalError()
}
...和TransformerCore相关的部分 略
}
//SignalCore
private final class SignalCore: SignalProducerCore {
private let _make: () -> Instance
//这个action会由SignalProducer传入
init(_ action: @escaping () -> Instance) {
self._make = action
}
//当外部执行SignalProducer.start函数订阅Producer时, 实际就是在执行这个函数
override func start(_ generator: (Disposable) -> Signal.Observer) -> Disposable {
let instance = makeInstance()// 1. 创建一个热信号signal
instance.signal.observe(generator(instance.interruptHandle)) 2. 通过参数generator创建一个观察者并订阅上面创建的signal
instance.observerDidSetup()3. 订阅signal完成 执行回调
return instance.interruptHandle
}
override func makeInstance() -> Instance {
return _make()
}
}
现在我们知道了冷信号是如何通过Signal来保存订阅者传入的Observer对象, 下来看看这些Observer是如何被执行的:
//SignalProducer.swift
public init(_ startHandler: @escaping (Signal.Observer, Lifetime) -> Void) {
self.init(SignalCore { //通过SignalCore.init(_ action:)创建Core Core.action就是makeInstance() 然后通过Core创建Producer
****SignalCore.makeInstance begin****
let disposable = CompositeDisposable()
//1. 创建一个Signal 这个Signal用于保存订阅者添加的Observer对象
let (signal, innerObserver) = Signal.pipe(disposable: disposable)
//2.1 创建一个observerDidSetup 当订阅Signal完成后就直接执行我们创建SignalProducer时传入的startHandler
//2.2 innerObserver通过startHandler传递给外部使用 外部使用innerObserver发送事件
let observerDidSetup = { startHandler(innerObserver, Lifetime(disposable)) }
let interruptHandle = AnyDisposable(observer.sendInterrupted)
//3. 通过Instance持有上面创建的Signal和observerDidSetup
return SignalProducerCore.Instance(signal: signal,
observerDidSetup: observerDidSetup,
interruptHandle: interruptHandle)
****SignalCore.makeInstance end****
})
}
}
//ViewModel.swift
let producer = Producer {[unowned self] (innerObserver, _) in
self.fetchData(completionHandler: { (data, error) in
innerObserver.send(value: data)//外界通过startHandler使用innerObserver发送事件
innerObserver.sendCompleted()
})
}
简单描述一下整个流程:
- 创建Producer时需要传入一个startHandler:(Signal.Observer, Lifetime) -> Void闭包, 我们通过这个startHandler的Observer参数发送事件, startHandler会在Producer.core._make执行时被回调.
- 那么Producer.core._make闭包什么时候会执行呢? 答案是一旦有人调用Producer.start(outerObserver)函数时. _make会创建一个Signal并订阅outerObserver到Signal中, 然后将InnerObserver传入startHandler闭包并执行.
记住, Producer.start调用几次, Producer.core._make就会执行几次(也就是startHandler会执行几次).
照例, 给到一张图:
这张图不能用于OC或RXSwift, 这两者的冷信号并不依托热信号, 只是思路类似, 不过实现方式会略复杂些.
Property/MutableProperty
ReactiveSwift发送事件的第三种途径是Property/MutableProperty. 从冷热信号的定义上来看, Property的行为应该属于热信号, 但和上文的Signal不同, Property/MutableProperty只提供一种状态的事件: Value.(虽然它有Completed状态)
我们就暂且认为Property/MutableProperty代表那些不知道何时结束的现场直播吧.
照例, 先上一段标准代码:
let constant = Property(value: 1)
// constant.value = 2 //error: Property(value)创建的value不可变
print("initial value is: \(constant.value)")
constant.producer.startWithValues { (value) in
print("producer received: \(value)")
}
constant.signal.observeValues { (value) in
print("signal received: \(value)")
}
输出: initial value is: 1
producer received: 1
let mutableProperty = MutableProperty(1)
print("initial value is: \(mutableProperty.value)")
mutableProperty.producer.startWithValues { /** 冷信号可以收到初始值value=1和2,3 */
print("producer received \($0)")
}
mutableProperty.signal.observeValues { /** 热信号只能收到后续的变化值value=2,3 */
print("signal received \($0)")
}
mutableProperty.value = 2 /** 设置value值就是在发送Value事件 */
mutableProperty.value = 3 /** 设置value值就是在发送Value事件 */
输出: initial value is: 1
producer received: 1
producer received: 2
signal received: 2
producer received: 3
signal received: 3
这段代码只是演示一下Property的基本信息. 大家只需要知道Property.value不可设置, MutableProperty.value可设置. Property/MutableProperty内部有一个Producer一个Signal, 设置value即是在向这两个信号发送Value事件即可.
下面以手机号输入限制举例给到一段实际使用的示例代码:
需求: 1.用户输入手机号 限制手机号最多输入11个数字
2.验证手机号是否有效 手机号无效需要展示错误信息
let errorLabel: UILabel
let sendButton: UIButton
let phoneNumerTextField: UITextField
var errorText = MutableProperty("")
var validPhoneNumer = MutableProperty("")
errorLabel.reactive.text <~ errorText //绑定错误信息到errorLabel
sendButton.reactive.isEnabled <~ errorText.map{ $0.count == 0 } //只是演示一下什么都可以绑
sendButton.reactive.backgroundColor <~ errorText.map{ $0.count == 0 ? UIColor.red : UIColor.gray } //只是演示一下什么都可以绑
phoneNumerTextField.reactive.text <~ validPhoneNumer //绑定有效输入到输入框
//有效输入的数据源来自原始的输入框 我们对原始输入进行一些格式化
validPhoneNumer <~ phoneNumerTextField.reactive.continuousTextValues
.map({(text) -> String in
let phoneNumer = (text ?? "").substring(to: 11) //1. 最多输入11个数字, 多余部分截掉
let isValidPhoneNum = NSPredicate(format: "SELF MATCHES %@", "正则表达式...").evaluate(with: phoneNumer) //2. 检查手机格式是否正确
errorText.value = isValidPhoneNum ? "手机号格式不正确" : "" //2. 格式不正确显示错误信息
return phoneNumer //3. 返回截取后的有效输入
})
上面的代码中出现了一个新东西: <~操作符. <~非常有用, 而且实现也非常的简单, 我会在下文解释, 这里大家只需要知道: <~的左边是绑定目标(BindingTargetProvider), 右边则是数据源(BindingSource), <~会把右边数据源的发送出的Value直接绑定到左边的目标上.
目前左侧现成的绑定目标有Property/MutableProperty和一系列形如UIKit.reactive.xxx的拓展, 右侧现成的数据源则有Signal, SignalProducer以及Property/MutableProperty.
对于非现成的绑定目标, 我们可以参照现有拓展自行拓展, 非常简单, 比如给YYLabel加个拓展:
//UILabel的默认拓展
extension Reactive where Base: UILabel {
public var text: BindingTarget {
return makeBindingTarget { $0.text = $1 }//$0表示UI控件本身 $1表示value
}
public var attributedText: BindingTarget {
return makeBindingTarget { $0.attributedText = $1 }
}
}
//照猫画虎给YYLabel也加上拓展
extension Reactive where Base: YYLabel {
public var text: BindingTarget {
return makeBindingTarget { $0.text = $1 }//$0表示UI控件本身 $1表示value
}
public var attributedText: BindingTarget {
return makeBindingTarget { $0.attributedText = $1 }
}
}
- <~的实现概述
Property的实现比较简单, 大体流程就是内部存了一个Signal然后只转发Signal的Value事件, 我就不多说了, 主要说说<~的实现(其实也非常简单...).
//数据源
public protocol BindingSource: SignalProducerConvertible {
associatedtype Value
associatedtype Error: Swift.Error
var producer: SignalProducer { get }
}
extension Signal: BindingSource {}
extension SignalProducer: BindingSource {}
//绑定目标提供者
public protocol BindingTargetProvider {
associatedtype Value
var bindingTarget: BindingTarget { get }
}
//绑定目标
public struct BindingTarget: BindingTargetProvider {
public let lifetime: Lifetime //这里定义何时取消订阅数据源
public let action: (Value) -> Void //这里定义了如何利用数据源发送的Value(一般来说就是简单的用Value设置某个属性)
...其他代码 略
}
extension BindingTargetProvider {
@discardableResult
public static func <~
(provider: Self, source: Source) -> Disposable?
where Source.Value == Value, Source.Error == NoError {
//订阅右边的数据源提供的producer, 在订阅回调中执行绑定目标的action闭包
return source.producer
.take(during: provider.bindingTarget.lifetime)
.startWithValues(provider.bindingTarget.action)
}
}
可以看到<~的实现非常简单, 只有三行代码, 订阅右边的数据源提供的producer, 在订阅回调中执行绑定目标的action闭包.
然后我们看看ReactiveSwift是如何给UI控件添加BindingTarget的, 以Label举例:
public protocol ReactiveExtensionsProvider: class {}
extension ReactiveExtensionsProvider {
public var reactive: Reactive {
return Reactive(self)
}
public static var reactive: Reactive.Type {
return Reactive.self
}
}//任何对象获取 someObject.reactive时就返回一个Reactive结构体, Reactive.base即是someObject
public struct Reactive extension Reactive where Base: NSObjectProtocol {
//创建一个BindingTarget BindingTarget.action则是在UI线程操作value
public func makeBindingTarget(on scheduler: Scheduler = UIScheduler(), _ action: @escaping (Base, U) -> Void) -> BindingTarget {
return BindingTarget(on: scheduler, lifetime: lifetime) { [weak base = self.base] value in
if let base = base {
action(base, value)
}
}
}
}
extension Reactive where Base: UILabel {
//当获取label.reactive.text时 就创建一个makeBindingTarget makeBindingTarget的action则是直接设置self.text = value
public var text: BindingTarget {
return makeBindingTarget { $0.text = $1 }//$0即是label自己 $1即是value
}
}
不到30行, 就不给图了...
Action/CocoaAction
Action是最后一种发送事件的途径, 不过和其他途径不同, 它并不直接发送事件, 而是生产信号, 由生产的信号来发送事件. 最重要的是, Action是唯一一种可以接受订阅者输入的途径. 举个栗子:
上文中的现场直播也好, 视频文件也好, 其实都是家长(ViewModel)提供的, 一般家长的特色就是只是给予, 但并不在乎你喜不喜欢, 而且你还没办法通过信号跟他进行沟通. 而Action不同, 它提供让你跟家长沟通的接口apply(input), 当然, 虽然你说了你想说的(传递了数据), 但家长(ViewModel)采不采纳就是另一回事了.
这里直接上Action的实际使用代码:
//Action.swift
public final class Action
public convenience init(execute: @escaping (Input) -> SignalProducer)
typealias APIAction = ReactiveSwift.Action<[String: String]?, O, APIError>
1. 创建一个Action 输入类型为[String: String]? 输出类型为Int 错误类型为APIError
let action = APIAction { (input) -> APIProducer in
print("input: ", input)
return APIProducer({ (innerObserver, _) in
//发起网络请求
innerObserver.send(value: 1)
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 2, execute: {
innerObserver.send(value: 2)
innerObserver.sendCompleted()
})
})
}
2. 订阅Action的执行事件
action.events.observe { print("did received Event: \($0)") }
3. 订阅Action的各种输出事件
action.values.observeValues { print("did received Value: \($0)") }
//action.errors.observeValues { print("did received Error: \($0)") }
//action.completed.observeValues { print("did received completed: \($0)") }
4. 执行Action 开始输出
action.apply(["1": "xxx"]).start()
5. 在返回的Producer还未结束前继续执行Action 什么也不会输出
for i in 0...10 {
action.apply([String(i): "xxx"]).start()
}
输出: input: Optional(["0": "xxx"])
did received Value: 1
did received Event: VALUE VALUE 1
....两秒后....
did received Value: 2
did received Event: VALUE VALUE 2
did received Event: VALUE COMPLETED
did received Event: COMPLETED
Action的三个泛型从左到右依次定义了输入类型, 输出类型, 错误类型, 通常我都是直接typealias的, 不然写起来真是太长了. 上面的代码主要描述以下信息:
- 通过闭包execute: (Input) -> SignalProducer 创建一个Action, 我们可以通过execute.input获取来自订阅者的输入, 然后我们需要返回一个SignalProducer, SignalProducer封装了事件的获取/发送逻辑.
- 通过Action.events可以订阅Action本身的事件, 此时的Event.Value还是一个Event.
- 通过Action.values/errors/completed可以订阅初始化闭包中返回的SignalProducer的各种事件, 我们可以订阅这些事件对返回的结果做相应的处理.
- 通过action.apply(input).start()提供输入信息并执行Action.
- 在返回的Producer还未结束前执行Action是没用的, 只有上一个返回的Producer无效后, Action才能再次执行. (这个特性用来处理按钮的多次点击发送网络请求非常有用.)
我们看到第5条Action通过返回的Producer的状态来控制自身的可执行与否, 大多数时候这就足够了, 但保不齐你需要更精准的状态控制, 此时你需要的是下面的函数:
public convenience init(enabledIf isEnabled: P, execute: @escaping (Input) -> SignalProducer) where P.Value == Bool
这个函数通过外部传入的Property
需求: 只在输入框有输入时才可以点击按钮发起网络请求
let executeButton: UIButton
//创建一个MutableProperty的状态控制信号 控制逻辑随便写
let enabled = MutableProperty(false)
//有输入才能发起请求
enabled <~ phoneNumberTF.reactive.continuousTextValues.map { return ($0 ?? "").count > 0 }
//传入状态控制信号即可
let action = APIAction(enabledIf: enabled) { (input) -> APIProducer in
print("input: ", input)
return APIProducer({ (innerObserver, _) in
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.5, execute: {
innerObserver.send(value: 1)
innerObserver.sendCompleted()
})
})
}
action.values.observeValues { print("did received value: \($0)") }
executeButton.reactive.controlEvents(.touchUpInside).observeValues { (sender) in
action.apply(["xxx": "xxx"]).start()
}
例子很简单, 不多解释, 最后介绍一下Action的Cocoa拓展: CocoaAction.
ReactiveCocoa为一些可点击的UI控件(如UIButton, UIBarButtonItem...)都添加了一个reactive.pressed属性, 我们可以通过设置reactive.pressed很方便的添加点击操作, 不过这个属性并不属于Action而是CocoaAction. 下面简单给到一段CocoaAction的用法:
typealias TextAction = ReactiveSwift.Action
let executeButton: UIButton
let enabled = MutableProperty(false)
enabled <~ phoneNumberTF.reactive.continuousTextValues.map { return ($0 ?? "").count > 0 }
let action = TextAction(enabledIf: enabled) { (input) -> APIProducer in
print("input: ", input) //这里的获取到的都是self.phoneNumberTF.text
return APIProducer({ (innerObserver, _) in
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.5, execute: {
innerObserver.send(value: 1)
innerObserver.sendCompleted()
})
})
}
//通过CocoaAction给Button添加点击事件
executeButton.reactive.pressed = CocoaAction(action) {[unowned self] _ in
return self.phoneNumberTF.text //每次点击时都传入此时的phoneNumberTF.text作为action的输入
}
//初始化CocoaAction法1 input为一个固定值
let cocoaAction1 = CocoaAction(action, input: self.phoneNumberTF.text) //这样写 action得到的永远都是""
//let cocoaAction1 = CocoaAction(action, input: nil)
//初始化CocoaAction法2 input为一个非固定值
let cocoaAction2 = CocoaAction(action) { _ in
let input = "xxx" //各种操作得到一个输入
return input
}
我们看到, 初始化CocoaAction需要两个参数, action和input, action定义了点击控件时执行的操作, 而input则定义了操作执行时输入的数据, input的类型需要合action.input的类型一一对应.
这里只需要注意一点: 如果action的输入是一个变化值, 比如来自某个输入框textField, 那么你应该通过闭包来提供这个输入而不是直接传入textField.text.
- Action的源码读起来好累, 不写...
ReactiveSwift的基本知识和用法, 到这里就介绍完了. 最后我们把上面提到的东西全部串起来, 给到一个Hello ReactiveSwift.
Hello ReactiveSwift
我们的需求是一个很普通的注册页面:
鉴于这只是一个简单的Demo, 我不会严格按照自己的开发模式来写, 给到一个懒人版的MVVM即可, 首先是View的部分:
@IBOutlet weak var accountTF: UITextField! //账号输入框
@IBOutlet weak var passwordTF: UITextField! //密码输入框
@IBOutlet weak var ensurePasswordTF: UITextField! //确认密码输入框
@IBOutlet weak var verifyCodeTF: UITextField! //验证码输入框
@IBOutlet weak var verifyCodeButton: UIButton! //获取验证码按钮
@IBOutlet weak var errorLabel: UILabel! //错误描述Label
@IBOutlet weak var submitButton: UIButton! //提交注册按钮
这部分大家简单瞄一眼即可, 记得大概属性名即可, 接着我们定义一下ViewModel的接口部分, Protocol或Public皆可, 这里我选择前者:
protocol RegisterViewModelProtocol {
//设置数据源依赖 (数据依赖是在初始化时注入还是使用前注入不是本文讨论的话题 懒人版只选择最方便的)
func setInput(accountInput: NSignal,
passwordInput: NSignal,
ensurePasswordInput: NSignal,
verifyCodeInput: NSignal)
var validAccount: MutableProperty { get } //格式化好的账号输出
var validPassword: MutableProperty { get } //格式化好的密码输出
var validEnsurePassword: MutableProperty { get } //类似
var validVerifyCode: MutableProperty { get } //类似
var errorText: MutableProperty { get } //错误信息输出
var verifyCodeText: MutableProperty { get } //验证码文案输出
var getVerifyCodeAction: AnyAPIAction{ get } // 验证码按钮点击事件
var submitAction: AnyAPIAction { get } //提交按钮点击事件
}
我们先来处理输入格式的部分:
private let InvalidAccount = "手机号格式不正确"
private let InvalidPassword = "密码格式不正确"
private let InvalidVerifyCode = "验证码格式不正确"
extension RegisterViewModel: RegisterViewModelProtocol{}
class RegisterViewModel {
private(set) var validAccount = MutableProperty("")
private(set) var validPassword = MutableProperty("")
private(set) var validEnsurePassword = MutableProperty("")
private(set) var validVerifyCode = MutableProperty("")
private var errors = (account: InvalidAccount, password: InvalidPassword, verifyCode: InvalidVerifyCode)
func setInput(accountInput: NSignal, passwordInput: NSignal, ensurePasswordInput: NSignal, verifyCodeInput: NSignal) {
//账号: 11位手机号 最多输入11个数字
validAccount <~ accountInput.map({[unowned self] (text) -> String in
let account = (text ?? "").substring(to: 11)
self.errors.account = !account.isValidPhoneNum ? InvalidAccount : ""
return account
})
//密码: 6~16位数字和字符的组合 最多输入16个字符
validPassword <~ passwordInput.map({[unowned self] (text) -> String in
let password = (text ?? "").substring(to: 16)
let isValidPassword = NSPredicate(format: "SELF MATCHES %@", "^(?=.*[a-zA-Z0-9].*)(?=.*[a-zA-Z\\W].*)(?=.*[0-9\\W].*).{6,16}$")
self.errors.password = !isValidPassword.evaluate(with: password) ? InvalidPassword : ""
return password
})
//确认密码: 最多输入16个字符 我们会在下文验证两次输入是否一致
validEnsurePassword <~ ensurePasswordInput.map({
return ($0 ?? "").substring(to: 16)
})
//验证码: 1~6位数字或字符 最多输入6个字符
validVerifyCode <~ verifyCodeInput.map({[unowned self] (text) -> String in
let verifyCode = (text ?? "").substring(to: 6)
let isValidVerifyCode = NSPredicate(format: "SELF MATCHES %@", "\\w+")
self.errors.verifyCode = !isValidVerifyCode.evaluate(with: verifyCode) ? InvalidVerifyCode : ""
return verifyCode
})
}
}
有了有效输入后, 我们就可以着手点击事件处理了, 先处理验证码的点击事件:
//因为没后台 所以给到一个任意输出的信号 只要不输出Error 那就是请求成功
typealias AnyAPIAction = ReactiveSwift.Action
typealias AnyAPIProducer = ReactiveSwift.SignalProducer
1. 首先我们需要一个网络请求
class UserAPIManager: HTTPAPIManager {
//获取验证码 (假装有后台)
func getVerifyCode(phoneNumber: String) -> AnyAPIProducer {
return arc4random() % 2 == 1 ? AnyAPIProducer(error: APIError(489489)) : AnyAPIProducer(value: true)
}
}
class RegisterViewModel {
private var timer: Timer?
private var time = MutableProperty(60)
private(set) var errorText = MutableProperty("")
private(set) var verifyCodeText = MutableProperty("验证码")
2. 然后需要一个Action发起网络请求
private(set) lazy var getVerifyCodeAction = AnyAPIAction(enabledIf: **self.enableGetVerifyCode) { [unowned self] _ -> AnyAPIProducer in
return self.getVerifyCodeProducer
}
3. Action的执行条件是: 1)手机号格式正确 2)验证码倒计时已结束或并未开始
private var enableGetVerifyCode: Property {
return Property.combineLatest(time, errorText).map({ (time, error) -> Bool in
return error != InvalidAccount && (time <= 0 || time >= 60)
})
}
4. 发起验证码网络请求 请求成功后启动timer进行60s倒计时
private var getVerifyCodeProducer: AnyAPIProducer {
return UserAPIManager().getVerifyCode(phoneNumber: self.validAccount.value).on(value: { [unowned self] (value) in
self.timer?.invalidate()
self.time.value = 60;
self.timer = Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(self.timeDown), userInfo: nil, repeats: true)
})
}
//5. 倒计时 设置验证码按钮文案
@objc private func timeDown() {
if (self.time.value > 0) {
self.verifyCodeText.value = String(self.time.value) + "s"
} else {
timer?.invalidate()
verifyCodeText.value = "验证码";
}
self.time.value -= 1;
}
}
接着是提交注册的点击事件:
1. 首先我们需要一个网络请求
class UserAPIManager: HTTPAPIManager {
func registerProducer(account: String, password: String, verifyCode: String) -> AnyAPIProducer {
//注册用户 (假装有后台)
return arc4random() % 2 == 1 ? AnyAPIProducer(error: APIError(789465)) : AnyAPIProducer(value: true)
}
}
class RegisterViewModel {
private(set) var errorText = MutableProperty("")
2. 然后需要一个Action发起网络请求
private(set) lazy var submitAction: AnyAPIAction = AnyAPIAction(enabledIf: self.enableSubmit) { [unowned self] _ -> AnyAPIProducer in
return self.submitProducer
}
3. Action的执行条件是: 1)手机号格式正确 2)密码格式正确 3)两次输入密码一致 4)验证码格式正确
private var enableSubmit: Property {
return Property.combineLatest(validAccount, validPassword, validEnsurePassword, validVerifyCode).map({ [unowned self] (account, password, ensurePassword, verifyCode) -> Bool in
//顺便在这里设置错误信息
if self.errors.account.count > 0 {
self.errorText.value = self.errors.account
} else if self.errors.password.count > 0 {
self.errorText.value = self.errors.password
} else if password != ensurePassword {
self.errorText.value = "两次输入的密码不一致"
} else if self.errors.verifyCode.count > 0 {
self.errorText.value = self.errors.verifyCode
} else {
self.errorText.value = ""
}
return self.errorText.value.count == 0
})
}
4.发起提交注册网络请求 请求成功后保存一些用户信息
private var submitProducer: AnyAPIProducer {
return UserAPIManager().registerProducer(account: validAccount.value, password: self.validPassword.value, verifyCode: validVerifyCode.code).on(value: { [unowned self] (value) in
self.timer?.invalidate()
UserDefaults.account = value
})
}
}
ViewModel的接口都实现了, 接下来就是Controller来使用这些接口对View进行绑定:
class RegisterViewController: UIViewController {
private var viewModel: RegisterViewModelProtocol! {
didSet {
//1. 设置依赖数据源
viewModel.setInput(accountInput: accountTF.reactive.continuousTextValues,
passwordInput: passwordTF.reactive.continuousTextValues,
ensurePasswordInput: ensurePasswordTF.reactive.continuousTextValues,
verifyCodeInput: verifyCodeTF.reactive.continuousTextValues)
//2. 绑定有效输入
accountTF.reactive.text <~ viewModel.validAccount
passwordTF.reactive.text <~ viewModel.validPassword
ensurePasswordTF.reactive.text <~ viewModel.validEnsurePassword
//3. 绑定错误信息
errorLabel.reactive.text <~ viewModel.errorText.signal.skip(first: 1)
//4. 绑定验证码相关信息
verifyCodeTF.reactive.text <~ viewModel.validVerifyCode
verifyCodeButton.reactive.title <~ viewModel.verifyCodeText
//5. 绑定验证码点击事件(因为前面已经注入了验证码输入 所以这里我们不需要给到input)
verifyCodeButton.reactive.pressed = CocoaAction(viewModel.getVerifyCodeAction)
viewModel.getVerifyCodeAction.errors.observeValues {[unowned self] (error) in
self.view.toast(error.reason)//验证码获取失败了 礼貌性的给个toast
}
//6. 绑定提交注册点击事件(同样的 不需要给到input)
submitButton.reactive.pressed = CocoaAction(viewModel.submitAction)
viewModel.submitAction.errors.observeValues {[unowned self] (error) in
self.view.toast(error.reason)//注册失败了 礼貌性的给个toast
}
viewModel.submitAction.values.observeValues {[unowned self] (value) in
//注册成功返回首页 至于信息保存一类的事情ViewModel已经做完了 Controller做好UI展示就够了
self.view.toast("注册成功")
self.navigationController?.popViewController(animated: true)
}
}
}
}
事实上, 在一个函数写完所有的绑定逻辑并不是什么好的代码规范(我应该把它拆开成多个小函数), 但考虑到这部分代码不多且只是个demo, 就先凑合吧. 荆轲刺秦王...
本文附带的Swift版Demo地址
本文附带的OC版Demo地址
也许你会用得上这些
ReactiveSwift的更多API示例代码请下载ReactiveSwift. 下载下来后: 1) 打开ReactiveSwift.xcworkspace 2)切换到 Result-Mac scheme进行编译 3)然后切换到 ReactiveSwift-macOS scheme进行编译 4)跟着ReactiveSwift.playground敲吧
ReactiveSwift的官方设计文档(只有英文版)
本文Demo中涉及到的MVVM概述