RxSwift学习--可观察序列Observable

时间 2019-11-24

标签 rxswift 学习观察序列 observable 繁體版

原文原文链接

前言

Observable英文直译为：可观察的，可看见的。可是在RxSwift广泛的称它为“可观察序列”,它的做用主要用来造成一条数据流或者事件流，全部的操做产生的事件都会经过Observable进行传输。 git

在Observable里有三种事件(Event: Event枚举类型，有三个成员，next，error，completed ) Observable发送的全部事件都是一个Event:github

next事件主要是当Observable里出现新的数据时会发出的事件，同时该事件会携带新的数据对象。api
completed事件是当Observable再也不有新的数据出现，Observable被标记完成,再也不产生数据.数组
error事件是当数据流遇到了错误会发出的事件，该事件也会致使Observable结束。bash

Observable(可观察序列)

1. Observable的建立

在RxSwift中，能够有多种建立Observable对象的方法,下面咱们逐一介绍：闭包

(1). create()方法

public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
        return AnonymousObservable(subscribe)
    }
复制代码

create()方法的参数是一个函数(闭包),根据闭包来建立序列，在闭包里面可自定义事件。函数须要传入参数AnyObserver类型，返回的是Disposable,AnyObserver其实就是观察者，Disposable是一个协议接口，里面只有一个dispose方法，用来释放一些资源。整个create()方法返回的是一个AnonymousObservable(匿名Observable).dom

例子：ide

let createOb = Observable<Int>.create{ (observer) -> Disposable in
        observer.onNext(1)
        observer.onCompleted()
        return Disposables.create()
    }
    
   let _ = createOb.subscribe(onNext: { (number) in
        print("订阅:",number)
    }, onError: { (error) in
        print("error:",error)
    }, onCompleted: {
        print("完成回调")
    }) {
        print("释放回调")
    }
复制代码

(2). empty()方法

public static func empty() -> Observable<E> {
        return EmptyProducer<E>()
    }
    
final private class EmptyProducer<Element>: Producer<Element> {
    override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        observer.on(.completed)
        return Disposables.create()
    }
}
复制代码

empty()方法返回一个EmptyProducer类，在这个类的内部实现了subscribe()订阅方法，且只有一个.completed状态，因此，empty()方法是一个空方法，里面没有onNext事件处理，只会处理onComplete事件。函数

例子：学习

let emtyOb = Observable<Int>.empty()
let  _ = emtyOb.subscribe(onNext: { (number) in
        print("订阅:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("完成回调")
        }) {
            print("释放回调")
        }
复制代码

(3). just()方法

public static func just(_ element: E) -> Observable<E> {
        return Just(element: element)
    }
复制代码

just()方法是单个信号序列建立，只能处理单个事件，简单来讲，咱们使用just()方法时不能将一组数据一块儿处理，只能一个一个数据进行处理。just() 根据传入的一个参数来建立序列，它会向订阅者发送两个事件，第一个发送带元素数据的.next事件，第二个发送 .completed事件。

例子：

let array = ["You","Me"]
        Observable<[String]>.just(array)
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
    let _ = Observable<[String]>.just(array).subscribe(onNext: { (number) in
            print("订阅:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("完成回调")
        }) {
            print("释放回调")
        }
复制代码

(4). of()方法

public static func of(_ elements: E ..., scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
        return ObservableSequence(elements: elements, scheduler: scheduler)
    }
复制代码

of()方法能够接受多个参数来建立实例，但这些参数必须是同类型，也就是说，of()方法是just()方法的升级版，它能够将一序列的事情组合起来一块儿处理。

例子：

Observable<String>.of("Henry","Jeannie")
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
            
 // 字典
        Observable<[String: Any]>.of(["name":"HuGe","age":18])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
 // 数组
        Observable<[String]>.of(["Peter","July"])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
复制代码

(5). from()方法

public static func from(optional: E?) -> Observable<E> {
    return ObservableOptional(optional: optional)
}
复制代码

from()方法只接收数组(数组，集合)做为参数，并抽取出数组里的元素来做为数据流中的元素,也就是说，from() 根据传入的数组元素来建立序列。它会依次发出.next事件，最后发出.completed 事件，结果和of()方法同样。

例子：

Observable<[String]>.from(optional: ["Hu","Ge"])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
复制代码

(6). deferred()方法

public static func deferred(_ observableFactory: @escaping () throws -> Observable<E>)
        -> Observable<E> {
        return Deferred(observableFactory: observableFactory)
    }
复制代码

deferred()方法是延时建立Observable对象，当subscribe的时候才去建立，它为每个bserver建立一个新的Observable；

例子：

//用于标记是奇数、仍是偶数
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)
}
复制代码

(7). range()方法

