RxJava2.x使用以及操作符详解

RxJava2.x是一个非常棒的流式编程,采用的观察者模式思想,事件的产生者产生事间之后发送给绑定的接受者,接受顺序与发送顺序一致.但是 是独立于RxJava1.x存在,本文讲解RxJava2.x的简单使用

RxJava2 封装主要变化

• Transformer的变化:RxJava1.X为rx.Observable.Transformer接口, 继承自Func1, Observable>, RxJava2.X为io.reactivex.ObservableTransformer,是一个独立的接口。
• Flowable则是FlowableTransformer，如果你使用Flowable，以下ObservableTransformer替换FlowableTransformer即可。



compile 'io.reactivex.rxjava2:rxjava:2.1.0'
  compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

简单使用:

//观察者模式,这里产生事件,事件产生后发送给接受者,但是一定要记得将事件的产生者和接收者捆绑在一起,否则会出现错误
Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        //这里调用的方法会在产生事件之后会发送给接收者,接收者对应方法会收到
        e.onNext("hahaha");
        e.onError(new Exception("wulala"));
        e.onComplete();
    }}).subscribe(new Observer() {
    //接受者,根据事件产生者产生的事件调用不同方法
    @Override
    public void onSubscribe(Disposable d) {
        Log.e(TAG, "onSubscribe: ");
    }

    @Override
    public void onNext(String value) {
        Log.e(TAG, "onNext: " + value);
    }

    @Override
    public void onError(Throwable e) {
        Log.e(TAG, "onError: ", e);
    }

    @Override
    public void onComplete() {
        Log.e(TAG, "onComplete: ");
    }
});

我们来用图解一下这其中发生了什么事:

Paste_Image.png

上游朝下游发送数据,经过subscribe使上下游产生关系,即达成订阅.

解析1:
ObservableEmitter,这是个啥东西?Emitter:顾名思义,即Rxjava的发射器,通过这个发射器,即可发送事件-----通过调用onNext,onError,onComplete方法发送不同事件.

注意:
虽然RxJava可以进行事件发送,但这并不意味着你可以随便发送,这其中需要遵循一些规则.


onNext:你可以发送无数个onNext,发送的每个onNext接受者都会接收到.


onError:当发送了onError事件之后,发送者onError之后的事件依旧会继续发送,但是接收者当接收到onError之后就会停止接收事件了.


onComplete:当发送了onComplete事件之后,发送者的onComplete之后的事件依旧会继续发送,但是接收者接收到onComplete之后就停止接收事件了.


onError事件和onComplete事件是互斥的,但是这并不代表你配置了多个onError和onComplete一定会崩溃,多个onComplete是可以正常运行的,但是只会接收到第一个,之后的就不会再接收到了,多个onError时,只会接收到第一个,第二个会直接造成程序崩溃.

解析2:
Disposable又是个啥东西,翻译之后百度告诉我这东西叫做一次性的,是用来控制发送者和接受者之间的纽带的,默认为false,表示发送者和接受者直接的通信阀门关闭,可以正常通信,在调用dispose()方法之后,阀门开启,会阻断发送者和接收者之间的通信,从而断开连接.

重载方法:

          subscribe();          //表示发送者随意发送数据,接受者什么都不管,什么都不接收.
          subscribe(Consumer onNext) {}     //只响应onNext()事件,其他的事件忽略.
          subscribe(Consumer onNext, Consumer onError) {}         //含义同上
          subscribe(Consumer onNext, Consumer onError, Action onComplete) {}         //含义同上
          subscribe(Consumer onNext, Consumer onError, Action onComplete, Consumer onSubscribe) {}     //含义同上

