RxJava框架的学习总结---基础用法01

作者: Elder | 来源:发表于2016-12-18 22:18 被阅读68次

之前看过RxJava的一篇文章非常不错跳转博文通过这篇博文我相信大家都会对RxJava这个框架的使用有了一定的心得。这里将自己的学习的内容进行总结，方便后期查用。

一、RxJava简介

GitHub地址大家可以自行了解，这里我简单介绍一下Android Studio如何添加RxJava依赖：

compile 'io.reactivex:rxjava:1.2.4'
compile 'io.reactivex:rxandroid:1.2.1'

这是截止目前最新的1.x版本了，在GitHub上可以看见RxJava已经有了2.0的更新版，由于是初学者并没有那么急于求成，还是从1.0的版本开始学习使用吧。这里你还可以看到RxAndroid的身影，简单介绍一下：

RxAndroid是对RxJava在Android上的扩展，如果你是做安卓开发的话，各种主线程和子线程的操作肯定会让你觉得头疼，RxAndroid可以很容易地解决你的这种困扰。

二、初步的使用

RxJava 的异步实现，是通过一种扩展的观察者模式来实现的。观察者最简单的对象关系如下图，当一个被观察者发出事件时，观察者接收事件并调用回调方法响应此事件。

观察模式关系图

1、观察者（Observer）

所以我们先定义一个观察者对象observer，代码如下：

Observer<String> observer = new Observer<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {

            }
        };

Observer是一个接口内部定义了三个方法如上，这里说明一下RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。

onNext()当事件队列里有事件发出时即会调用此方法来处理
onError()当事件队列在处理过程中出异常时，onError()会被触发，同时队列自动终止，不允许再有事件发出。
onCompleted()当事件队列完结，并且不再有新事件发出时即会调用此方法。
在一个正确运行的事件序列中, onCompleted() 和 onError()有且只有一个，并且是事件序列中的最后一个。需要注意的是,onCompleted() 和 onError()二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。

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

subscriber = new Subscriber<String>() {
            @Override
            public void onStart() {
                super.onStart();
                // 这是一个扩展的方法，用于初始化一些数据，与定义Subscriber对象运行在同一个线程
            }

            @Override
            public void onCompleted() {
                Log.e("xns", "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("xns", e.toString());
            }

            @Override
            public void onNext(String s) {
                Log.e("xns", s);
            }
        };

 @Override
    protected void onStop() {
        if (subscriber.isUnsubscribed()) {// 释放资源的方法，防止内存泄漏
            subscriber.unsubscribe();
        }
        super.onStop();
    }

onStart()
这是 Subscriber增加的方法。它会在 subscribe 刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，它总是在 subscribe 所发生的线程被调用，而不能指定线程。
unsubscribe()
这是 Subscriber所实现的另一个接口 Subscription的方法，用于取消订阅。在这个方法被调用后，Subscriber将不再接收事件。一般在这个方法调用前，可以使用 isUnsubscribed()先判断一下状态。 unsubscribe()这个方法很重要，因为在 subscribe()之后， Observable会持有 Subscriber的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（例如 onPause()、onStop()等方法中）调用 unsubscribe()来解除引用关系，以避免内存泄露的发生。

关于观察者创建和使用就介绍到这，我们再来看看被观察者的创建和使用方法。

2、被观察者（Obserable）

RxJava使用create()方法来创建一个Observable对象，并为它定义触发事件时的规则：

Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("Hello");
            subscriber.onNext("RxJava");
            subscriber.onCompleted();
        }
    });

这里传入了一个OnSubscribe对象作为参数。它的作用相当于一个计划表，当Obserable被订阅的时候，OnSubscribe的call()方法就会被调用，就会依次调用订阅者的onNext()方法两次和onCompleted()方法。这样，就完成了被观察者调用观察者的回调方法来完成事件的传递，即观察者模式。

onCreate()是RxJava最基本的创建事件序列的方法。基于这个方法，RxJava还提供了一些快捷方法来创建。
just(T...)将传入的参数依次发送出来。

