Rxjava------初识Rx和Rxjava

什么是Rx

• Rx是一个编程模型，目标是提供一致性的编程接口，帮助我们更方便的处理异步数据流。
• Rx是一个使用可观察数据流进行异步编程的编程接口，ReactiveX结合了观察者模式，迭代器模式和函数式编程的精华。

Rx的特点

1. 使用的是观察者模式
2. 简化代码：

• 函数式风格：对可观察数据流使用无副作用的输入输出函数，避免程序里错综复杂的状态。
• 简化代码：Rxjava的操作符通常可以将复杂的难题简化为很少的几行代码。
• 异步错误处理：传统的try/catch无法进行异步计算，Rx提供了合适的错误处理机制。
• 轻松使用并发：Rx的Observables（被观察者）和Schedulers（调度）让开发者可以摆脱底层的线程同步和各种并发问题。

3. 响应式函数式编程。

函数响应式编程

• 响应式编程：响应式编程就是与异步和数据流交互的编程范式，我们可以将所有的事件视为数据流，监听这样的数据流并作出反应。异步是为区分无关的事物，数据流是为了联系起有关的事物。用到观察者模式实现数据流传递。
  • 数据流：是两个事物（在这里我们理解为函数）间关系的桥梁，且只有一个方向，即从上游实体到下游实体。
  • 异步：事物在子各自的线程中执行。
• 函数响应式编程：我们可以调用许多非常棒的函数，去创建、结合、过滤任何一组数据流。一个或多个数据流可以作为另一个数据流的输入。

Rxjava的原理

1. 扩展的观察者模式

Rxjava基于一种扩展的观察者模式，这个模式在Android中很常见，比如说Button的点击事件，就是一个典型的观察者模式，控件Button是被观察者，onClickListener是观察者，setOnClickListener是订阅者，将观察者和被观察者连接到一起。

Rxjava中扩展的观察者模式：

角色	作用	类别
被观察者（Observables）	产生事件	控件
观察者（Observer）	接收事件，并给出响应动作	onClickListener
订阅者（Subscribe）	连接被观察者和观察者	setOnClickListener
事件（Event）	充当被观察者和观察者之间沟通的载体	控件被点击

2. Rxjava的观察者模式流程

RxJava原理可总结为：被观察者 （Observable） 通过 订阅（Subscribe） 按顺序发送事件 给观察者 （Observer）， 观察者（Observer） 按顺序接收事件 & 作出对应的响应动作。

Rxjava的基本使用

分步骤实现

使用步骤主要分为3步：创建被观察者，创建观察者，通过订阅将两者连接起来。

步骤1：创建被观察者（生产事件）

 // 1. 创建被观察者 Observable 对象
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            // create() 是 RxJava 最基本的创造事件序列的方法
            // 此处传入了一个 OnSubscribe 对象参数
            //当Observable被订阅时，OnSubscribe的call()方法会自动被调用，即事件序列会一次设定次序本被触发
            //即观察者会依此调用对应事件的复写方法从而响应事件
            //从而实现被观察者调用了观察者的回调方法&由被观察者向观察者的事件传递


            //2.在复写的subscribe（）里定义需要发送的事件
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                // 通过 ObservableEmitter类对象产生事件并通知观察者

                // ObservableEmitter类介绍
                // a. 定义：事件发射器
                // b. 作用：定义需要发送的事件 & 向观察者发送事件

                e.onNext(1);  //发送事件
                e.onNext(2);
                e.onNext(3);
                e.onComplete();//发送完成事件
            }
        });

步骤2：创建观察者（Observe）并定义响应事件的行为

创建观察者有两种方式：Observer接口和Subscriber接口

