RxJava的操作说明

概念：

RxJava：a library for composing asynchronous and event-based programs using observable sequences for the Java VM
翻译：RxJava 是一个在 JVM 上使用可观测的序列来组成异步的、基于事件的程序的库

创建被观察者对象&产事件

 private void creatObservable() {

        observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            // create() 是 RxJava 最基本的创造事件序列的方法
            // 此处传入了一个 OnSubscribe 对象参数
            // 当 Observable 被订阅时，OnSubscribe 的 call() 方法会自动被调用，即事件序列就会依照设定依次被触发
            // 即观察者会依次调用对应事件的复写方法从而响应事件 // 从而实现被观察者调用了观察者的回调方法 & 由被观察者向观察者的事件传递，即观察者模式
            // 2\. 在复写的subscribe（）里定义需要发送的事件
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 通过 ObservableEmitter类对象产生事件并通知观察者
                // ObservableEmitter类介绍
                // a. 定义：事件发射器
                // b. 作用：定义需要发送的事件 & 向观察者发送事件
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onNext(4);
                emitter.onComplete();
            }
        });
    }

创建Observable的其他方法：

方法1：just(T…)：直接将传入的参数依次发送出来

      observable1=Observable.just("A","B","C");
         将会依次调用：
        onNext("A");
         onNext("B");
         onNext("C");
       onCompleted();

方法2：from(T[]) / from(Iterable

        // 方法2：from(T[]) / from(Iterable<? extends T>) : 将传入的数组 / Iterable 拆分成具体对象后，依次发送出来
      String[] words = {"A", "B", "C"};
      Observable<String> observable=Observable.fromArray(words);
        // 将会依次调用：
        onNext("A");
        onNext("B");
        onNext("C");
        onCompleted();

创建观察者对象定义响应事件的行为

方式1：采用Observer 接口

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

            // 观察者接收事件前，默认最先调用复写 onSubscribe（）

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用Observer连接");
            }

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

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

            }

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

            }
        };

    }

方式2：采用Subscriber 抽象类 创建观察者 （Observer ）对象

/**
     * 方式2：采用Subscriber 抽象类 创建观察者 （Observer ）对象
     * Subscriber类 = RxJava 内置的一个实现了 Observer 的抽象类，对 Observer 接口进行了扩展
     * 注意此方法是RxJava1.0版本中的方法在2.0以上已经废弃
     */
    private void creatObserverBySubscriber() {
        subscriber = new Subscriber<Integer>() {
            //  创建对象时通过对应复写对应事件方法 从而 响应对应事件
            // 观察者接收事件前，默认最先调用复写 onSubscribe（）
            @Override
            public void onSubscribe(Subscription s) {
                Log.d(TAG, "开始采用subscribe连接");
            }

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

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

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

方式1和方式2的区别

1. 二者基本使用方式完全一致（实质上，在RxJava的 subscribe 过程中，Observer总是会先被转换成Subscriber再使用）
2. onStart()：在还未响应事件前调用，用于做一些初始化工作
3. unsubscribe()：用于取消订阅。在该方法被调用后，观察者将不再接收 & 响应事件
4. 调用该方法前，先使用 isUnsubscribed() 判断状态，确定被观察者Observable是否还持有观察者Subscriber的引用，如果引用不能及时释放，就会出现内存泄露

通过订阅（Subscribe）连接观察者和被观察者

      observable.subscribe(observer);
//        observable.subscribe((Observer<? super Integer>) subscriber);注意这是RxJava1.0版本中的方法，2.0以上已经没有了subscriber方法
//        ②Observable.subscribe(Subscriber) 的内部实现
        // public Subscription subscribe(Subscriber subscriber) {
        // subscriber.onStart();
        // 步骤1中 观察者 subscriber抽象类复写的方法，用于初始化工作 onSubscribe.call(subscriber);
        // 通过该调用，从而回调观察者中的对应方法从而响应被观察者生产的事件
        // 从而实现被观察者调用了观察者的回调方法 & 由被观察者向观察者的事件传递，即观察者模式
        // 同时也看出：Observable只是生产事件，真正的发送事件是在它被订阅的时候，即当 subscribe() 方法执行时
        // }

RxJava的链式操作

 private void creatRxJava() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 1\. 创建被观察者 & 生产事件
                emitter.onNext(11);
                emitter.onNext(22);
                emitter.onNext(33);
                emitter.onComplete();

            }
        }).subscribe(new Observer<Integer>() {
            // 2\. 通过通过订阅（subscribe）连接观察者和被观察者
            // 3\. 创建观察者 & 定义响应事件的行为
            // 1\. 定义Disposable类变量
            private Disposable mDisposable;

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接-链式调用");
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "对Next事件" + value + "作出响应");
// 可采用 Disposable.dispose() 切断观察者 与 被观察者 之间的连接
//即观察者 无法继续 接收 被观察者的事件，但被观察者还是可以继续发送事件
                if (value == 22) {
                    // 设置在接收到第二个事件后切断观察者和被观察者的连接
                    mDisposable.dispose();
                    Log.d(TAG, "已经切断了连接：" + mDisposable.isDisposed());
                }


            }

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

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

以 Consumer为例：实现简便式的观察者模式

 /**
     * 以 Consumer为例：实现简便式的观察者模式
     */
    private void creatRxJavaConsumer() {
        Observable.just("ConsumerHelloRxjava").subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println("ConsumerHelloRxjava");
            }
        });
    }