把它当做陌生人再一次去认识

环境集成

首先废话不多说，先把Rxjava集成到我们项目中来。

rxjava1和rxjava2

当你在app项目的module setting中添加dependency的时候，会出现让你选择使用rx1还是2的窘境，那1和2有什么不一样呢
在此，作为并没有对rxjava有所了解的陌生者，我先告诉你，2是1的improvement，所以我们集成的时候使用 2即可。

    compile 'io.reactivex.rxjava2:rxjava:2.0.6'

OK,环境配置算是完成了。

先随便撸一段代码看看

首先你需要普及一段知识，这个所谓的rxjava是基于观察者模式，或者子通俗一点，你总归听说这玩意儿使用来做响应式编程的吧。
那么我接下去，所要写的第一段代码从Observer和Subscriber开始应该可以理解了吧

• Observer

在MainActivity中直接开了一个private的方法，写上Observer，选择reactx的包，发现需要输入一个泛型，先什么都不管，我们输入一个String，然后new之后自动跳出来一大坨如下：

Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                
            }

            @Override
            public void onNext(String s) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };

我们点到Observer的源码看，发现这个“观察者”是个接口，总共就上述的四个方法，具体用来干什么我们先放一放。

• Subscriber

国内的rxjava鱼龙混杂，绝大部分是基于rxjava1去进行讲解的，你就会发现他们会跟你这么讲

Subscriber和Observer是一样的接口，唯一不同的是，它里面有自己的两个独有的方法，onStart，unSubscribe方法

结果你在听信了我的话导入了rxjava2之后发现结果是这样的：

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {

            }

            @Override
            public void onNext(String s) {

            }

            @Override
            public void onError(Throwable t) {

            }

            @Override
            public void onComplete() {

            }
        };

没错，跟Observer一模一样，你疑惑的点到源码里面看，发现也是一模一样。完全一样的接口，完全一样的四个接口方法。

这里我要告诉你，在rxjava1中确实是Subscriber这个类存在（rxjava1主包名为rx，rxjava2主包名为io.reactivex），存在于rx包下，但是我们在io.reactivex包下却没有发现Subscriber，我们使用的Subscriber实际上来自于org.reactivestreams.Subscriber,rxjava2已经将Subscriber这个抽象类移除了，代替它的是具体的Subscriber,在io.reactivex.subscribers包下的比如DefaultSubscriber, ResourceSubscriber 和 DisposableSubscriber等抽象类。

• Observable

当我们在前面想要创建Observer的时候，IDE会跳出来Observable，字面翻译的意思是观察者的东西，猜测应该是用来传递的对象，我们来看一下，进到源码中我们发现，这个Observable是个抽象类，那照理来说应该是被继承而非直接创建实例才对。

这种时候我们一般怎么做，大家知道我们通常不去使用抽象类new对象，那么如果这个抽象类有其他的一些构造方法，肯定就是在static方法中，结果我们发现他有个create方法，上面的注释下的很明白，将相应与回调联系起来的一个API，我们不妨用用看

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                
            }
        });

我们可以看到create方法对传参的描述

the emitter that is called when an Observer subscribes to the returned

翻译成人话的意思是当观察者订阅了之后所回调的一个发射器（这里的发射器我们就把他理解成一个相当迅速的回调），我们再来看一下这个ObservableOnSubscribe接口，按照之前的理解，他就是观察者做了订阅动作之后返回的一个回调。
只有一个接口方法：

/**
     * Called for each Observer that subscribes.
     * @param e the safe emitter instance, never null
     * @throws Exception on error
     */
    void subscribe(ObservableEmitter<T> e) throws Exception;

我们看到每一个观察者订阅了之后都会触发这个subscribe方法

继续看这个ObservableEmitter，观察者发射器，继承Emitter，就是发射器，一看是个接口，接口里面有三个方法，onNext，onError, onComplete。是不是有点印象，没错跟之前的Observer和Subscriber接口的方法一模一样。

那好，根据之前的注释和接口里的方法，我们可以笃定，这几个类之间一定是有关系的，主要是怎么把他们联系起来。

• 把Observable，Observer，Subscriber联系起来

  由于Observer和Subscriber都是接口，方法又都只有四个且都是onXXX这种非主动性方法，那我们只有从Observable入手，我们开始在Observable方法中全局搜索Observer类，看哪个方法的传参类型是Observer，发现：

    public final void subscribe(Observer<? super T> observer) 

但是没有发现Subscriber。不管了，我们先用用看，我们在刚才的Observer和Observable的方法中打上log。

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("hello on next");
                Log.e("observable", "subscribe    ");
            }
        });

结果发现，subscribe方法内调什么，Observer就回调什么。

OK，这两者的关系已经很明显了。那么到底Subscriber是和谁联系起来的呢

