RxJava2核心解析-优快云博客

本文链接：https://blog.youkuaiyun.com/gswdzh/article/details/74076202

RxJava剥析

着手写RxJava2简析，也是我希望有更多人有对他更全面的了解，而不是先看到代码，一脸茫然，觉得不知如何用起，最重要的，还是自己以什么心态去学习这陌生又熟悉的RxJava，是随波逐流还是寻求自我，学什么都无非如此。好了，长话短说，入正：

Question 1:是什么;

两个字：异步。

Question 2:工作原理;

要使用，得先要了解RxJava特点：
首次看到它的时候，感觉这代码风格和我们平时命令式编码很大不同，它是以流程为核心，所执行的代码都是机器实际上要执行的指令，而这种风格，是称为函数式响应编程：以数据流为核心，处理数据输入输出的编程方式。

Question 3：为什么要用RxJava;

RxJava强大的地方在于:
1:代码分级处理，增加可读性和可再读性;
2:更加清晰的业务分离方式;代码更加简洁明了;
3:和AsyncTask和Handler相比，它的优势同样是简洁，而简洁的方式不同：随着逻辑变得更加复杂，却还是能够保持它的简洁性，这主要归功于它的分级。

明白了以上三个问题之后，是时候去学习它了，因为Rxjava1为实践版本，故直接讲述RxJava2：

RxJava核心原理:

基于观察者模式实现事件（任何事件）处理;
RxJava 有四个基本概念：Observable (被观察者)、 Observer (观察者)、 subscribe (订阅（事件）)。Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。

实现方法

1）：创建Observer

Observer 即观察者，它决定事件触发的时候将有怎样的行为:

    Observer<String> observer = new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
            //当观察者被订阅（订阅）OnSubscribe接口的呼叫方法会被执行。
            Log.e("gsw", "--observer-->onSubscribe: " + d);
        }
        @Override
        public void onNext(String s) {
            //下一步将要操作的事件
            Log.e("gsw", "--observer-->onNext: " + s);
        }
        @Override
        public void onError(Throwable e) {
            //错误发生时产生的回调
            Log.e("gsw", "--observer-->onError: " + e);
        }
        @Override
        public void onComplete() {
            //事件完成时的回调
            Log.e("gsw", "--observer-->onComplete: ");
        }
    };

这时要着重讲一下OnSubscriber执行概要：
/* 通常可以在这里做一些初始化操作，调用request()方法表示初始化工作已经完成，并立即触发onNext()方法
在onComplete()方法完成，才会再执行request()后边的代码
在2.X中，在我们onSubscribe()回调中必须调用s.request()方法去请求资源，参数就是要请求的数量，一般如果不限制请求数量，可以写成Long.MAX_VALUE，会之后触发|立即onNext()方法！
所以当你在onSubscribe()/onStart()中做了一些初始化的工作，而工作这些的英文在request()后面时，会出现一些问题，在onNext()执行时，你的初始化工作的那部分代码还没有执行。为了避免这种情况，请你确保调用request()时，已经把所有初始化工作做完了。*/

除了 Observer 接口之外，RxJava 还内置了一个实现了 Observer 的抽象类：Subscriber。 Subscriber 对 Observer 接口进行了一些扩展，但他们的基本使用方式是完全一样的：

不仅基本使用方式一样，实质上，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能，选择 Observer 和 Subscriber 是完全一样的。

 Subscriber<Integer> subscriber = new Subscriber<Integer>() {
        @Override
        public void onSubscribe(Subscription s) {
        //这一步是必须，我们通常可以在这里做一些初始化操作，调用request()方法表示初始化工作已经完成
        //调用request()方法，会立即触发onNext()方法
        //在onComplete()方法完成，才会再执行request()后边的代码
            s.request(Long.MAX_VALUE);
            Log.e("gsw", "subscriber-->onSubscribe-->Subscription: " + s);
        }
        @Override
        public void onNext(Integer integer) {
            Log.e("gsw", "subscriber-->onNext-->Integer: " + integer);
        }
        @Override
        public void onError(Throwable t) {
            Log.e("gsw", "subscriber-->onError-->ThrowableL:" + t);
        }

        @Override
        public void onComplete() {
            Log.e("gsw", "subscriber-->onComplete--");
        }
    };

2) 创建 Observable

Observable 即被观察者，它决定什么时候触发事件以及触发怎样的事件。 RxJava 使用 create() 方法来创建一个 Observable ，并为它定义事件触发规则：

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

            observer.onNext("gsw-->01");
            observer.onNext("gsw-->02");
            observer.onNext("gsw-->03");

            observer.onComplete();
            subscriber.onComplete();
        }
    });

create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法， RxJava 还提供了一些方法用来快捷创建事件队列，例如：

//just(T...): 将传入的参数依次发送出来。
Observable observable = Observable.just("Hello", "Hi", "Aloha");

//from(T[]) / from(Iterable<? extends T>) : 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。
String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);

创建了 Observable 和 Observer 之后，再用 subscribe() 方法将它们联结起来，就可以工作了。

        //订阅其一
        observable.subscribe(observer);
        //订阅全部
        observable.subscribe();

关键理解点：

有人可能会注意到， subscribe() 这个方法有点怪：它看起来是『observalbe 订阅了 observer / subscriber』而不是『observer / subscriber 订阅了 observalbe』，这看起来就像『杂志订阅了读者』一样颠倒了对象关系。这让人读起来有点别扭，不过如果把 API 设计成 observer.subscribe(observable) / subscriber.subscribe(observable) ，虽然更加符合思维逻辑，但对流式 API 的设计就造成影响了，比较起来明显是得不偿失的。