Android框架源码分析——RxJava 操作符使用介绍

RxJava因为功能强大和代码结构简单深受程序员的亲睐，之前的学习也使用过可是有的操作符还是会遗忘，为了自己的总结和复习，接下来的几篇会针对RxJava的一些操作符的使用，进行简单的归纳：

1、基本用法：

 

Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {

            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                
            }
        });

 

相信以上代码大家都知道如何使用，这也是RxJava的最基本使用，大致步骤：

 

• 创建一个被观察者
• 创建一个观察者，这里面使用了Consume 一个简易的observe，可以理解为一个消费者
• 订阅 subcribe()

上述所描述的三个过程，后两个基本一直且是必须的，那我们就开看看如何创建一个观察者，RxJava提供了很多操作符用于满足不同需求的创建：

 

•  发送多个数据：

1. creat() 
2. just()  
3. fromArray()  
4. fromIterable（）

create的创建上述已经说过了，来看看just的创建，

    just（） ：会依次发送数据，但数据最多为10条

Observable.just(1,2,3,4,5)
               .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {

            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
            }
        });//输出的结果是：1,2,3,4,5

 fromArray（） 

 与just()相对应的方法，传入一个数组一次输出数据，数量可以超过10条，这里省略了后面的订阅和观察者

Integer integer[] = {1,2,3};
 Observable.fromArray(integer)

fromIterable（）

传入一个集合，使用方法与fromArray一样

• 发送空数据：

 

 

1. never() 不发送
2. empty : 发送空数据，回调onComplete
3. error()：回调onError

上述使用方法相同以empty为例：

Observable.empty().subscribe(new Observer<Object>() {...}

• 延时发送的

1. defer() 
2. timer() 
3. interval() 
4. interRange() 
5. range()

创建操作符中我们主要讲讲延时操作符：

1、defer():

在观察者订阅时在会创建实例，保证数据最新,也就是说只有当你订阅的时候，才会初始化被观察这的数据，确保发送的是最新数据：

Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<Integer>>() {
            @Override
            public ObservableSource<Integer> call() throws Exception {
                return Observable.just(i);
            }
        });
        Observable<Integer> observable1 = Observable.just(i);
        i = 20;
        observable.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("defer ==", integer + "");
            }
        });
        observable1.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("just ==", integer + "");
            }
        });

上述代码创建了两个针对与i的被观察着，第一个使用defer，第二个时普通创建，之后将i的值改为20，然后订阅两个观察者分别输出说的到的值，按之前的逻辑defer会获取最新的值，所以defer== 20，而just = 10，看下实际运行结果：

运行结果与分析的一致，

2、timer()

 延迟发送  第一个参数：时间 第二个:时间单位，倒计时结束后，发送一个0，数据类型为Long

 Observable.timer(2,TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
             @Override
             public void accept(Long aLong) throws Exception {
                 
             }
         });Observable.timer(2,TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
             @Override
             public void accept(Long aLong) throws Exception {
                 
             }
         });

3、interval()

    根据一定的周期不停的发送数据，三个参数：第一个数的延迟时间、每次的周期、时间单位

Observable.interval(3,2, TimeUnit.SECONDS)

4、interRange() :

 按照一定的时间发送固定数量的数据，参数：起始值，数量，第一个数延迟时间，周期，时间单位，输出类型为Long

Observable.intervalRange(15, 3, 3, 1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e("Long ==", aLong + "");
                    }
                });//输出结果：15,16,17

5、range(）

从起始值开始发送一定数量的数据 从参数： 起始值，数量  无延迟立即发送，输出为integter

Observable.range(15, 3)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer aLong) throws Exception {
                        Log.e("Long ==", aLong + "");
                    }
                });

应用实例：网络轮循

Observable.interval(3,2, TimeUnit.SECONDS)
                .doOnNext(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e("RxJava","第"+ aLong +"次");

                        RetrofitCreateHelper.createApi(Api.class,Api.BASE_URL)
                                .getCall().compose(RxHelper.<Translation>rxSchedulerHelper())
                                .subscribe(new Consumer<Translation>() {
                                    @Override
                                    public void accept(Translation translation) throws Exception {
                                        translation.show();
                                    }
                                });
                    }
                }).subscribe();

本实例使用的时Retrofit 和RxJava结合使用，代码会在后续文章中上传，此处只是展示使用，输出结果：