• Flowable横空出世

  想来想去不知道Subscriber被谁用，你如果之前不知道Rxjava，再或者你即使用过Rxjava1，到了这儿你也不知道怎么去用Subscriber。

  无奈，点开了github的Rxjava2目录，你会在包的根目录中发现如下四个跟Observable很像的类，分别是Completable，Flowable，Maybe，Single。

  
  
  Observable.png
  
  
  Completable.png
  
  
  Flowable.png
  
  
  Maybe.png
  
  
  Single.png

  我们去一个一个的看这几个类的subscribe方法，我们会发现Completable对应的传参是onComplete的action，Single对应的是SingleObserver，Maybe对应的是MaybeObserver，Flowable对应的是Subscriber。终于找到了！！！赶紧拿来用一用。

Flowable<String> flowable = Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {
                e.onNext("hello flowable1");
            }
        }, BackpressureStrategy.DROP);
flowable.subscribe(subscriber);

效仿Observable的构造方法，我们同样用create去创建Flowable对象，new了之后IDE帮我们自动生成，结果发现传参有两个，我们点到create方法中看到还需要传一个BackpressureStrategy。。。

这是个啥

点开BackpressureStrategy，发现是个enum，先不管那么多了随便传一个进去看看，我就用了BackpressureStrategy.DROP。

发现，发现，什么都没出来！！

不过，我不管了，我把这个关系给找出来已经很累了，先歇会儿，喝杯茶~~~

• 关于onNext，onError，onComplete要说的一些话

  • 你可以在Subscribe方法（我们可以称之为上游）中发送无限个onNext，在onSubScribe方法中（我们称之为下游）就可以接受无限个onNext。
  • 但是倘若你在上游发送了onComplete，或者是onError之后，下游接受到了，上游之后的事件下游就不再接受了。（这个想想就可以理解）
  • onComplete和onError是互相排斥的，你不能在上游发了onComplete之后又发onError，当然你发了下游也接受不到，hohoho~
  • 你不能发送多个onComplete和多个onError，虽然后续都不会再接受。但是要注意哦。发送多个onComplete系统不会崩溃，发送多个onError，你试试~~

• Disposable，Subscription怎么用呢

  • Disposable
    我们在上面讲Observer的时候并没有涉及到Disposable的用法，我们点到这个类里看一下

/**

• Represents a disposable resource.
  /
  public interface Disposable {
  /*

  • Dispose the resource, the operation should be idempotent.
    */
    void dispose();

  /**

  • Returns true if this resource has been disposed.
  • @return true if this resource has been disposed
    */
    boolean isDisposed();
    }

   是个接口，只有两个方法，Disposable字面意思是一次性东西。dispose我们看到注释是处理这个资源，操作等幂。

   这个`idempotent`是什么鬼，这个词语之后可能会在注释中一直看见，表示这个方法你使用多次跟使用一次的效果是一样的。

   其实很好理解，dispose就是销毁这个资源，如果放在响应式编程中，我猜，算了，不猜了，意思再明显不过了，就是断开观察者和被观察者之间的关系。也就是说接下去下游不会再收到上游的任何通知。

   使用过程中我们需要注意什么呢？

   如果我们的activity已经退出了，如果上游和下游还连着，下游如果做UI改动，会导致程序崩溃。
    我们需要在onSubscribe中将Disposable进行缓存，然后在activity退出的时候，调用它的Disposable.dispose方法断开连接。如果有多个Disposable，那我们可以使用官方提供的容器类`CompositeDisposable`，这个类提供了add和clear方法，可以对Disposable群体进行管理。
   * Subscription
    记得前面讲Flowable的时候，什么东西都没有出来么，现在看看好像只能从这个家伙入手了，让我们一起点开它的源码看个究竟。
   
     一看，是个接口，只有两个方法，一个`request`,一个`cancel`。我又要猜了，一个是请求，一个是断开。但是request后面还会跟着一个参数，这什么意思呢？

    来看下它的parm解释，大体翻译成老百姓看的懂得意思就是接受上游的事件数，你上游可以发很多事件，但是我这里就接受那么多个，接下去的我不接受。
 
    我们在Subscriber的onSubscribe方法中添加  `subscription.request(2)`这行代码。（随便写了个2），然后程序一跑，发现onNext打印出来了。

     在经过各种组合打印之后，最终得出的结论是，request传入的个数是接受的onNext的个数，onComplete和onError不算在接受事件的个数之中。

* #####subscribe方法的重载
   无论是Observable或者是flowable，他们的subscrib方法都有相同的重载

public final Disposable subscribe() {}
public final Disposable subscribe(Consumer<? super T> onNext) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
public final void subscribe(Observer/Subscriber<? super T> observer/subscriber) {}

   几个重载的意思分别是，什么都不监听，就是只管上游发事件，没有监听的下游；只监听onNext方法，其他不监听；只监听onNext和onError；。。。

-------

##电梯
  [抱着陌生的态度再看Rxjava（二）](//www.greatytc.com/p/f435dc51221f)
    [抱着陌生的态度再看Rxjava（三）](//www.greatytc.com/p/96df60fd35c6)
    [抱着陌生的态度再看Rxjava（四）](//www.greatytc.com/p/de8af3fadede)