RxJava2.0笔记记录（一）

一 基本使用

Observable创建

Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {     @Override     public void subscribe(ObservableEmitter<Integer> e) throws Exception {         //ObservableEmitter 发射器的意思，用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。     } });

Observer创建

Observer<Integer> observer = new Observer<Integer>(){  @Override  public void onSubscribe(Disposable d) {  //开关的意思，当调用它的dispose()方法时，它就会切断事件的接受，导致观察者接受不到事件。这个可以用作当页面销毁时，取消网络请求。  }  @Override  public void onNext(Integer integer) {       }  @Override  public void onError(Throwable e) {  }  @Override  public void onComplete() {  }};

订阅被观察者与观察者

observable.subscribe(observer);

一个observable可能没有观察者订阅，也可以多个观察者订阅，当观察者和被观察者建立联系后，被观察者可以通过onNext发送事件，也可以发送onComplete标志事件完成，被观察者发送onComplete之后，可以继续发送，而观察者接受到onComplete之后，就不会继续接收事件。

onComplete和onError必须唯一并且互斥。

subscribe有多个方法的重载，带有一个参数的Consumer方法，表示下游可以只关心onNext方法。

---

二 线程控制

默认情况下，观察者和被观察者工作在主线程。通常我们的需求是在子线程做耗时操作，然后回到主线程中来操作UI。此时我们可以用线程控制来达到这一目的。

observable     .subscribeOn(Schedulers.io())  //subscribeOn被观察者工作的线程     .observeOn(AndroidSchedulers.mainThread()) //observeOn 观察者工作的线程     .subscribe(observer);

RxJava内置线程选项：
1.Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作，内部用线程池维护。
2.Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
3.Schedulers.newThread() 代表一个常规的新线程
4.AndroidSchedulers.mainThread() 代表Android的主线程

注意：
1.多次指定被观察者的线程只有第一次指定的有效, 也就是说多次调用subscribeOn() 只有第一次的有效, 其余的会被忽略.
2.多次指定观察者的线程是可以的, 也就是说每调用一次observeOn() , 下游的线程就会切换一次.

---

三 操作符

< 1 >.map

map是RxJava中最简单的一个变换操作符, 它的作用就是对observable发送的每一个事件应用一个函数, 使得每一个事件都按照指定的函数去变化.

eg:

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 "this is " + integer;    }}).subscribeOn(Schedulers.io())  .observeOn(AndroidSchedulers.mainThread())  .subscribe(new Consumer<String>() {      @Override      public void accept(String s) throws Exception {          System.out.println(s);      }  });

通过Map可以将Observable发送的事件转换为任意的类型。

< 2 >. flatmap

FlatMap将一个发送事件的Observable变换为多个发送事件的Observables，然后将它们发射的事件合并后放进一个单独的Observable里.

eg:

Observable.create(new ObservableOnSubscribe<Integer>() {        @Override        public void subscribe(ObservableEmitter<Integer> e) throws Exception {            e.onNext(1);            e.onNext(2);            e.onNext(3);        }    }).flatMap(new Function<Integer, ObservableSource<String>>() {        @Override        public ObservableSource<String> apply(Integer integer) throws Exception {            List<String> list = new ArrayList<>();            for(int i = 0; i<3; i++){                list.add("I am value " + integer);            }            return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);        }    }).subscribe(new Consumer<String>() {        @Override        public void accept(String s) throws Exception {            System.out.println(s);        }    });

注意：flatmap并不能保证事件的顺序，如果需要保证事件的顺序可以使用concatmap，用法和flatmap一样。

< 3 >.zip

zip通过一个函数将多个Observable发送的事件结合到一起，然后发送这些组合到一起的事件. 它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个Observable一样多的数据。

Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {    @Override    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {    }}).subscribeOn(Schedulers.io());Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {    @Override    public void subscribe(ObservableEmitter<String> emitter) throws Exception {    }}).subscribeOn(Schedulers.io());Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {    @Override    public String apply(Integer integer, String s) throws Exception {        return "";    }}).subscribe(new Consumer<String>() {    @Override    public void accept(String s) throws Exception {    }});

---

四. 背压 Backpressure

< 1 >.原理引入

当observable和observer工作在不同线程时，它们之间不能直接通信，当observable发送一个事件时，是放在一个容器（具体就是一个队列）里面的，当容器里面有事件时，才会向observer发送事件。而当observable发送事件太快，observer取事件太慢，容器就会一直放事件，最后会因为容器事件越来越多，最后导致容器OOM了。

这种observable产生事件的速度很快，而observer处理很慢，事件会堆积起来，最终挤爆你的内存，导致程序崩溃（MissingBackpressureException异常）。

至此，就可以引出背压(Backpressure)的概念：背压是指在异步场景中，被观察者发送事件速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略。

关于背压，可以看这里

< 2 >.解决方案

a. 使用filter过滤掉不需要的数据
b. 使用sample每隔一段时间从observable取出事件，发送给下游。
c. 延时降低observable发送事件的速度。
d.使用flowable解决。

大致就是从数量和速度上解决。

---

五.Flowable

这里把被观察者指定为flowable，观察者指定为subscriber。

eg:

Flowable<Integer> flowable = Flowable.create(new FlowableOnSubscribe<Integer>() {        @Override        public void subscribe(FlowableEmitter<Integer> e) throws Exception {                }        //流速不均匀直接抛异常    }, BackpressureStrategy.ERROR);    Subscriber<Integer> subscriber = new Subscriber<Integer>() {        @Override        public void onSubscribe(Subscription s) {                 }        @Override        public void onNext(Integer integer) {        }        @Override        public void onError(Throwable t) {        }        @Override        public void onComplete() {        }    };    flowable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(subscriber);

和observable不同的是，这里增加了一个参数，用来处理上下游流速不均衡的时候应该怎么处理的办法，在例子中直接抛出了一个BackpressureStrategy.ERROR异常，也就是MissingBackpressureException异常。同时观察者中不是再使用Disposable，而是使用Subscription，与Disposable不同的是，这种采用的是响应式拉取，当在onSubscribe方法中调用了request方法时，observable会根据request的事件数量发相应数量的事件。observable不会再一直发事件。如果不调用request方法，在同一线程，就会抛MissingBackpressureException异常，在不同线程，observable就会先把事件放到一个容器，大小为128。当observer调用request才会发送事件。

---

参考

1.Season_zlc的“水管”系列
2.系列文章