public static func range(start: E, count: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
        return RangeProducer<E>(start: start, count: count, scheduler: scheduler)
    }
复制代码

range()方法经过指定起始和结束数值，建立一个以这个范围内全部值做为初始值的 Observable 序列。range()方法其实和of()方法很类似，其功能和of()差很少，咱们只要输出start和count而后就能生成一组数据，让它们执行onNext。值得注意的是，range()方法只生成Observable类型。

例子：

Observable.range(start: 2, count: 5)
    .subscribe { (event) in
        print(event)
    }.disposed(by: disposeBag)
复制代码

(8). generate()方法

public static func generate(initialState: E, condition: @escaping (E) throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: @escaping (E) throws -> E) -> Observable<E> {
        return Generate(initialState: initialState, condition: condition, iterate: iterate, resultSelector: { $0 }, scheduler: scheduler)
    }
复制代码

generate()方法建立一个只有当提供的全部的判断条件都为 true 的时候，才会给出动做的Observable序列。generate()方法是一个迭代器，它一直循环onNext事件，直到condition不知足要求退出。generate()有四个参数，第一个是最开始的循环变量，第二个是条件，第三个是迭代器，这个迭代器每次运行都会返回一个E类型，做为下一次是否执行onNext事件源，而是否正的要执行则看是否知足condition条件。其实咱们能够理解generate()就是一个循环体，其内部实现也正是一个循环，相似于数组的遍历，具体实现代码在GenerateSink的run方法。

例子：

Observable.generate(initialState: 0,// 初始值
                    condition: { $0 < 10}, // 条件1
                    iterate: { $0 + 2 })  // 条件2 +2
        .subscribe { (event) in
                print(event)
        }.disposed(by: disposeBag)
复制代码

(9). timer()方法

public static func timer(_ dueTime: RxTimeInterval, period: RxTimeInterval? = nil, scheduler: SchedulerType)
        -> Observable<E> {
        return Timer(
            dueTime: dueTime,
            period: period,
            scheduler: scheduler
        )
    }
复制代码

timer()方法是建立的Observable 序列在通过设定的一段时间后，产生惟一的一个元素，或者每隔一段时间产生一个元素。这取决于period是否有值。

例子：

let observable = Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}
复制代码

(10). interval()方法

public static func interval(_ period: RxTimeInterval, scheduler: SchedulerType)
        -> Observable<E> {
        return Timer(
            dueTime: period,
            period: period,
            scheduler: scheduler
        )
    }
复制代码

interval()方法建立的 Observable 序列每隔一段设定的时间，会发出一个索引数的元素。并且它会一直发送下去。差异在于timer()能够设置间隔时间和持续时间，而interval()的间隔时间和持续时间是同样的。

例子：

//下面方法让其每 1秒发送一次，而且是在主线程（MainScheduler）发送。
let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}
复制代码

(11). repeatElement()方法

public static func repeatElement(_ element: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
        return RepeatElement(element: element, scheduler: scheduler)
    }
复制代码

repeatElement()方法建立一个能够无限发出给定元素的Event的Observable序列，它是无限循环的，会一直循环onNext方法，不会终止。

例子：

Observable<Int>.repeatElement(5)
    .subscribe { (event) in  
     print("订阅:",event)
    }
    .disposed(by: disposeBag)
复制代码

(12). error()方法

public static func error(_ error: Swift.Error) -> Observable<E> {
        return ErrorProducer(error: error)
}

final private class ErrorProducer<Element>: Producer<Element> {
    private let _error: Swift.Error
    
    init(error: Swift.Error) {
        self._error = error
    }
    
    override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        observer.on(.error(self._error))
        return Disposables.create()
    }
}
复制代码

error()方法是返回一个只能调用onError方法的Observable序列。其中的onNext和OnCompleted方法是不会执行的。

例子：

Observable<String>.error(NSError.init(domain: "ObservableError", code: 10010, userInfo: ["reason":"unknow"]))
            .subscribe { (event) in
                print("订阅:",event)
            }
            .disposed(by: disposeBag)
复制代码

(13). never()方法

public static func never() -> Observable<E> {
        return NeverProducer()
    }
    
final private class NeverProducer<Element>: Producer<Element> {
    override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        return Disposables.create()
    }
}
复制代码

never()方法建立一个永远不会发出 Event，也不会终止的 Observable序列。就是返回一个无终止的观察者事件序列，能够用来表示无限持续时间。

例子：

let neverSequence = Observable<Int>.never()
    _ = neverSequence.subscribe { event in
        print(event)
   }
复制代码

2. Observable的订阅

建立完了 Observable，还要使用 subscribe() 方法来订阅它，并接收它发出的 Event。

(1). Subscribes event handler