解析3:
默认情况下,发送者和接收者都运行在主线程,但是这显然是不符合实际需求的,我们在日常使用中,通常用的最多的就是在子线程进行各种耗时操作,然后发送到主线程进行,难道我们就没有办法继续用这个优秀的库了?想多了你,一个优秀的库如果连这都想不到,怎么能被称为优秀呢,RxJava中有线程调度器,通过线程调度器,我们可以很简单的实现这种效果,下面放代码.

Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        e.onNext("hahaha");
        e.onNext("hahaha");
        e.onNext("hahaha");
        Log.e(TAG,"运行在什么线程" + Thread.currentThread().getName());
        e.onComplete();
    }
}).subscribeOn(Schedulers.newThread())               //线程调度器,将发送者运行在子线程
  .observeOn(AndroidSchedulers.mainThread())          //接受者运行在主线程
  .subscribe(new Observer() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.e(TAG, "onSubscribe: ");
        Log.e(TAG,"接收在什么线程" + Thread.currentThread().getName());
    }

    @Override
    public void onNext(String value) {
        Log.e(TAG, "onNext: " + value);
    }

    @Override
    public void onError(Throwable e) {
        Log.e(TAG, "onError: ", e);
    }

    @Override
    public void onComplete() {
        Log.e(TAG, "onComplete: ");
    }
});

注意事项: 变换线程方法与1.x一致
subscribeOn(),只有在第一次调用的时候生效,之后不管调用多少次,只会以第一次为准.
observeOn(),可以被调用多次,每次调用都会更改线程.

RxJava线程池中的几个线程选项

      - Schedulers.io()      io操作的线程, 通常io操作,如文件读写.
      - Schedulers.computation()      计算线程,适合高计算,数据量高的操作.
      - Schedulers.newThread()      创建一个新线程,适合子线程操作.
      - AndroidSchedulers.mainThread()      Android的主线程,主线程

---

操作符之变换

Map:

首先是变换操作符- > Map,(此处引入以前看过的一篇文章的一句话:不知道Map已经统治世界了么?)那么在RxJava2中,Map究竟是个什么鬼.
map是RxJava中最简单的一个变换操作符,它的作用是将上游发送过来的事件都去应用一个函数,让每一个事件都按照该函数去变化,下游接收到事件时,就变成了变化过后的事件,多说无益,上代码.

Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> e) throws Exception {
            e.onNext(1);
            e.onNext(2);
            e.onNext(3);
        }
    }).map(new Function<Integer, String>() {
        @Override
        public String apply(Integer integer) throws Exception {
            return "我是变换过后的" + integer;
        }
    }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            Log.e("XYK",s);
        }
    });
}

通过运行结果可以看到,我们在上游发送的数据类型为Integer,到了下游接收到的数据为String类型,中间通过map对其进行了转换,是不是感觉很强大?通过map我们可以将上游数据转化为任意类型发送到下游,就是这么6~

圆形事件1,2,3,经过Map转化之后,变成了三角形事件1,2,3,但是有童鞋要问了,这有什么用呢,我们来举一个实际需求的例子,用Map来做一下:

读取一篇英文文章,将文章中的字符全部转换为大写.

我们先来用非RxJava2来做一下:

//模拟一篇文章
String article = "fkjdsalijfofldaJFOIEjfldanlJR2OnfldajilwafkndaIUPO32,LFKjlijuJFLMA";
        char[] chars = article.toCharArray();

        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < chars.length; i++) {
            Log.e(TAG,chars[i] + "");
            if(chars[i] >= 'a' && chars[i] <= 'z'){
                sb.append((chars[i] + "").toUpperCase());
            }else{
                sb.append(chars[i]);
            }
        }

        Log.e(TAG,sb.toString());

好像看上去没什么问题,但是这逼格显然不够高,程序员的精髓不就是要敲出一段逼格超高的代码么,我们试试用RxJava2:

