Rxjava2的简单使用与基本操作符

一 、关于Rxjava

异步：RxJava 在 GitHub 主页上的自我介绍是 "a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。
简洁：异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。RxJava 的优势也是简洁，但它的简洁的与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。

二 、基本概念

• Observable：发射源，在观察者模式中称为被观察者
• Observer：接收源，在观察者模式中成为观察者，可接收Observable、Subject发射的数据；
• Subscriber：“订阅者”，也是接收源，接收源在观察者模式中成为观察者。Subscriber实现了Observer接口，比Observer多了一个最重要的方法unsubscribe( )，用来取消订阅。
• subscribe：订阅，Observable和Observer通过subscribe()进行订阅
• Subscription：Observable调用subscribe( )方法返回的对象，同样有unsubscribe( )方法，可以用来取消订阅事件；
• Disposable：用于维系观察者、被观察者之间的联系。
• Event：事件。

1、基本调用

添加依赖

implementation 'io.reactivex.rxjava2:rxandroid:2.1.0'
implementation 'io.reactivex.rxjava2:rxjava:2.2.3'

创建被观察者

Observable normalObservable  = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter observableEmitter) throws Exception {
        observableEmitter.onNext("msg1");//通过onNext(),发射一个"msg1"的String
        observableEmitter.onNext("msg2");//通过onNext(),发射一个"msg2"的String
        observableEmitter.onComplete();//发射完成,这种方法需要手动调用onCompleted，才会回调Observer的onCompleted方法
    }
});

创建观察者

Observer mObserver = new Observer() {
    @Override
    public void onSubscribe(Disposable disposable) {
        //d.dispose();移除订阅关系
        //d.isDisposed()是否发生订阅关系
    }
    @Override
    public void onNext(String s) {
    }
    @Override
    public void onError(Throwable throwable) {
    }
    @Override
    public void onComplete() {
    }
}

调用subscribe实现订阅

normalObservable.subscribe(mObserver);

2、链式调用

当然我们也可以使用链式操作的写法
其中Consumer参数的方法表示下游只对我们关心onNext事件，或Throwable事件进行处理

Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter observableEmitter) throws Exception {
    }
}).subscribe(new Consumer() {
    @Override
    public void accept(String s) throws Exception {
    }
});

三、线程切换

我们在请求网络时必须是将其放在子线程执行，然后在安卓主线程中更新Ui

代码	含义
Schedulers.immediate	直接在当前线程运行。
Schedulers.newThread	启用新线程，并在线程执行操作。
Schedulers.io	内部是一个无数量上限的的线程池，可以重用空闲的线程，不要把计算工作放在io中。
Schedulers.computation	使用固定的线程池，大小为CPU核数。

• subscribeOn()：指定Observable线程

  如subscribeOn(Schedulers.io())在IO线程中请求网络

• observeOn()：指定Observer线程

  如observeOn(AndroidSchedulers.mainThread())在主线程中更新界面

Observable.create(new ObservableOnSubscribe() {
     @Override
     public void subscribe(ObservableEmitter e) throws Exception {
          //模拟登陆
        Call respCall = api.login(new User(username, password));
        Resp resp = respCall.execute().body();
        e.onNext(resp);
    }
})
//设置请求网络在io线程内执行、子线程中执行
.subscribeOn(Schedulers.io())
//设置更新ui在安卓主线程中执行
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer() {
    @Override
    public void accept(String s) throws Exception {
        //更新UI
    }
});

四、操作符

操作符变换符是RxJava中一个很重要的概念，也是其简洁很重要的原因，这里整理一些很常见的操作符。

》》1.使用just( )，创建一个Observable并自动为你调用onNext( )发射数据(最多可发送9个)

Observable  justObservable = Observable.just("just1","just2");//依次发送"just1"和"just2"

String []justs={"just1","just2"};
Observable.fromArray(justs)//传入数组，类似于just();

》》2.使用from( )，遍历集合，发送每个item

List list = new ArrayList<>();
list.add("from1");
list.add("from2");
list.add("from3");
Observable  fromObservable = Observable.from(list);  //遍历list 每次发送一个