Observable<String> observable2 = Observable.just("Hello","RxJava");

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

String[] strArr = {"Hello","RxJava"};
    Observable<String> observable3 = Observable.from(strArr);

以上这三种方式都是等价的。

3、订阅（Subscribe）

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

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

Observable.subscribe(Subscriber) 的内部实现是这样的（仅核心代码）：

// 注意：这不是 subscribe() 的源码，而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
// 如果需要看源码，可以去 RxJava 的 GitHub 仓库下载。
public Subscription subscribe(Subscriber subscriber) {
    subscriber.onStart();
    onSubscribe.call(subscriber);
    return subscriber;
}

可以看到，subscriber() 做了3件事：

调用 Subscriber.onStart() 。这个方法在前面已经介绍过，是一个可选的准备方法。
调用 Observable 中的 OnSubscribe.call(Subscriber) 。在这里，事件发送的逻辑开始运行。从这也可以看出，在 RxJava 中， Observable 并不是在创建的时候就立即开始发送事件，而是在它被订阅的时候，即当 subscribe() 方法执行的时候。
将传入的 Subscriber 作为 Subscription 返回。这是为了方便 unsubscribe()。（看源码你会发现Subscriber是Subscription的实现子类，Subscription接口只定义了两个方法void unsubscribe();、boolean isUnsubscribed();）

被观察者与观察者方法的调用关系

除了 subscribe(Observer) 和 subscribe(Subscriber) ，subscribe() 还支持不完整定义的回调，RxJava 会自动根据定义创建出 Subscriber 。形式如下：

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);

这里介绍一下Action0和Action1。它们都是RxJava的内部接口，Action0接口只用一个call()方法，这个方法无参无返回值；由于 onCompleted() 方法也是无参无返回值的，因此 Action0 可以被当成一个包装对象，将 onCompleted() 的内容打包起来将自己作为一个参数传入 subscribe()以实现不完整定义的回调。这样其实也可以看做将 onCompleted() 方法作为参数传进了subscribe()，相当于其他某些语言中的『闭包』。 Action1接口有一个call(T param)方法，这个方法也无返回值可以看作是将 onNext(obj)和 onError(error) 打包起来传入 subscribe() 以实现不完整定义的回调。RxJava 还提供了多个 ActionX 形式的接口 (例如 Action2, Action3) 的，它们可以被用以包装不同的无返回值的方法。

4、举例说明：

a.打印字符串数组
将字符串数组 names中的所有字符串依次打印出来：

private void testRxjava2() {
        String[] names = {"xns","wxs","tyc"};
        Observable.from(names).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d("xns", s);
            }
        });
    }

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

private void testRxJava3() {
        final int drawableResId = 0;
        final ImageView imageView = new ImageView(this);
        Observable.create(new Observable.OnSubscribe<Drawable>() {

            @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
            @Override
            public void call(Subscriber<? super Drawable> subscriber) {
                Drawable drawable = getTheme().getDrawable(drawableResId);
                subscriber.onNext(drawable);
                subscriber.onCompleted();
            }
        }).subscribe(new Observer<Drawable>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Drawable drawable) {
                imageView.setImageDrawable(drawable);
            }
        });
    }

    private void testRxjava2() {
        String[] names = {"xns","wxs","tyc"};
        Observable.from(names).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d("xns", s);
            }
        });
    }

以上就是RxJava的基本使用。然而在 RxJava 的默认规则中，事件的发出和消费都是在同一个线程的。也就是说，如果只用上面的方法，实现出来的只是一个同步的观察者模式。观察者模式本身的目的就是『后台处理，前台回调』的异步机制，因此异步对于 RxJava 是至关重要的。而要实现异步，则需要用到 RxJava 的另一个概念： Scheduler（调度器）。下一篇我将和大家继续学习RxJava接下来的内容。

RxJava框架的学习总结---基础用法01

一、RxJava简介

二、初步的使用

1、观察者（Observer）

2、被观察者（Obserable）

3、订阅（Subscribe）

4、举例说明：

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

RxJava

Android技术知识