//模拟一篇文章
        String article = "fkjdsalijfofldaJFOIEjfldanlJR2OnfldajilwafkndaIUPO32,LFKjlijuJFLMA";

        final char[] chars = article.toCharArray();
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                for (int i = 0; i < chars.length; i++) {
                    e.onNext(chars[i]);
                }
            }
            //delay  延时5秒发送
        }).delay(5, TimeUnit.SECONDS)
                //事件类型转换
                .map(new Function() {
                    @Override
                    public String apply(Character s) throws Exception {
                        if (s >= 'a' && s <= 'z') {
                            return s.toString().toUpperCase();
                        } else {
                            return s.toString();
                        }
                    }
                })
                //线程调度
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e(TAG, s);
                    }
                });

瞬间逼格就上去了,而且还做了线程调度等操作,是不是心头顿时感觉一串666飘过,这仅仅是最基础的转化操作符,接下来我们在看一个FlatMap:

FlatMap

FlatMap,上来就看到map,这个操作符和刚才的map有什么区别呢,flatmap可以将上游发送过来的数据,变换为多个数据,然后合并为一个事件发送到下游,这么说是不是有点难懂?恩,还是直接上代码:

Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) throws Exception {
            e.onNext(1);
            e.onNext(2);
            e.onNext(3);
        }
    }).flatMap(new Function>() {
        @Override
        public ObservableSource apply(Integer integer) throws Exception {
            List list = new ArrayList();
            for (int i = 0; i < 5; i++) {
                list.add("我是变换过的" + integer);
            }
            return Observable.fromIterable(list);
        }
    }).subscribe(new Consumer() {
        @Override
        public void accept(String s) throws Exception {
            Log.e("XYK", s);
        }
    });
}

通过运行结果可以看到,上游发送的数据在到达flatmap的时候,经过处理,将每个事件变成了5个,而后将5个合并为1个事件发送到下游,并且我们可以注意到,发送到下游的数据是无序的,那么这时候就要说了,我要接收的事件是有序的怎么办,这就是接下来要说的concatMap.

ConcatMap:

ConcatMap和FlatMap一样,只不过一个是有序,一个是无序而已,我们直接把上边的代码做一个更改:

Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) throws Exception {
            e.onNext(1);
            e.onNext(2);
            e.onNext(3);
        }
    }).concatMap(new Function>() {
        @Override
        public ObservableSource apply(Integer integer) throws Exception {
            List list = new ArrayList();
            for (int i = 0; i < 5; i++) {
                list.add("我是变换过的" + integer);
            }
            return Observable.fromIterable(list);
        }
    }).subscribe(new Consumer() {
        @Override
        public void accept(String s) throws Exception {
            Log.e("XYK", s);
        }
    });
}

过滤操作符

Filter

Filter,顾名思义,过滤器,可以过滤掉一部分不符合要求的事件,当上游给我们发送的数据超多,而下游需要的只是一些特定的数据,如果全部接收上游发送的数据,很容易造成OOM,为了避免OOM的出现,我们则需要对上游数据进行过滤,具体操作如下:

    Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                for (int i = 0; i < 10000; i++) {
                    e.onNext(i);
                }
            }
        }).observeOn(Schedulers.io())
                .subscribeOn(AndroidSchedulers.mainThread())
                .filter(new Predicate() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer % 7 == 0;
                    }
                }).subscribe(new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("XYK",integer + "");
            }
        });
    }

在上面的代码中,我们朝下游发送了10000个数据,而我只需要其中可以被7整除的数据,利用filter,将其他的数据过滤出去,留下需要的数据.

Filter方法使我们经常用到的一个过滤方法,基本已经可以满足大部分应用场所了,最常见的是过滤一些null对象,但是除此之外,还有一些其他的过滤方法,我们也来看下.

Sample

Sample,样品,其功能也是,sample会每隔一段时间对上游数据进行取样,发送到下游,但是这样会导致丢失了大量事件,比较适合特定场合,如对一组数中进行抽样,代码如下:

   Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                for (int i = 0; ; i++) {
                    e.onNext(i);
                }
            }
        }).sample(1,TimeUnit.SECONDS)
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e("XYK",integer + "");
                    }
                });
    }

