写在前面
RxSwift 是 ReactiveX 家族的重要一员, ReactiveX 是 Reactive Extensions 的缩写,一般简写为Rx。
ReactiveX 官方给Rx的定义是,Rx是一个使用可观察数据流进行异步编程的编程接口。
ReactiveX结合了观察者模式、迭代器模式和函数式编程的精华。
RX模式
- 创建:Rx可以方便的创建事件流和数据流
- 组合:Rx使用查询式的操作符组合和变换数据流
- 监听:Rx可以订阅任何可观察的数据流并执行操作
简化代码
- 函数式风格:对可观察数据流使用无副作用的输入输出函数,避免了程序里错综复杂的状态
- 简化代码:Rx的操作符通通常可以将复杂的难题简化为很少的几行代码
- 异步错误处理:传统的try/catch没办法处理异步计算,Rx提供了合适的错误处理机制
- 轻松使用并发:Rx的Observables和Schedulers让开发者可以摆脱底层的线程同步和各种并发问题
为什么要使用
我们编写的绝大部分代码都涉及到外部事件的响应。当一个用户操作控制的时候,我们需要写一个@IBAction来处理。我们需要观察通知来监测键盘如何更改位置。URL回话响应数据时,我们需要用闭包来执行。我们使用KVO来监听变量的改变。所有这些不同的系统都让我们的代码不必要的复杂。如果有一个一致统一的系统来处理这些呼叫/响应,那岂不是很好。RX就是这样一个系统。
概念
所有Observable实例只是一个队列。
Observable队列比swift队列的好处就是他可以异步接受元素。这是RXSwift的核心,所有扩展都是在这个概念基础上的。
Observable(ObservableType)跟Sequence一样
ObservableType.subscribe(_:)和Sequence.makeIterator()类似
ObservableType.subscribe(_:)拥有一个观察者对象(ObserverType)的参数,这个对象将被订阅自动接受队列事件和Observable所发出的元素,而不是手动的调用next()
如果一个Observable发出一个next事件Event.next(Element),她可以继续发出更多的事件。当然如果发出一个error事件Event.error(ErrorType)或者一个完成事件Event.completed,Observable队列不会再给订阅者发送额外的事件。源代码里是一个递归枚举
public enum Event<Element> {
/// Next element is produced.
case next(Element)
/// Sequence terminated with an error.
case error(Error)
/// Sequence completed successfully.
case completed
}
Observables and observers
Observables不会执行订阅的闭包除非有一个订阅者。下面的例子中,Observable的订阅闭包不会执行,因为她并没有订阅者。她只是一个可被订阅者。
_ = Observable<String>.create { observerOfString -> Disposable in
print("This will never be printed")
observerOfString.on(.next("😬"))
observerOfString.on(.completed)
return Disposables.create
}
下面这种情况,当调用subscribe(_:)方法了,闭包就会被执行了
_ = Observable<String>.create { observerOfString in
print("Observable created")
observerOfString.on(.next("😉"))
observerOfString.on(.completed)
return Disposables.create()
}
.subscribe { event in
print(event)
}
subscribe(_:)这个方法返回Disposable实例。这种类型以后会讨论。就是一个可以被释放的类型,需要释放。
构建和订阅Observables
never
构建一个从不终止和发出任何事件的队列
let disposeBag = DisposeBag()
let neverSequence = Observable<String>.never()
let neverSequenceSubscription = neverSequence
.subscribe { _ in
print("This will never be printed")
}
neverSequenceSubscription.disposed(by: disposeBag)
empty
构建一个空的Observable队列,只发出完成事件
let disposeBag = DisposeBag()
Observable<Int>.empty()
.subscribe { event in
print(event)
}
.disposed(by: disposeBag)
just
构建一个只有一个元素的Observable队列
let disposeBag = DisposeBag()
Observable.just("🔴")
.subscribe { event in
print(event)
}
.disposed(by: disposeBag)
of
构建一个拥有固定数量元素的Observable序列
let disposeBag = DisposeBag()
Observable.of("🐶", "🐱", "🐭", "🐹")
.subscribe(onNext: { element in
print(element)
})
.disposed(by: disposeBag)
subscribe(_:)方法接受事件参数,下面这个例子接受元素参数
someObservable.subscribe(
onNext: { print("Element:", $0) },
onError: { print("Error:", $0) },
onCompleted: { print("Completed") },
onDisposed: { print("Disposed") }
)
from
从序列中创建可观察到的序列,如数组、字典或集合。
let disposeBag = DisposeBag()
Observable.from(["🐶", "🐱", "🐭", "🐹"])
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
create
构建一个自定义的可观察序列
let disposeBag = DisposeBag()
let myJust = { (element: String) -> Observable<String> in
return Observable.create { observer in
observer.on(.next(element))
observer.on(.completed)
return Disposables.create()
}
}
myJust("🔴")
.subscribe { print($0) }
.disposed(by: disposeBag)
range
创建一个可观察序列,该序列释放一系列连续整数,然后终止
let disposeBag = DisposeBag()
Observable.range(start: 1, count: 10)
.subscribe { print($0) }
.disposed(by: disposeBag)
repeatElement
创建一个可观察到的序列,它无限地释放给定的元素
let disposeBag = DisposeBag()
Observable.repeatElement("🔴")
.take(3)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
generate
创建一个可观察的序列,只要所提供的条件求值为true,就生成值。
let disposeBag = DisposeBag()
Observable.generate(
initialState: 0,
condition: { $0 < 3 },
iterate: { $0 + 1 }
)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
deferred
为每个订阅者创建一个新的可观察序列。
let disposeBag = DisposeBag()
var count = 1
let deferredSequence = Observable<String>.deferred {
print("Creating \(count)")
count += 1
return Observable.create { observer in
print("Emitting...")
observer.onNext("🐶")
observer.onNext("🐱")
observer.onNext("🐵")
return Disposables.create()
}
}
deferredSequence
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
deferredSequence
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
error
创建一个没有任何元素的可观察序列,并立即以错误结束。
let disposeBag = DisposeBag()
Observable<Int>.error(TestError.test)
.subscribe { print($0) }
.disposed(by: disposeBag)
doOn
为每个发出的事件调用副作用动作并返回(传递)原始事件。
let disposeBag = DisposeBag()
Observable.of("🍎", "🍐", "🍊", "🍋")
.do(onNext: { print("Intercepted:", $0) }, onError: { print("Intercepted error:", $0) }, onCompleted: { print("Completed") })
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)