①可被监听的序列-概念
❶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)
复制代码
3074
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