注意：just()方法也可以传list，但是发送的是整个list对象，而from（）发送的是list的一个item
》》3.使用defer( )，有观察者订阅时才创建Observable，并且为每个观察者创建一个新的Observable

Observable  deferObservable = Observable.defer(new Func0>() {
    @Override
    //注意此处的call方法没有Subscriber参数
    public Observable call() {
        return Observable.just("deferObservable");
    }});

》》4.使用interval( )创建一个按固定时间间隔发射整数序列的Observable，可用作定时器

Observable  intervalObservable = Observable.interval(1, TimeUnit.SECONDS);//每隔一秒发送一次

》》5.使用range( )，创建一个发射特定整数序列的Observable，第一个参数为起始值，第二个为发送的个数，如果为0则不发送，负数则抛异常

Observable rangeObservable = Observable.range(10, 5);//将发送整数10，11，12，13，14

》》6.使用timer( )，创建一个Observable，它在一个给定的延迟后发射一个特殊的值，等同于Android中Handler的postDelay( )方法

Observable timeObservable = Observable.timer(3, TimeUnit.SECONDS);  //3秒后发射一个值

》》7.使用repeat( )，创建一个重复发射特定数据的Observable

Observable repeatObservable = Observable.just("repeatObservable").repeat(3);//重复发射3次

》》8.使用concat( )，连接两个被订阅者，订阅者将会按照a->b的顺序收到两个被订阅者所发射的消息。

final String[] aStrings = {"A1", "A2", "A3", "A4"};
final String[] bStrings = {"B1", "B2", "B3"};
final Observable aObservable = Observable.fromArray(aStrings);
final Observable bObservable = Observable.fromArray(bStrings);
Observable.concat(aObservable, bObservable);

输出A1", "A2", "A3", "A4"，"B1", "B2", "B3"

》》9.使用window( )，每隔n秒，发射这段时间内的数据，不是有数据就发射

Observable windowObservable=Observable.interval(1, TimeUnit.SECONDS).window(3, TimeUnit.SECONDS);//3秒后，发射前三秒所发射的数据

五、变换操作符

》》1. Map：最常用且最实用的操作符之一，将对象转换成另一个对象发射出去，应用范围非常广，如数据的转换，数据的预处理等。（如我们传入用户id需要查询用户信息，我们就可以使用map创建id返回user对象）
例一：数据类型转换，改变最终的接收的数据类型。假设传入本地图片路径，根据路径获取图片的Bitmap。

Observable.just(filePath).map(new Func1() {
    @Override
    public Bitmap call(String path) {
         return getBitmapByPath(path);
    }}).subscribe(new Action1() {
     @Override
    public void call(Bitmap bitmap) {
    //获取到bitmap，显示
}});

例二：对数据进行预处理，最后得到理想型数据。实际开发过程中，从后台接口获取到的数据也许不符合我们想要的，这时候可以在获取过程中对得到的数据进行预处理（结合Retrofit）。

Observable.just("12345678").map(new Func1() {
    @Override
    public String call(String s) {
        return s.substring(0,4);//只要前四位
    }})
.subscribe(new Action1() {
    @Override
    public void call(String s) {
        Log.i("mytag",s);
    }});

》》2. FlatMap：和Map很像但又有所区别，Map只是转换发射的数据类型，而FlatMap可以将原始Observable转换成另一个Observable。
例：
需要使用的school类，student类就不展示了，保存一些学生基本信息的字段

public class School {
    private String name;
    private List studentList；
    ......
    class studengt{
    ......
    }
}

List schoolList = new ArrayList<>();

首先假设要打印全国所有学校的名称，可以直接用Map：

Observable.from(schoolList).map(new Func1() {
    @Override
    public String call(School school) {
          return school.getName();
    }}).subscribe(new Action1() {
    @Override
    public void call(String schoolName) {
          Log.i(TAG,schoolName);
    }});

再进一步，打印学校所有学生的姓名，先使用map