public func subscribe(_ on: @escaping (Event<E>) -> Void)
        -> Disposable {
        
        }
复制代码

这种subscribe()方法订阅了一个 Observable 对象，该方法的 block的回调参数就是被发出的 event 事件.

例子：

let observable = Observable.of(1, 2, 3)
         
observable.subscribe { event in
    print(event)
    print(event.element)
}
复制代码

这里能够看到初始化 Observable 序列时设置的默认值都按顺序经过 .next 事件发送出来，等到数据都发送完毕，它还会自动发一个 .completed 事件出来。

(2). Subscribes element handler

public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
        -> Disposable {
        }
复制代码

这种subscribe()预订方法，它能够把 event 进行分类：.next，.completed，.error以处理不一样类型的event,同时会把 event 携带的数据直接解包出来做为参数.

例子：

let observable = Observable.of("A", "B", "C")
         
observable.subscribe(onNext: { element in
    print(element)
}, onError: { error in
    print(error)
}, onCompleted: {
    print("completed")
}, onDisposed: {
    print("disposed")
})
复制代码

onNext、onError、onCompleted 和 onDisposed 这四个回调参数都是有默认值的，即它们都是可选的。因此也能够只处理 onNext而无论其余的状况。

3. Observable的事件生命周期

public func `do`(onNext: ((E) throws -> Void)? = nil, onError: ((Swift.Error) throws -> Void)? = nil, onCompleted: (() throws -> Void)? = nil, onSubscribe: (() -> Void)? = nil, onSubscribed: (() -> Void)? = nil, onDispose: (() -> Void)? = nil)
        -> Observable<E> {
            return Do(source: self.asObservable(), eventHandler: { e in
                switch e {
                case .next(let element):
                    try onNext?(element)
                case .error(let e):
                    try onError?(e)
                case .completed:
                    try onCompleted?()
                }
            }, onSubscribe: onSubscribe, onSubscribed: onSubscribed, onDispose: onDispose)
    }
复制代码

当 Observable 的某些事件产生时，你可使用 do() 操做符来注册一些回调操做。这些回调会被单独调用，它们会和 Observable 本来的回调分离。

可使用 do() 方法来监听事件的生命周期，它会在每一次事件发送前被调用，同时它和 subscribe() 同样，能够经过不一样的回调处理不一样类型的 event。

例子：

let observable = Observable.of("A", "B", "C")
 
observable.do(onNext: { element in
        print("Next：", element)
    }, onError: { error in
        print("Error：", error)
    }, onCompleted: {
        print("Completed")
    }, onDispose: {
        print("Disposed")
    })
   observable.subscribe(onNext: { element in
        print(element)
    }, onError: { error in
        print(error)
    }, onCompleted: {
        print("completed")
    }, onDisposed: {
        print("disposed")
    })
复制代码

4. Observable的销毁

经过上面的这些内容，咱们大概已经知道了，当一个Observable 序列被正常建立出来后它不会立刻就开始被激活从而发出 event，而是要等到它被订阅了才会激活它。而 Observable 序列激活以后要一直等到它发出了.error 或者 .completed的 event 后，它才被终结。

(1). 显式销毁--dispose() 方法

当一个订阅结束了再也不须要了，就能够调用 dispose() 方法把这个订阅给销毁掉，防止内存泄漏。订阅行为被 dispose 了，订阅将被取消，而且内部资源都会被释放，那么以后 Observable若是再发出 event，这个已经 dispose 的订阅就收不到消息了。一般状况下，你是不须要手动调用 dispose 方法的。

例子：

let observable = Observable.of("A", "B", "C")
let observableDispose = observable.subscribe { event in
    print(event)
}
observableDispose.dispose()
复制代码

(2). 隐式销毁--DisposeBag 方法

DisposeBag建立一个对象来管理多个订阅行为的销毁，能够把一个 DisposeBag 对象当作一个回收垃圾袋，把用过的订阅行为都放进去。而这个 DisposeBag就会在本身快要销毁的时候，对它里面的全部订阅行为都调用 dispose() 方法。

例子：

let disposeBag = DisposeBag()

let observable = Observable.of(1, 2, 3)
observable.subscribe { event in
    print(event)
}.disposed(by: disposeBag)
复制代码

总结

这篇内容简单的介绍了Observable序列的建立，订阅，和销毁。这里建立的序列都是最基本的序列，在RxSwift 里面Observable也存在一些特征序列，Driver，Single，ControlEvent...这些特征序列能够帮助咱们更准确的描述序列，让咱们可以用更加优雅的方式书写代码，关于这些特征序列后面我会再学习。关于Observable的销毁好像还有一种方法，后面研究到了会回来补充。如文中有错误还请各位指正！

最后感谢RxSwift中文文档.