RxJava（一）

2017-08-15  本文已影响0人  珞神

前言

一、RxJava 是什么

一个词概括：异步

二、为什么要用 RxJava ，好在哪

一个词概括：简洁

三、概念

3.1 RxJava 是一种扩展的观察者模式，有四个基本概念

Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。

四、创建观察者，即 Observe

创建之前要先添加依赖：

    //RxJava
    compile 'io.reactivex:rxjava:1.3.0'
    compile 'io.reactivex:rxandroid:1.2.1'
4.1 它决定事件触发的时候将有怎样的行为。 RxJava 中的 Observer 接口的实现方式：
    /**
     * 观察者，它决定事件触发的时候将有怎样的行为
     */
    Observer<String> observer = new Observer<String>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(String s) {

        }
    };
4.2 另一个观察者，Subscriber
Subscriber 是 Observer 的抽象类，它 对 Observer 接口进行了一些扩展，但他们的基本使用方式是完全一样的：
 Subscriber<String> subscriber = new Subscriber<String>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(String s) {

        }

        @Override
        public void onStart() {
            super.onStart();
        }

    };
不仅基本使用方式一样，实质上，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能，选择 Observer 和 Subscriber 是完全一样的。它们的区别对于使用者来说主要有两点：
subscriber.unsubscribe();

五、创建被观察者 Observable

5.1 它决定什么时候触发事件以及触发怎样的事件。 RxJava 使用 create() 方法来创建一个 Observable ，并为它定义事件触发规则，create() 方法是 RxJava 最基本的创造事件序列的方法
    /**
     * 创建 被观察者
     *
     * 当 Observable 被订阅的时候，OnSubscribe 的 call() 方法会自动被调用
     */
    Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("Hello");
            subscriber.onNext("Hi");
            subscriber.onNext("Aloha");
            subscriber.onCompleted();

        }
    });
5.2 其他创建 Observable 的方式
//目前，通过 API 发现 just 方法的参数限定在十个以内，十个以外还没试过
Observable<String> observable2 = Observable.just("Hello", "Hi", "Aloha");
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

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

    List<String> items = new ArrayList<>();
    items.add("Hello");
    items.add("Hi");
    items.add("Aloha");
    Observable<String> observable3 = Observable.from(items);

六、订阅 Subscribe

创建了 Observable 和 Observer 之后，再用 subscribe() 方法将它们联结起来，整条链子就可以工作了。代码形式很简单：

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

当 subscribe() 方法执行的时候，就立即开始发送事件

七、RxJava 中的 ActionX

ActionX 指的是一系列的接口，它只有一个方法 call()，这个方法是无返回值的，可以传入 subscribe() 以实现不完整定义的回调。

7.1 看看有多少种 Action
image
7.2 看看其中的 Action1 和 Action0
/**
 * A one-argument action.
 * @param <T> the first argument type
 */
public interface Action1<T> extends Action {
    void call(T t);
}

/**
 * A zero-argument action.
 */
public interface Action0 extends Action {
    void call();
}
7.3 使用的时候，形式如下
Action1<String> onNextAction = new Action1<String>() {
    // onNext()
    @Override
    public void call(String s) {
        Log.d(tag, s);
    }
};
Action1<Throwable> onErrorAction = new Action1<Throwable>() {
    // onError()
    @Override
    public void call(Throwable throwable) {
        // Error handling
    }
};
Action0 onCompletedAction = new Action0() {
    // onCompleted()
    @Override
    public void call() {
        Log.d(tag, "completed");
    }
};

// 自动创建 Subscriber ，并使用 onNextAction 来定义 onNext()
observable.subscribe(onNextAction);
// 自动创建 Subscriber ，并使用 onNextAction 和 onErrorAction 来定义 onNext() 和 onError()
observable.subscribe(onNextAction, onErrorAction);
// 自动创建 Subscriber ，并使用 onNextAction、 onErrorAction 和 onCompletedAction 来定义 onNext()、 onError() 和 onCompleted()
observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

说明：

八、线程控制 —— Scheduler

在不指定线程的情况下， RxJava 遵循的是线程不变的原则，即：在哪个线程调用 subscribe()，就在哪个线程生产事件；在哪个线程生产事件，就在哪个线程消费事件。如果需要切换线程，就需要用到 Scheduler （调度器）。

8.1 Scheduler 的 API 如下：
8.2 使用

我们可以使用 subscribeOn() 和 observeOn() 两个方法来对线程进行控制了。 subscribeOn(): 指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。 * observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程，示例如下：

Observable.just(1, 2, 3, 4)
    .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
    .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
    .subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer number) {
            Log.d(tag, "number:" + number);
        }
    });

说明：

8.3 扩展 doOnSubscribe()
Observable.create(onSubscribe)
    .subscribeOn(Schedulers.io())
    .doOnSubscribe(new Action0() {
        @Override
        public void call() {
            progressBar.setVisibility(View.VISIBLE); // 需要在主线程执行
        }
    })
    .subscribeOn(AndroidSchedulers.mainThread()) // 指定主线程
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(subscriber);

如上，在 doOnSubscribe()的后面跟一个 subscribeOn() ，就能指定准备工作的线程了。

8.4 线程的自由控制
Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.newThread())
    .map(mapOperator) // 新线程，由 observeOn() 指定
    .observeOn(Schedulers.io())
    .map(mapOperator2) // IO 线程，由 observeOn() 指定
    .observeOn(AndroidSchedulers.mainThread) 
    .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定
8.5 doOnNext()
        observable
                .subscribeOn(Schedulers.io())
                .doOnNext(new Action1<RetrofitTextBean>() {
                    @Override
                    public void call(RetrofitTextBean retrofitTextBean) {
                        //耗时操作在里边进行

                        String name = Thread.currentThread().getName();
                        Log.i("doOnNext",name);
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<RetrofitTextBean>() {
                    @Override
                    public void onCompleted() {

                        Toast.makeText(getApplicationContext(), "请求完成", Toast.LENGTH_SHORT).show();
                    }

                    @Override
                    public void onError(Throwable e) {

                        textview.setText(e.getMessage());
                    }

                    @Override
                    public void onNext(RetrofitTextBean retrofitTextBean) {
                        String name = Thread.currentThread().getName();
                        Log.i("onNext",name);

                        int code = retrofitTextBean.getCode();
                        String msg = retrofitTextBean.getMsg();
                        textview.setText("code:" + code + "---msg:" + msg);
                    }
                });

log 信息显示如下：

I/doOnNext: RxIoScheduler-2
I/onNext: main

分析： 我没有指定线程，默认在 io 线程中 ，我想会不会跟 subscribeOn(Schedulers.io()) 有关，当然也可以通过 observeOn 来指定线程，并且该方法执行顺序在 Observer 的 onNext 方法之前。

上一篇 下一篇

猜你喜欢

热点阅读