在上边的代码中,使用sample之后,每隔1秒对上游数据采样一次,发送到下游,其他事件则被过滤.

take/takeList

take和takeList方法可以将上游事件中的前N项或者最后N项发送到下游,其他事件则进行过滤,代码如下:

 Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                for (int i = 0; ; i++) {
                    e.onNext(i);
                }
            }
        }).take(3)
        //.takeList(3)
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e("XYK",integer + "");
                    }
                });
    }

distinct

distinct方法,可以将重复对象去除重复对象,这里我们要用到一个方法,repeat(),产生重复事件,这里重复事件,再去除有些多余,只作为一个例子来展示.

Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                for (int i = 0;i < 50; i++) {
                    e.onNext(i);
                }
            }
        }).take(3)
                //生成重复事件
                .repeat(3)
                .distinct()
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e("XYK",integer + "");
                    }
                });




组合操作符

zip操作符:

Observable observable = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        e.onNext(1);
        e.onNext(2);
        e.onNext(3);
        e.onNext(4);
    }
});

Observable observable1 = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        e.onNext("这是");
        e.onNext("这个是");
        e.onNext("这个则是");
    }
});

Observable observable2 = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        e.onNext("个");
        e.onNext("只");
        e.onNext("条");
        e.onNext("张");
        e.onNext("本");
        e.onNext("副");
    }
});

Observable.zip(observable, observable1, observable2, new Function3() {
    @Override
    public String apply(Integer integer, String s, String s2) throws Exception {
        return s + integer + s2;
    }
}).subscribe(new Consumer() {
    @Override
    public void accept(String s) throws Exception {
        Log.e("XYK",s);
    }
});

运行结果:

Paste_Image.png

我们可以看到,3条上游中分别有4个事件,3个事件,6个事件,经过zip操作符操作之后为什么就只变成了3个事件了呢?我们来打下Log,看看其他事件去哪了.

添加Log之后的运行结果:

Paste_Image.png

根据运行结果可以看到,上游逐条发送到下游,下游在接收到最后一条上游发送过来的事件之后开始组合,而多余的数据也被发送了,但是并没有被进行组合,这样是不是就看明白了呢?但是这时候有问题了,组合完成之后,多余的数据依旧在发送,如果我们不停发呢?会产生什么后果?,我们来修改一下observable
的代码:

Observable observable = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        for (int i = 0; ; i++) {
            Log.e("XYK",i + "");
            e.onNext(i);
        }
    }
});

运行之后通过Monitors我们查看一下内存:(Sorry,这里没截下图来....可以自己试一下,不过想一下也知道,内存肯定会暴增嘛...)

在内存持续暴增的情况下,可能用不了多久就会OOM,这种情况下我们应该怎么办呢?

还记不记得上篇文章写了啥,过滤啊,我们把不需要的过滤掉不就好了

Observable observable = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        for (int i = 0; ; i++) {
            e.onNext(i);
        }
    }
}).filter(new Predicate() {
    @Override
    public boolean test(Integer integer) throws Exception {
        return integer % 100 == 0;
    }
});

当然,除此之外还有很多办法,可以根据实际情况来进行组合应用.

RxJava中的zip操作符作用是将多条上游发送的事件进行结合到一起,发送到下游,并且按照顺序来进行结合,如多条上游中发送的事件数量不一致,则以最少的那条中的事件为准,下游接收到的事件数量和其相等.

---

Rxjava的2.x与1.x的区别(官翻)

Nulls

RxJava 2x 不再支持 null 值，如果传入一个null会抛出 NullPointerException

Observable.just(null);

Single.just(null);

Observable.fromCallable(() -> null)
    .subscribe(System.out::println, Throwable::printStackTrace);

Observable.just(1).map(v -> null)
    .subscribe(System.out::println, Throwable::printStackTrace);

这意味着 Observable 不再发射任何值，而只是正常结束或者抛出异常。API 设计者可以定义 Observable