一、关于Swift
苹果公司有两种开发语言，大儿子Objective-C，这几年已经很久没更新过新东西了，小儿子Swift，虽然前几个版本不太稳定，但一直是重点培养的对象，在 2019 年的 WWDC 大会之前，Swift 5 正式发布了，更让大家激动的是这一版本的 ABI 稳定了！以后可以尽情的用Swift挥霍了，至于Swift与Objective-C对比的优势，百度一下就会有很多介绍。除此之外，用Swift还可以开发服务器，这对于一个iOSer想做全栈的人来说，无疑是一个爆炸性的消息，目前用Swift开发服务器，常用的框架有Vapor、Perfect、Kitura和Zewo，有兴趣的小伙伴可以去Github上搜一搜，这里就不多说了。
使用Objective-C开发的人应该都听过RAC，函数响应式编程是有多么的强大，而在Swift中也同样存在着这么一个强大的开发利器，那就是RxSwift。
二、RxSwift介绍
RxSwift全称ReactiveX for Swift，是一个简化异步编程的框架，实现了函数响应式编程，事件与对象紧密联系，业务流清晰，便于管理。在RxSwift中，所有异步操作（事件）和数据流均被抽象为可观察序列的概念。流程：
创建序列 -> 订阅序列 -> 发送信号 -> 信号接收
下面就简单用几个常用的小例子来感觉一下RxSwift的用起来是有多么爽
三、RxSwift简单应用
1.button的点击事件
private func test() -> Void {
//正常写法
let button = UIButton(type: .custom)
button.addTarget(self, action: #selector(btnTap(_:)), for: .touchUpInside)
}
@objc private func btnTap(_ btn: UIButton) -> Void {
}
//Rx写法
private func test() -> Void {
let button = UIButton(type: .custom)
button.rx.tap
.subscribe(onNext: { () in
//按扭被点击后的逻辑
})
.disposed(by: disposeBag)
}
2.添加手势点击事件
//正常写法
private func test() -> Void {
self.view.isUserInteractionEnabled = true
let tap = UITapGestureRecognizer(target: self, action: #selector(viewTap(_:)))
self.view.addGestureRecognizer(tap)
}
@objc private func viewTap(_ tap: UITapGestureRecognizer) -> Void {
}
//Rx写法
private func test() -> Void {
self.view.isUserInteractionEnabled = true
let tap = UITapGestureRecognizer(target: self, action: #selector(viewTap(_:)))
self.view.addGestureRecognizer(tap)
tap.rx.event
.subscribe(onNext: { (gesture) in
})
.disposed(by: disposeBag)
3.UITextField监听文本变化
正常的写法我就不写了，太麻烦，还得写代理方法，Rx这里有两种方式
//1.通过文本变化
private func test() -> Void {
let textField = UITextField()
textField.rx.text.orEmpty.changed
.subscribe(onNext: { (text) in
})
.disposed(by: disposeBag)
}
//2.通过事件，像我们监听键盘点击了retuen事件，也是通过这个方式，换成editingDidEndOnExit即可
private func test() -> Void {
let textField = UITextField()
textField.rx.controlEvent(.editingChanged)
.subscribe(onNext: { (text) in
})
.disposed(by: disposeBag)
}
4.将UITextField内容绑定到UILabel上
正常我们想写此功能，我们需要使用KVO或者写UITextField的代理方法，然后再往UILabel上赋值，然而用Rx就很便利了
_ = textField.rx.text.bind(to: label.rx.text)
5.KVO监听
self.person.rx.observeWeakly(String.self, "name").subscribe(onNext: { (value) in
//处理事件
}).disposed(by: disposeBag)
6.滑动时监听contentoffset
scrollview.rx.contentOffset.subscribe(onNext: { [weak self] (content) in
let y = content.y
print(content.y)
//处理事件 ……
}).disposed(by: disposeBag)
7.定时器
let timer = Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)
timer.subscribe(onNext: { (time) in
print("\(time)")
})
.disposed(by: disposeBag)
//或者写到一起
Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)
.subscribe(onNext: { (time) in
})
.disposed(by: disposeBag)
8.通知（键盘弹出）
NotificationCenter.default.rx.notification(UIResponder.keyboardWillShowNotification)
.subscribe(onNext: { (notification) in
})
.disposed(by: disposeBag)
9.网络请求
//正常写法
let url = URL(string: "https://www.baidu.com")
URLSession.shared.dataTask(with: url!) { (data, response, error) in
}.resume()
//Rx写法
URLSession.shared.rx.response(request: URLRequest(url: url!))
.subscribe(onNext: { (response, data) in
}, onError: { (error) in
}, onCompleted: {
})
.disposed(by: disposeBag)
四、RxSwift核心原理
1.Observable<T>
Observable<T> 这个类就是Rx框架的基础，可以称它为可观察序列。它的作用就是可以异步地产生一系列的 Event（事件），即一个 Observable<T> 对象会随着时间推移不定期地发出 event(element : T) 这样一个东西。
而且这些 Event 还可以携带数据，它的泛型 <T> 就是用来指定这个Event携带的数据的类型。
有了可观察序列，我们还需要有一个Observer（订阅者）来订阅它，这样这个订阅者才能收到 Observable<T> 不时发出的 Event。
2.Event
/// Represents a sequence event.
///
/// Sequence grammar:
/// **next\* (error | completed)**
public enum Event<Element> {
/// Next element is produced.
case next(Element)
/// Sequence terminated with an error.
case error(Swift.Error)
/// Sequence completed successfully.
case completed
}
由上代码可知，Observable可以产生三种Event事件
-
next：
next事件就是那个可以携带数据 <T> 的事件 -
error：
error事件表示一个错误，它可以携带具体的错误内容，一旦Observable发出了error Event，则这个Observable就等于终止了，以后它再也不会发出Event事件了。 -
completed：
completed事件表示Observable发出的事件正常地结束了，跟 error 一样，一旦 Observable 发出了completed Event，则这个Observable就等于终止了，以后它再也不会发出event事件了。
3.Observable 与 Sequence比较
为更好地理解，我们可以把每一个 Observable 的实例想象成于一个 Swift 中的 Sequence：
- 即一个
Observable（ObservableType）相当于一个序列Sequence（SequenceType）。 -
ObservableType.subscribe(_:)方法其实就相当于SequenceType.generate()
但它们之间还是有许多区别的：
- Swift 中的
SequenceType是同步的循环，而Observable是异步的。 -
Observable对象会在有任何Event时候，自动将Event作为一个参数通过ObservableType.subscribe(_:)发出，并不需要使用next方法。
五、创建 Observable 序列
我们可以通过如下几种方法来创建一个Observable序列
1.just() 方法
该方法通过传入一个默认值来初始化。即指定了这个 Observable所发出的事件携带的数据类型必须是指定的类型。
let observable = Observable<Int>.just(5)
2.of() 方法
该方法可以接受可变数量的参数（必需要是同类型的）,Swift 也会自动推断类型。
let observable = Observable.of("A", "B", "C")
3.from() 方法
该方法需要一个数组参数。
let observable = Observable.from(["A", "B", "C"])
4.empty() 方法
该方法创建一个空内容的 Observable 序列。
let observable = Observable<Int>.empty()
5.never() 方法
该方法创建一个永远不会发出 Event（也不会终止）的 Observable 序列。
let observable = Observable<Int>.never()
6.error() 方法
该方法创建一个不做任何操作，而是直接发送一个错误的 Observable 序列。
enum MyError: Error {
case A
case B
}
let observable = Observable<Int>.error(MyError.A)
7.range() 方法
该方法通过指定起始和结束数值，创建一个以这个范围内所有值作为初始值的Observable序列。
//两种方法创建的 Observable 序列都是一样的。
//使用range()
let observable = Observable.range(start: 1, count: 5)
//使用of()
let observable = Observable.of(1, 2, 3 ,4 ,5)
8.repeatElement() 方法
该方法创建一个可以无限发出给定元素的Event的Observable序列（永不终止）。
let observable = Observable.repeatElement(1)
9.generate() 方法
该方法创建一个只有当提供的所有的判断条件都为 true 的时候，才会给出动作的 Observable 序列。
//两种方法创建的 Observable 序列都是一样的。
//使用generate()方法
let observable = Observable.generate(
initialState: 0,
condition: { $0 <= 10 },
iterate: { $0 + 2 }
)
//使用of()方法
let observable = Observable.of(0, 2, 4, 6, 8, 10)
10.create() 方法
该方法接受一个 block 形式的参数，任务是对每一个过来的订阅进行处理。
//这个block有一个回调参数observer就是订阅这个Observable对象的订阅者
//当一个订阅者订阅这个Observable对象的时候，就会将订阅者作为参数传入这个block来执行一些内容
let ob = Observable<String>.create { (observer) -> Disposable in
observer.onNext("abc")
return Disposables.create()
}
ob.subscribe(onNext: { (text) in
print(text)
}, onError: { (error) in
}, onCompleted: {
})
.disposed(by: disposeBag)
11.deferred() 方法
该个方法相当于是创建一个 Observable 工厂，通过传入一个 block 来执行延迟 Observable序列创建的行为，而这个 block 里就是真正的实例化序列对象的地方。
//用于标记是奇数、还是偶数
var isOdd = true
//使用deferred()方法延迟Observable序列的初始化，通过传入的block来实现Observable序列的初始化并且返回。
let factory : Observable<Int> = Observable.deferred {
//让每次执行这个block时候都会让奇、偶数进行交替
isOdd = !isOdd
//根据isOdd参数，决定创建并返回的是奇数Observable、还是偶数Observable
if isOdd {
return Observable.of(1, 3, 5 ,7)
}else {
return Observable.of(2, 4, 6, 8)
}
}
//第1次订阅测试
_ = factory.subscribe { event in
print("\(isOdd)", event)
}
//第2次订阅测试
_ = factory.subscribe { event in
print("\(isOdd)", event)
}
12.interval() 方法
这个方法创建的 Observable 序列每隔一段设定的时间，会发出一个索引数的元素。而且它会一直发送下去。这就像是我们常用的定时器一样
//每 1 秒发送一次，并且是在主线程（MainScheduler）发送。
Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)
.subscribe(onNext: { (time) in
})
.disposed(by: disposeBag)
另一种是创建的 Observable 序列在经过设定的一段时间后，每隔一段时间产生一个元素。
Observable<Int>.timer(.seconds(5), period: .seconds(1), scheduler: MainScheduler.instance)
.subscribe(onNext: { (time) in
})
.disposed(by: disposeBag)
六、关于Observable的执行逻辑
先写一个简单的小例子
//创建一个序列
let ob = Observable<Any>.create { (observer) -> Disposable in
//发送内容
observer.onNext("abc")
//发送错误
observer.onError(NSError(domain: "error", code: 10086, userInfo: nil))
//发送完成
observer.onCompleted()
return Disposables.create()
}
//订阅序列
ob.subscribe(onNext: { (any) in
print("订阅到\(any)")
}, onError: { (error) in
print("订阅到错误\(error)")
}, onCompleted: {
print("订阅到完成")
})
.disposed(by: disposeBag)
执行结果为：
订阅到abc
订阅到错误Error Domain=error Code=10086 "(null)"
因为error event与completed event是互斥的，所以不论先执行哪个，另一个也不会执行
1.Observable的逻辑大致可以归纳为以下几点：
- 在创建Observable类的ob对象时，调用的create方法，实际上是保存了我们的create实现的闭包。
- 在ob调用subscribe时，已经把订阅的实现逻辑封装到了闭包内，并且把这个闭包封装成了一个叫observer的临时变量，然后调用了AnonymousObservable的subscribe方法。
- AnonymousObservable的subscribe方法，默认创建了AnonymousObservableSink类，并把observer保存成自己属性，又通过该类的run方法调用了第一步里保存的闭包，并把自己作为参数穿进去，用以让第一步保存的闭包成功获得这个observer。
- 这样就保证了订阅方法subscribe能获得onNext里的数据。因为subscribe已经持有了Observable创建时声明的闭包。
在subscribe订阅后，获取到对应的Event对应事件处理：
- 在AnonymousObservable类调用subscribe时，实际上是创建了一个sink对象。* 在这个sink类调用我们保存的闭包的时候，也把闭包内的onNext方法方法作为event事件做了持有操作。并在调用observer对象时，把event做为参数传了进来。
- AnonymousObserver类根据传进来的event，调用不同的实现闭包。
