①可被监听的序列-概念
❶Observable理解
-
Observable<T> 类
用于描述元素异步产生的序列,既可观察序列,是 Rx 框架的基础 -
作用是
:异步地产生一系列的Event
(事件),即一个Observable<T>
对象会随着时间推移不定期地发出event(element : T)
-
Event 还可以携带数据,它的泛型
<T>
就是用来指定这个 Event 携带的数据的类型 -
每一个Observable的实例都是一个序列
-
Observable序列相比于Swift序列的关键优势点在于它能够
异步地接收元素
-
有可观察序列,还需要一个
Observer
(订阅者)来订阅它,这个订阅者才能收到Observable<T>
不时发出的 Event
Observable(ObservableType) | 等效于Sequence |
observableType.subscribe(_:) | 方法等效于Sequence.makeIterator() |
ObservableType.subscribe(_:) | 接收一个观察者ObserverType参数,它将被订阅自动接收由可观察到的序列事件和元素,而不是在返回的生成器上手动调用next() |
- 如果一个Observable发出一个next事件(Event.next(Element)),它还能够继续发出更多的事件
- 如果一个Observable发出一个error事件(Event.error(ErrorType))或者一个completed事件(Event.completed),那么这个Observable序列就不能给订阅者发送其他的事件了
❷创建序列
框架已经创建好了许多常用的序列。例如:
button
的点击,textField
的当前文本,switch
的开关状态,slider
的当前数值等等一些自定义的序列是需要自己创建的
- 创建序列最直接的方法就是调用
Observable.create
创建一个 [0, 1, ... 4] 的序列
-
调用
Observable.create
,在构建函数里面描述元素的产生过程 -
observer.onNext(0)
就代表产生了一个元素,他的值是 0 -
又产生 4个元素分别是
1, 2, ... 4
-
最后,用
observer.onCompleted()
表示元素已经全部产生,没有更多元素了
let numbers: Observable<Int> = Observable.create { observer -> Disposable in
observer.onNext(0)
observer.onNext(1)
observer.onNext(2)
observer.onNext(3)
observer.onNext(4)
observer.onCompleted()
return Disposeable.create()
}
复制代码
可以用这种方式来封装功能组件,例如:闭包回调
- 在闭包回调中,如果任务失败,就调用
observer.onError(error!)
- 如果获取到目标元素,就调用
observer.onNext(jsonObject)
- 由于这个序列只有一个元素,所以在成功获取到元素后,就直接调用
observer.onCompleted()
来表示任务结束 - 最后
Disposables.create { task.cancel() }
说明如果数据绑定被清除(订阅被取消)的话,就取消网络请求。
typealias JSON = Any
let json: Observable<JSON> = Observable.create { (observer) -> Disposable in
let task = URLSession.shared.dataTask(with: ...) { data, _, error in
guard error == nil else {
observer.onError(error!)
return
}
guard let data = data,
let jsonObject = try? JSONSerialization.jsonObject(with: data, options: .mutableLeaves)
else {
observer.onError(DataError.cantParseJSON)
return
}
observer.onNext(jsonObject)
observer.onCompleted()
}
task.resume()
return Disposables.create { task.cancel() }
}
复制代码
以上就将传统的闭包回调转换成序列。然后用
subscribe
方法来响应这个请求的结果
json.subscribe(
onNext: { json in
print("取得 json 成功: \(json)")},
onError: { error in
print("取得 json 失败 Error: \(error.localizedDescription)")},
onCompleted: {
print("取得 json 任务成功完成")}
)
.disposed(by: disposeBag)
复制代码
❸Event
事件 Event 的定义
- Event 就是一个枚举,一个 Observable 是可以发出 3 种不同类型的 Event 事件
public enum Event<Element>{
case next(Element)
case error(Swift.Error)
case completed
}
复制代码
next
- next 事件就是那个可以携带数据 的事件,可以说它就是一个“最正常”的事件
1--2--3--->
复制代码
error
- error 事件表示一个错误,它可以携带具体的错误内容,一旦 Observable 发出了 error event,则这个 Observable 就等于终止了,以后它再也不会发出 event 事件了
-------1-----2------ x
复制代码
completed
- completed:completed 事件表示 Observable 发出的事件正常地结束了,跟 error 一样,一旦 Observable 发出了 completed event,则这个 Observable 就等于终止了,以后它再也不会发出 event 事件了
------1 ------2--------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,还要用 subscribe() 方法来订阅它,接收它发出的 Event
订阅方法1
❶使用 subscribe() 订阅一个 Observable 对象
- 该方法的 block 的回调参数就是被发出的 event 事件,将其直接打印出来
let observable = Observable.of("A","B","C")
observable.subscribe { event in
print(event)}
//print
next(A)
next(B)
next(C)
completed
复制代码
❷如果获取到事件里的数据,通过 event.element
let observable = Observable.of("A","B","C")
observable.subscribe{ event in
print(eventt.element)}????????????
//print
Optional("A")
Optional("B")
Optional("C") q
nil
复制代码
订阅方法2
RxSwift还提供另一个subscribe 方法,它可以把 event 进行分类
- 通过不同的 block 回调处理不同类型的 event(其中 onDisposed 表示订阅行为被 dispose 后的回调)
- 同时会把 event 携带的数据直接解包出来作为参数,方便我们使用
let observable = Observable("A","B","C")
observable.subscribe(
onNext:{ element in
print(element) },
onError:{error in
print(error)},
onCompleted:{
print("completed")},
onDisposed:{
print("disposed")
}
)
//print
A
B
C
completed
disposed
复制代码
- subscribe() 方法的 onNext、onError、onCompleted 和 onDisposed 这四个回调 block 参数都是有默认值的,即它们都是可选的。我们可以只处理 onNext 而不管其他的情况
let observable = Observable.of("A","B","C")
observable.subscribe(
onNext:{element in
print(element)}
)
//print
A
B
C
复制代码
③Observable 事件监听
监听事件的生命周期
doOn 介绍
使用 doOn 方法来监听事件的生命周期,它会在每一次事件发送前被调用
同时它和 subscribe 一样,可以通过不同的 block 回调处理不同类型的 event
- do(onNext:) 方法就是在 subscribe(onNext:) 前调用
- 而 do(onCompleted:) 方法则会在 subscribe(onCompleted:) 前面调用
栗子
let observable = Observable.of("A","B","C")
observable.do(
onNext: { element in
print("Intercepted Next:", element)},
onError: {error in
print("Intercepted Error:", error)},
onCompleted: {
print("Intercepted Completed")
},
onDispose: {
print("Intercepted Disposed")
}
)
.subscribe(
onNext: {element in
print(element)},
onError: {error in
print(error)},
onCompleted:{
print("completed")},
onDisposed:{
print("disposed")
}
)
复制代码
④Observable 的Dispose
❶Observable 从创建到终结流程
一个 Observable 序列被创建出来后它不会马上就开始被激活从而发出 Event,而是要等到它被某个人订阅了才会激活它 而Observable序列激活之后要一直等到它发出了 .error 或者 .completed 的 event后,它才被终结
❷dispose() 方法
除了 dispose() 方法之外,更经常用 DisposeBag 的对象来管理多个订阅行为的销毁
- 以把一个DisposeBag对象看成一个垃圾袋,把用过的订阅行为都放进去,感觉有点像OC释放池
- 而这个DisposeBag就会在自己快要dealloc的时,对它里面的所有订阅行为都调用 dispose() 方法
let disposeBag = DisposeBag()
//第1个Observable,和订阅
let observable1 = Observable.of("A","B","C")
observable1.subscribe{ event in
print(event)}
.disposed(by: disposeBag)
//第2个Observable,和订阅
let observable2 = Obserable.of(1,2,3)
observable2.subscribe{event in
print(event)}
.disposed(by: disposeBag)
复制代码