RxJava学习第一篇---重新认识RxJava以及基本使用

RxJava在工作中一直有用到过，不管是使用RxBus还是interval轮循，一直使用的是最基本的功能，RxJava的精髓内容一直没有使用过，感觉有点为了使用而使用的嫌疑，今天开始对RxJava进行一次深入的学习，本文预计分为三篇

第一篇：重新认识RxJava以及基本使用

第二篇：RxJava调度器以及操作符使用

第三篇：反压学习，RxAndroid的使用和总结

下面开始第一章学习，本次学习以RxJava在GitHub上的官方wiki文档为主WiKi传送门

RxJava对我来说有两大特点，

第一链  链式结构（个人认为链式结构逻辑更清晰）

第二线  线程切换非常方便（在Android中主线程和子线程切换确实是一个很费时间的工作）

如何使用

本文主要针对Android使用其他不在考虑范围，当然使用工具为android studio，其他开发工具请自行百度操作

要使用第一步当然是引入了，官方文档写的很明显，当然这里还是粘贴一下

首先在App的Gradle中添加

implementation "io.reactivex.rxjava2:rxjava:2.1.12"

引入之后我们在测试类中先写一个简单的测试

   @Test
    public void addition_isCorrect() {
        testRx("1", "2", "3", "4");
    }

    private void testRx(String... message) {
        Observable.fromArray(message)
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        System.out.println("Hello RxJava " + s);
                    }
                });
    }

然后我们可以看到输出结果为：

Hello RxJava 1
Hello RxJava 2
Hello RxJava 3

Hello RxJava 4

一个简单的RxJava使用就结束了

对象解释

我们都知道RxJava本质是观察者模式，那么我们肯定有被观察者和观察者，有绑定和取消绑定。

因为本文主要是做深入学习，不对原理进行和流程进行深入介绍，接下来直接总结个人认为关键的内容

在RxJava2.0中，观察者对象主要有

    Flowable: 可以发射0到N个值，并且以成功或者错误结束，支持Backpressure

    Observable: 可以发射0到N个值，并且以成功或者错误结束，不支持Backpressure,性能忧于Flowable

    Single:只可以发射一个值，或者一个错误的通知（触发任何一个订阅关系都会）

    Completable:它从来不发射数据，只处理onComplete和onError事件。

    Maybe:  能够发射0或者1个数据，要么成功要么失败。

 private void testFlowable() {
        Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 10; i++) {
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.BUFFER).subscribe(new Subscriber<Integer>() {
            Subscription subscription;

            @Override
            public void onSubscribe(Subscription s) {
                subscription = s;
            }

            @Override
            public void onNext(Integer integer) {
                try {
                    Thread.sleep(5000);
                  LogUtils.i("Hello Flowable:" + integer + "  时间：" + TimeUtils.getNowString());
                    subscription.request(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onError(Throwable t) {
                LogUtils.i("Flowable:错误");
            }

            @Override
            public void onComplete() {
                LogUtils.i("Flowable:结束");
            }
        });
    }

  private void testObservable() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 10; i++) {
                    emitter.onNext(i);
                }
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                System.out.println("Hello Observable:" + integer + "  时间：" + TimeUtils.getNowString());
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

private void testSingle() {
        Single.create(new SingleOnSubscribe<Integer>() {
            @Override
            public void subscribe(SingleEmitter<Integer> emitter) throws Exception {
                emitter.onSuccess(1);
            }
        }).subscribe(new SingleObserver<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onSuccess(Integer integer) {
                System.out.print("Hello Single:"+integer);
            }

            @Override
            public void onError(Throwable e) {

            }
        });
    }

    private void testCompletable(){
        Completable.create(new CompletableOnSubscribe() {
            @Override
            public void subscribe(CompletableEmitter emitter) throws Exception {
                emitter.onComplete();
            }
        }).subscribe(new CompletableObserver() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onComplete() {
                System.out.print("Hello Completable");
            }

            @Override
            public void onError(Throwable e) {

            }
        });
    }

 private void testMaybe() {
        Maybe.create(new MaybeOnSubscribe<Integer>() {
            @Override
            public void subscribe(MaybeEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 10; i++) {
                    emitter.onComplete();
                }
            }
        }).subscribe(new MaybeObserver<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onSuccess(Integer integer) {
                System.out.print("Hello MayBe" + integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                System.out.print("Hello MayBe" );
            }
        });
    }

上诉几个例子中我们看到都用到了一个 subscribe，它用于订阅被观察者，需要传入一个观察者对象，观察者对象有三个回调方法

onNext(T item )：接收到发射的数据，可以多次被调用；

onComplete( )：正常结束后调用，只可以调用一次

onError(Throwable e):异常结束后调用，只可以调用一次

有订阅当然肯定有取消订阅，取消订阅使用unSubscribe就可以了。