RxJava啊，知道，但是没用过啊。

导语

神父，我忏悔，作为一个Android开发，对于RxJava还是一无所知。最初知道他的名字大概是前年？群里一大神用RxJava搞事情，当初并不知道这有什么卵用。再一次知道是在去年，书签里保存了很多关于它的文章，但是一直都没看过 = = 以上。

呐，开始，先别jier跟我整些有的没的，我就是想先用用感受下。

• 添加依赖，顺手加上butterknife

    compile 'io.reactivex.rxjava2:rxjava:2.1.1'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
    compile 'com.jakewharton:butterknife:8.7.0'
    annotationProcessor 'com.jakewharton:butterknife-compiler:8.7.0'

• 强撸代码

 @OnClick(R.id.btn)
    public void onClick() {
        //创建被观察者
        Observable observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("第一发");
                e.onNext("第二发");
                e.onNext("第三发");
                e.onComplete();
            }
        });
        //创建一个观察者
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.e("rxjava","Disposable是个什么玩意");
            }

            @Override
            public void onNext(@NonNull String s) {
                Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {
                Log.e("rxjava","onComplete");
            }
        };
        //连接 被观察者看上去很主动的请求观察者连接他，很棒棒？
        observable.subscribe(observer);
    }

  OKOK，运行下，没毛病。先执行onSubscribe，然后next依次执行，最后执行onComplete。可以脑补了，onSubscribe开始工作的时候调用，onNext干活，onError罢工，onComplete工作完成。试一下onError好了。

 @OnClick(R.id.btn)
    public void onClick() {
        //创建被观察者
        Observable observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("第一发");
                e.onNext("第二发");
                e.onNext(null);
                e.onNext("第三发");
                e.onComplete();
            }
        });
        //创建一个观察者
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.e("rxjava","Disposable是个什么玩意");
            }

            @Override
            public void onNext(@NonNull String s) {
                Toast.makeText(MainActivity.this, s.toString(), Toast.LENGTH_SHORT).show();
            }

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

            @Override
            public void onComplete() {
                Log.e("rxjava","onComplete");
            }
        };
        //连接 被观察者看上去很主动的请求观察者连接他，很棒棒？
        observable.subscribe(observer);
    }

改了下代码
  执行顺序分别是onSubscribe--toast1-toast2-onError没了，onComplete在工作成果完成后调用。可以这很科学。
  排下版弄成传说中的链式结构。

@OnClick(R.id.btn)
    public void onClick() {
        
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("第一发");
                e.onNext("第二发");
                e.onNext(null);
                e.onNext("第三发");
                e.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.e("rxjava", "Disposable是个什么玩意");
            }

            @Override
            public void onNext(@NonNull String s) {
                Toast.makeText(MainActivity.this, s.toString(), Toast.LENGTH_SHORT).show();
            }

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

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

    }

  没毛病，用着还算阔以，想想在什么情况下会用到呢，目前只想到排队送死流会用到了。看上去每次都要传递相同类型的参数过去？还是在onNext里面强转？那岂不是变墨迹了？这个坑先放着，基础体位这就用完了？好空虚，好寂寞。

• ObservableEmitter biubiubiu的发射器
    可以发射三种导弹，No.1:onNext,No.2:onComplete,No.3:onError。恩，继续
  我擦，原来三种导弹是可以随便发的，没啥顺序要求，我还以为必须按顺序来呢，这很灵活啊。上游可以随便biubiubiu,无论如何都会把事件执行完，下游遇到成功或者失败的指令就会停止不在听上游瞎jierBB。开发者自己控制成功失败的执行，而且也可以不发射这两种导弹。当然成功和失败是互斥的，值得注意的是多次发射成功没啥事，但是收到两次失败的话，程序会瞬间爆炸崩溃。
  -Disposable 功能一：导弹拦截装置

  @OnClick(R.id.btn)
    public void onClick() {

        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("第一发");
                e.onNext("第二发");
                e.onNext("第三发");
                e.onNext("第四发");
                e.onComplete();
            }
        }).subscribe(new Observer<String>() {
            private Disposable disposable;
            private int i;

            @Override
            public void onSubscribe(@NonNull Disposable d) {
                disposable = d;
            }

            @Override
            public void onNext(@NonNull String s) {
                Toast.makeText(MainActivity.this, s.toString(), Toast.LENGTH_SHORT).show();
                i++;
                if (i == 2) {
                    disposable.dispose();
                }
            }

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

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

    }

  运行下，大概的意思是，上游一直在那里BB，然后：发你妹啊，看我直接把你掐死。当然上游依旧我行我素，只不过是下游不叼他了。
PS：原来是可以这么记数的，制杖了。

• subscribe() 厚道的重载方法，拷贝忍者汪汪卡觐见

    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<? super T> observer) {}

不带参数：你上游可劲BB，老纸不管
带参数：你BB我做就好了，并不在意成功与失败

---

Over 请问，没有“个性”的人也能够成为英雄吗？

One·for·All