• Observer接口：在对象中复写被观察者的对应事件方法，当被观察者生产某个事件时，会调用该复写方法进行响应。必须复写onSubscribe方法。

 // 1. 创建观察者 （Observer ）对象
        Observer<Integer> observer = new Observer<Integer>() {
            // 2. 创建对象时通过对应复写对应事件方法 从而 响应对应事件

            // 观察者接收事件前，默认最先调用复写 onSubscribe（）
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            // 当被观察者生产Next事件 & 观察者接收到时，会调用该复写方法 进行响应
            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "对Next事件作出响应" + value);
            }

            // 当被观察者生产Error事件& 观察者接收到时，会调用该复写方法 进行响应
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            // 当被观察者生产Complete事件& 观察者接收到时，会调用该复写方法 进行响应
            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        };
    }

• Subscriber接口：使用方法与Observer接口完全一致。

// 1. 创建观察者 （Observer ）对象
        Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            // 2. 创建对象时通过对应复写对应事件方法 从而 响应对应事件

            // 观察者接收事件前，默认最先调用复写 onSubscribe（）
            @Override
            public void onSubscribe(Subscription s) {
                Log.d(TAG, "开始采用subscribe连接");
            }


            // 当被观察者生产Next事件 & 观察者接收到时，会调用该复写方法 进行响应
            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "对Next事件作出响应" + value);
            }

            // 当被观察者生产Error事件& 观察者接收到时，会调用该复写方法 进行响应
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            // 当被观察者生产Complete事件& 观察者接收到时，会调用该复写方法 进行响应
            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        };

Subscriber抽象类和Observer接口的区别

• 相同点：二者基本使用的方法完全一致（实质上，在Rxjava的订阅subscribe过程中，Observer总是会被转换成Subscriber再使用）
• 不同点：Subscriber是Observer的一个抽象类，对Observer接口进行了扩展，新增了两个方法：
  • onStart（）：在还未响应事件前调用，用于做一些初始化工作。
  • unsubscribe（）：用于取消订阅。在该方法被调用后，观察者将不再接受/响应事件。
  • 调用该方法前，先使用isUnsubscribed（）判断状态，确定被观察者Observable是否还持有Subscriber的引用，如果引用不能及时释放，就会出现内存泄漏。

步骤3：通过订阅（Subscribe）链接观察者和被观察者

observable.subscribe(observer);
 // 或者 observable.subscribe(subscriber)；

Rxjava–基于事件流的链式编程

上面的写法是为了描述Rxjava的使用，在实际使用中会将上面的代码连在一起，从而更加简洁，更加优雅，即链式编程。

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(@NonNull Integer integer) {
                Log.d(TAG, "对Next事件作出响应" + integer);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });

还有更简洁的写法：

Observable.just(1,2,3).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: "+i);
            }
        });

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

• just(T...): 将传入的参数依次发送出来。

Observable observable = Observable.just("Hello", "Hi", "Aloha");
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

• from(T[]) / from(Iterable<? extends T>) : 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。

String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

上面 just(T...) 的例子和 from(T[]) 的例子，都和之前的 create(OnSubscribe) 的例子是等价的。

两个使用例子

• 打印字符串数组

String[] names = ...;
Observable.from(names)
    .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("tag", s);
            }
        });

• 由id获取图片并显示：由指定的一个 drawable 文件 id drawableRes 取得图片，并显示在 ImageView 中，并在出现异常的时候打印 Toast 报错：

int drawableRes = ...;
ImageView imageView = ...;
Observable.create(new ObservableOnSubscribe<Drawable>() {
    @Override
    public void subscribe(@io.reactivex.annotations.NonNull ObservableEmitter<Drawable> emitter) throws Exception {
        Resources resources = getContext().getResources();
        Drawable drawable = resources.getDrawable(drawableRes);
        emitter.onNext(drawable);
        emitter.onComplete();
    }
}).subscribe(new Observer<Drawable>() {
    @Override
    public void onSubscribe(@io.reactivex.annotations.NonNull Disposable d) {
    }

    @Override
    public void onNext(@io.reactivex.annotations.NonNull Drawable drawable) {
         imageView.setImageDrawable(drawable);
    }
    @Override
    public void onError(@io.reactivex.annotations.NonNull Throwable e) {
         Toast.makeText(getActivity(), "Error!", Toast.LENGTH_SHORT).show();
    }
     @Override
        public void onComplete() {
     }
});