RXJava学习1

概念

基于观察者模式，事件流的异步操作程序库。主要包含Observable, Observer, Event, subscribe

被观察者(Observable): 发送事件，传递给观察者，观察者响应事件做出动作
观察者(Observer): 接收事件
事件(Event): 发出的事件，事件流形式
订阅(Subscribe)：连接观察者和被观察者

创建被观察者

主要有以下方法：

Creat

//1. 完整创建1个被观察者对象（Observable）
Observable<T> create(ObservableOnSubscribe<T> source)

val observable = Observable.create(object : ObservableOnSubscribe<Int> {
    override fun subscribe(emitter: ObservableEmitter<Int>) {
        //需要发送的事件
        emitter.onNext(1)
        emitter.onNext(2)
        emitter.onError(Throwable("Error"))
        emitter.onComplete()
    }
})

Just

//2.快速创建观察者对象 最多支持10个事件 发送事件的特点：直接发送 传入的事件
Observable<T> just(T item1, T item2, T item3, T item4,...)
val observable = Observable.just(1,2,3,4)

FromArray

//3. 发送事件的特点：直接发送传入的数组数据 会将数组中的数据转换为Observable对象
public static <T> Observable<T> fromArray(T... items)
// 设置需要传入的数组
Integer[] items = { 0, 1, 2, 3, 4 };
// 创建被观察者对象（Observable）时传入数组
// 在创建后就会将该数组转换成Observable & 发送该对象中的所有数据, 挨个发送。可以大于10个
Observable.fromArray(items)

fromIterable

//4. 可迭代对象 列表 集合
public static <T> Observable<T> fromIterable(Iterable<? extends T> source)
val array = arrayListOf<Int>(1,2,3,4,5,7,8,9,10,11)
Observable.fromIterable(array)

timer

//5. 延迟指定时间后，发送1个数值0（Long类型）
public static Observable<Long> timer(long delay, TimeUnit unit)
public static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler)
Observable.timer(10, TimeUnit.SECONDS)

interval

//6. 发送事件的特点：每隔指定时间就发送事件, 发送的事件序列 = 从0开始、无限递增1的的整数序列
public static Observable<Long> interval(long initialDelay/*初始时延*/, long period/*时间间隔*/, TimeUnit unit)
public static Observable<Long> interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
public static Observable<Long> interval(long period, TimeUnit unit)

Range

//7. 发送事件的特点：每隔指定时间 就发送 事件，可指定发送的数据的数量。发送的事件序列 = 从0开始、无递增1的的整数序列
public static Observable<Long> intervalRange(long start/*事件起点*/, long count/*数量*/, long initialDelay, long period, TimeUnit unit)
Observable.intervalRange(3,10,2,3,TimeUnit.SECOND)//第一个事件3开始10个事件，开始延迟2s, 每隔3s一次
//8.
public static Observable<Integer> range(final int start, final int count)

other

// 下列方法一般用于测试使用
<-- empty()  -->
// 该方法创建的被观察者对象发送事件的特点：仅发送Complete事件，直接通知完成
val observable1=Observable.empty(); 
// 即观察者接收后会直接调用onCompleted（）

<-- error()  -->
// 该方法创建的被观察者对象发送事件的特点：仅发送Error事件，直接通知异常
// 可自定义异常
val observable2=Observable.error(new RuntimeException())
// 即观察者接收后会直接调用onError（）

<-- never()  -->
// 该方法创建的被观察者对象发送事件的特点：不发送任何事件
val observable3=Observable.never();
// 即观察者接收后什么都不调用

创建观察者

实现Observer接口

        val observer = object : Observer<Int> {
            override fun onSubscribe(d: Disposable?) {
                //连接订阅时调用
            }
            override fun onNext(t: Int?) {
                //接收到事件时调用
            }
            override fun onError(e: Throwable?) {
                //发生错误调用
            }
            override fun onComplete() {
                //事件发生完成，没事件在发生
            }
        }

订阅事件，连接观察者和被观察者

observable.subscribe(observer)
//subscribe多个重载

public final Disposable subscribe() {}
// 表示观察者不对被观察者发送的事件作出任何响应（但被观察者还是可以继续发送事件）

public final Disposable subscribe(Consumer<? super T> onNext) {}
// 表示观察者只对被观察者发送的Next事件作出响应
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
// 表示观察者只对被观察者发送的Next事件 & Error事件作出响应

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
// 表示观察者只对被观察者发送的Next事件、Error事件 & Complete事件作出响应

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
// 表示观察者只对被观察者发送的Next事件、Error事件 、Complete事件 & onSubscribe事件作出响应

public final void subscribe(Observer<? super T> observer) {}
// 表示观察者对被观察者发送的任何事件都作出响应

切断连接

//mDisposable?.dispose()
//onComplete()，onError()方法后也会切断连接

Observable.just(1, 2, "hello").subscribe(object :Observer<Any>{
           var mDisposable: Disposable? = null
           override fun onSubscribe(d: Disposable?) {
               //订阅
               mDisposable = d
           }

           override fun onNext(t: Any?) {
               if (t == 2) {
                   mDisposable?.dispose()//解除订阅关系，不会发送任何方法
               }
           }

           override fun onError(e: Throwable?) {
               TODO("Not yet implemented")
           }

           override fun onComplete() {
               TODO("Not yet implemented")
           }


       })

使用subscribe方法返回的Disposable 对象

 val disposable = Observable.just(1, 2, "hello").subscribe()
 if (!disposable.isDisposed) {
     disposable.dispose()
 }

流式调用

        Observable.create(object : ObservableOnSubscribe<String> {
            override fun subscribe(e: ObservableEmitter<String>?) {
                // emit event
            }
        }).subscribe(object : Observer<String> {
            override fun onSubscribe(d: Disposable?) {
                TODO("Not yet implemented")
            }

            override fun onNext(t: String?) {
                TODO("Not yet implemented")
            }

            override fun onError(e: Throwable?) {
                TODO("Not yet implemented")
            }

            override fun onComplete() {
                TODO("Not yet implemented")
            }

        })