Observable.from(schoolList).map(new Func1() {
    @Override
    public School.Student call(School school) {
        return school.getStudentList();//错误的地方
    }}).subscribe(new Action1() {
    @Override
    public void call(School.Student student) {
            Log.i(TAG,student.getName());
    }});

看似可行，但事实上，这是一段错误的代码，细心的人就会发现错误的地方 school.getStudentList()返回的时list集合
Map是一对一的关系，无法将单一的School对象转变成多个Student。FlatMap可以改变原始Observable变成另外一个Observable，如果我们能利用from()操作符把school.getStudentList()变成另外一个Observable，现在使用FlatMap实现

Observable.from(schoolList).flatMap(new Func1>() {
    @Override
    public Observable call(School school) {

        return Observable.from(school.getStudentList()); //关键，将学生列表以另外一个Observable发射出去

    }}).subscribe(new Action1() {

    @Override
    public void call(School.Student student) {
        Log.i(TAG,student.getName());
    }});

》》3. Buffer：缓存，可以设置缓存大小，缓存满后，以list的方式将数据发送出去；例：

Observable.just(1,2,3).buffer(2).subscribe(new Action1>() {
    @Override
    public void call(List list) {
        Log.i(TAG"size:"+list.size());
    }});

运行打印结果如下：

MainActivity.this: size:2
MainActivity.this: size:1

Buffer和Map经常一起使用，通常发生在从后台取完数据，对一个List中的数据进行预处理后，再用Buffer缓存后一起发送，保证最后数据接收还是一个List，如：

List schoolList = new ArrayList<>();
Observable.from(schoolList).map(new Func1() {
    @Override
    public School call(School school) {
        school.setName("NB大学");  //将所有学校改名
        return school;
    }}).buffer(schoolList.size())  //缓存起来，最后一起发送
.subscribe(new Action1>() {
    @Override
    public void call(List schools) {   
}});

六 、过滤操作符

》》1.Take：发射前n项数据，还是用上面的例子，假设不要改所有学校的名称了，就改前四个学校的名称：

Observable.from(schoolList).take(4).map(new Func1() {
    @Override
    public School call(School school) {
        school.setName("NB大学");
        return school;
    }}).buffer(4).subscribe(new Action1>() {
    @Override
    public void call(List schools) {
    }});

》》2.Distinct:去掉重复的项，比较好理解

Observable.just(1, 2, 1, 1, 2, 3)
        .distinct()
        .subscribe(new Action1() {
            @Override
            public void call(Integer item) {
                System.out.println("Next: " + item);
            }
        });

输出

Next: 1
Next: 2
Next: 3

》》3.Filter：过滤，通过谓词判断的项才会被发射，例如，发射小于4的数据

Observable.just(1, 2, 3, 4, 5)
        .filter(new Func1() {
            @Override
            public Boolean call(Integer item) {
                return( item < 4 );
            }
        }).subscribe(new Action1() {
          @Override
          public void call(Integer item) {
                System.out.println("Next: " + item);
      }});

输出：

Next: 1
Next: 2
Next: 3

》》window：

关于其他操作符或详情查看官网：RxJava使用以及操作符

六、注意事项

1、RxBinding的使用

RxBinding是在RxJava的基础上封装的一些操作，可以处理常用的一些UI的响应问题，这里具体实现就不分析了，只整理一些常用的方法作为记录。

添加依赖：

implementation 'com.jakewharton.rxbinding3:rxbinding:3.0.0-alpha1'

1.1、常用方法：

1.1.1、RxView

• RxView.clicks().throttleFirst(long windowDuration, TimeUnit unit)指定的时间windowDuration内，点击clicks事件只响应一次
• RxView.longClicks()长按监听
• RxView.draws()绘制监听
• RxView.drags()拖拽监听
• RxView.scrollChangeEvents()滑动触发
• .....

例：按钮防抖，指定时间内事件只响应1次

//2秒内，按钮点击事件只响应1次
RxView.clicks(btn)
    .throttleFirst(2, TimeUnit.SECONDS)
    .subscribe(new Consumer