RxJava的使用详解
来源:互联网 发布:华东师范继续教育网络 编辑:程序博客网 时间:2024/06/17 15:19
介绍
RxJava 在 GitHub 主页上的自我介绍是 “a library for composing asynchronous and event-based programs using observable sequences for the Java VM”(一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库)。
其实, RxJava 的本质可以压缩为异步这一个词。
Android中的异步处理,我们使用过 AsyncTask / Handler 等等,那么RxJava相比他们的优势在哪里呢?那就是简洁,它使用一种链式调用,没有任何嵌套,随着程序逻辑变得越来越复杂,它依然能够保持简洁。
我们使用Android Studio IDE时引入RxJava只需要引入依赖:
compile 'io.reactivex:rxjava:1.0.14' compile 'io.reactivex:rxandroid:1.0.1'
API 及原理简析
概念:扩展的观察者模式
RxJava 的异步实现,是通过一种扩展的观察者模式来实现的。
(1)观察者模式
还记得我们之前讲设计模式时的观察者模式吗?参考设计模式(三)之行为型模式。
观察者模式(又被称为发布-订阅(Publish/Subscribe)模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时,会通知所有的观察者对象,使他们能够自动更新自己。 Android 开发中一个比较典型的例子是点击监听器 OnClickListener 。
(2)RxJava 的观察者模式
RxJava 有四个基本概念:Observable (被观察者)、 Observer (观察者)、 subscribe (订阅)、event(事件)。Observable 和 Observer 通过 subscribe() 方法实现订阅关系,从而 Observable 可以在需要的时候发出事件来通知 Observer。
与传统观察者模式不同, RxJava 的事件回调方法除了普通事件 onNext() (相当于 onClick() / onEvent())之外,还定义了两个特殊的事件:onCompleted() 和 onError()。
- onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理,还会把它们看做一个队列。RxJava规定,当不会再有新的 onNext() 发出时,需要触发 onCompleted() 方法作为标志。
- onError(): 事件队列异常。在事件处理过程中出异常时,onError() 会被触发,同时队列自动终止,不允许再有事件发出。
在一个正确运行的事件序列中, onCompleted() 和 onError()有且只有一个,并且是事件序列中的最后一个。需要注意的是,onCompleted() 和 onError() 二者也是互斥的,即在队列中调用了其中一个,就不应该再调用另一个。
RxJava 的观察者模式大致如下图:
基本实现
RxJava 的基本实现主要有三点:
(1)创建 Observer
Observer 即观察者,它决定事件触发的时候将有怎样的行为。 RxJava 中的 Observer 接口的实现方式:
Observer<String> observer = new Observer<String>() { @Override public void onNext(String s) { Log.d(tag, "Item: " + s); } @Override public void onCompleted() { Log.d(tag, "Completed!"); } @Override public void onError(Throwable e) { Log.d(tag, "Error!"); }};
除了 Observer 接口之外,RxJava 还内置了一个实现了 Observer 的抽象类:Subscriber。 Subscriber 对 Observer 接口进行了一些扩展,但他们的基本使用方式是完全一样的:
Subscriber<String> subscriber = new Subscriber<String>() { @Override public void onStart() { Log.d(tag, "onStart!"); } @Override public void onNext(String s) { Log.d(tag, "Item: " + s); } @Override public void onCompleted() { Log.d(tag, "Completed!"); } @Override public void onError(Throwable e) { Log.d(tag, "Error!"); }};
不仅基本使用方式一样,实质上,在 RxJava 的 subscribe 过程中,Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能,选择 Observer 和 Subscriber 是完全一样的。它们的区别对于使用者来说主要有两点:
- onStart(): 这是 Subscriber 增加的方法。它会在 subscribe刚开始,而事件还未发送之前被调用,可以用于做一些准备工作,例如数据的清零或重置。这是一个可选方法,默认情况下它的实现为空。需要注意的是,如果对准备工作的线程有要求(例如弹出一个显示进度的对话框,这必须在主线程执行),onStart() 就不适用了,因为它总是在 subscribe 所发生的线程被调用,而不能指定线程。要在指定的线程来做准备工作,可以使用doOnSubscribe() 方法,具体可以在后面的文中看到。
- unsubscribe(): 这是 Subscriber 所实现的另一个接口 Subscription的方法,用于取消订阅。在这个方法被调用后,Subscriber 将不再接收事件。一般在这个方法调用前,可以使用isUnsubscribed() 先判断一下状态。unsubscribe() 这个方法很重要,因为在 subscribe() 之后,Observable 会持有 Subscriber的引用,这个引用如果不能及时被释放,将有内存泄露的风险。所以最好保持一个原则:要在不再使用的时候尽快在合适的地方(例如 onPause()、onStop() 等方法中)调用 unsubscribe() 来解除引用关系,以避免内存泄露的发生。
(2) 创建 Observable
Observable 即被观察者,它决定什么时候触发事件以及触发怎样的事件。 RxJava 使用 create() 方法来创建一个 Observable ,并为它定义事件触发规则:
Observable 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(); }});
可以看到,这里传入了一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中,它的作用相当于一个计划表,当 Observable 被订阅的时候,OnSubscribe 的 call() 方法会自动被调用,事件序列就会依照设定依次触发(对于上面的代码,就是观察者Subscriber 将会被调用三次 onNext() 和一次 onCompleted())。这样,由被观察者调用了观察者的回调方法,就实现了由被观察者向观察者的事件传递,即观察者模式。
create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法, RxJava 还提供了一些方法用来快捷创建事件队列,例如:
- just(T…): 将传入的参数依次发送出来。
/**将会依次调用:onNext("Hello");onNext("Hi");onNext("Aloha");onCompleted();**/Observable observable = Observable.just("Hello", "Hi", "Aloha");
- from(T[]) / from(Iterable<\? extends T>) : 将传入的数组或 Iterable
拆分成具体对象后,依次发送出来。
String[] words = {"Hello", "Hi", "Aloha"};Observable observable = Observable.from(words);
上面 just(T…) 的例子和 from(T[]) 的例子,都和之前的 create(OnSubscribe) 的例子是等价的。
(3) Subscribe (订阅)
创建了 Observable 和 Observer 之后,再用 subscribe() 方法将它们联结起来,整条链子就可以工作了。代码形式很简单:
observable.subscribe(observer);//或者:observable.subscribe(subscriber);
注:subscribe() 这个方法有点怪:它看起来是『observalbe 订阅了 observer / subscriber』而不是『observer / subscriber 订阅了 observalbe』,但更符合流式 API 的设计。这个地方要注意一下。
整个过程中对象间的关系如下图:
除了 subscribe(Observer) 和 subscribe(Subscriber) ,subscribe() 还支持不完整定义的回调,RxJava 会自动根据定义创建出 Subscriber 。形式如下:
//Action1表示携带一个参数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表示携带0个参数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);
简单解释一下这段代码中出现的 Action1 和 Action0。 Action0 是 RxJava 的一个接口,它只有一个方法 call(),这个方法是无参无返回值的;由于 onCompleted() 方法也是无参无返回值的,因此 Action0 可以被当成一个包装对象,将 onCompleted() 的内容打包起来将自己作为一个参数传入 subscribe() 以实现不完整定义的回调。这样其实也可以看做将 onCompleted() 方法作为参数传进了 subscribe(),相当于其他某些语言中的『闭包』。 Action1 也是一个接口,它同样只有一个方法 call(T param),这个方法也无返回值,但有一个参数;与 Action0 同理,由于 onNext(T obj) 和 onError(Throwable error) 也是单参数无返回值的,因此 Action1 可以将 onNext(obj) 和 onError(error) 打包起来传入 subscribe() 以实现不完整定义的回调。事实上,虽然 Action0 和 Action1 在 API 中使用最广泛,但 RxJava 是提供了多个 ActionX 形式的接口 (例如 Action2, Action3) 的,它们可以被用以包装不同的无返回值的方法。
(4) 场景示例
a. 打印字符串数组
将字符串数组 names 中的所有字符串依次打印出来:
String[] names = {"java", "android", "javascript", "php"};Observable.from(names) .subscribe(new Action1<String>() { @Override public void call(String name) { Log.d(tag, name); } });
b. 由 id 取得图片并显示
由指定的一个 drawable 文件 id drawableRes 取得图片,并显示在 ImageView 中,并在出现异常的时候打印 Toast 报错:
Observable.create(new Observable.OnSubscribe<Drawable>() { @Override public void call(Subscriber<? super Drawable> subscriber) { Drawable drawable = getTheme().getDrawable(R.drawable.buddy); subscriber.onNext(drawable); subscriber.onCompleted(); } }).subscribe(new Observer<Drawable>() { @Override public void onNext(Drawable drawable) { img.setImageDrawable(drawable); } @Override public void onCompleted() { } @Override public void onError(Throwable e) { Toast.makeText(MainActivity.this, "Error!", Toast.LENGTH_SHORT).show(); } });
变换
(1)map
RxJava 提供了对事件序列进行变换的支持,这是它的核心功能之一,也是大多数人说『RxJava 真是太好用了』的最大原因。所谓变换,就是将事件序列中的对象或整个序列进行加工处理,转换成不同的事件或事件序列。
首先看一个 map() 的例子:
String path = Environment.getExternalStorageDirectory().getAbsolutePath() + "/test.jpg"; Observable.just(path) // 输入类型 String .map(new Func1<String, Bitmap>() { @Override public Bitmap call(String filePath) { //参数类型 String Bitmap bitmap = BitmapFactory.decodeFile(filePath); return bitmap; // 返回类型 Bitmap } }) .subscribe(new Action1<Bitmap>() { @Override public void call(Bitmap bitmap) { //参数类型 Bitmap img.setImageBitmap(bitmap); } });
这里出现了一个叫做 Func1 的类。它和 Action1 非常相似,也是 RxJava 的一个接口,用于包装含有一个参数的方法。 Func1 和 Action1 的区别在于, Func1 包装的是有返回值的方法。另外,和 ActionX 一样, FuncX 也有多个,用于不同参数个数的方法。FuncX 和 ActionX 的区别在 FuncX 包装的是有返回值的方法。
可以看到,map() 方法将参数中的 String 对象转换成一个 Bitmap 对象后返回,而在经过 map() 方法后,事件的参数类型也由 String 转为了 Bitmap。这种直接变换对象并返回的,是最常见的也最容易理解的变换。不过 RxJava 的变换远不止这样,它不仅可以针对事件对象,还可以针对整个事件队列,这使得 RxJava 变得非常灵活。
map(): 事件对象的直接变换,具体功能上面已经介绍过。它是 RxJava 最常用的变换。 map() 的示意图:
(2)flatMap
首先假设这么一种需求:假设有一个数据结构『学生』,现在需要打印出一组学生的名字。实现方式很简单:
Student[] students = {new Student("bob"), new Student("jack"), new Student("watson")}; Subscriber<String> subscriber = new Subscriber<String>() { @Override public void onNext(String name) { Log.d(tag, name); } @Override public void onCompleted() { Log.d(tag, "onComplete"); } @Override public void onError(Throwable e) { Toast.makeText(MainActivity.this, "Error!", Toast.LENGTH_SHORT).show(); } }; Observable.from(students) .map(new Func1<Student, String>() { @Override public String call(Student student) { return student.getName(); } }) .subscribe(subscriber);
很简单。那么再假设:如果要打印出每个学生所需要修的所有课程的名称呢?(需求的区别在于,每个学生只有一个名字,但却有多个课程。)用 map() 显然是不行的,因为 map() 是一对一的转化,而我现在的要求是一对多的转化。那怎么才能把一个 Student 转化成多个 Course 呢?
这个时候,就需要用 flatMap() 了:
Course[] courseList1 = new Course[]{new Course("Chinese"), new Course("mathematics")}; Course[] courseList2 = new Course[]{new Course("Chinese"), new Course("english")}; Course[] courseList3 = new Course[]{new Course("english"), new Course("mathematics")}; Student[] students = {new Student("bob", courseList1), new Student("jack", courseList2), new Student("watson", courseList3)}; Subscriber<Course> subscriber = new Subscriber<Course>() { @Override public void onNext(Course course) { Log.d(tag, course.getName()); } @Override public void onCompleted() { Log.d(tag, "onComplete"); } @Override public void onError(Throwable e) { Toast.makeText(MainActivity.this, "Error!", Toast.LENGTH_SHORT).show(); } }; Observable.from(students) .flatMap(new Func1<Student, Observable<Course>>() { @Override public Observable<Course> call(Student student) { return Observable.from(student.getCourse()); } }) .subscribe(subscriber);
从上面的代码可以看出, flatMap() 和 map() 有一个相同点:它也是把传入的参数转化之后返回另一个对象。但需要注意,和 map() 不同的是, flatMap() 中返回的是个 Observable 对象,并且这个 Observable 对象并不是被直接发送到了 Subscriber 的回调方法中。 flatMap() 的原理是这样的:
1. 使用传入的事件对象创建一个 Observable 对象;
2. 并不发送这个 Observable, 而是将它激活,于是它开始发送事件;
3. 每一个创建出来的 Observable 发送的事件,都被汇入同一个 Observable ,而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。
这三个步骤,把事件拆成了两级,通过一组新创建的 Observable 将初始的对象『铺平』之后通过统一路径分发了下去。而这个『铺平』就是 flatMap() 所谓的 flat。
看输出结果:
flatMap() 示意图:
(3)compose
本节用到了Scheduler的内容,请先看完线程控制:Scheduler。
RxJava的另一个好处在于,我们可以清楚地看到数据是如何在一系列操作符之间进行转换的。
Observable.from(someSource) .map(new Func1<Data, Data>() { @Override public Data call(Data data) { return manipulate(data); } }).subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Action1<Data>() { @Override public void call(Data data) { doSomething(data); } });
如何将一组操作符重用于多个数据流中呢?例如,因为希望在工作线程中处理数据,然后在主线程中处理结果,所以我会频繁使用subscribeOn()和observeOn()。如果我能够通过重用的方式,将这种逻辑运用到我所有的数据流中,将是一件多么伟大的事。
糟糕的实现方式(反面教材):
首先,使用schedulers(调度)创建一个方法:
<T> Observable<T> applySchedulers(Observable<T> observable) {return observable.subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread());}
然后,封装Observable数据链:
applySchedulers(Observable.from(someSource).map(new Func1<Data, Data>() { @Override public Data call(Data data) { return manipulate(data); } })).subscribe(new Action1<Data>() { @Override public void call(Data data) { doSomething(data); }});
虽然这样做也能达到目的,但是它看起来不仅丑,还容易让人产生困惑,applySchedulers()到底什么鬼?它不再符合操作符链路式结构,所以,看起来很难理解。
聪明的同学可能已经意识到了这个问题,但是RxJava早已提供了一种解决方案:Transformer(译者注:有转换器意思),一般情况下可以通过使用操作符Observable.compose()来实现。
Transformer实际上就是一个Func1<\Observable<\T>, Observable<\R>>,换言之就是:可以通过它将一种类型的Observable转换成另一种类型的Observable,和调用一系列的内联操作符是一模一样的。
接下来,我们一起创建一个Transformer与schedulers相结合的方法:
<T> Transformer<T, T> applySchedulers() { return new Transformer<T, T>() { @Override public Observable<T> call(Observable<T> observable) { return observable.subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()); } };}
试用:
Observable.from(someSource) .map(new Func1<Data, Data>() { @Override public Data call(Data data) { return manipulate(data); } }) .compose(applySchedulers()) .subscribe(new Action1<Data>() { @Override public void call(Data data) { doSomething(data); } });
如果使用 JDK 7或者更早版本进行编译的话,就不得不做出一些额外的改变,为compose()添加泛型:
.compose(this.<YourType>applySchedulers())
重用Transformers:
上一个实例中,我在所有的方法调用中都new了一个Transformer实例。你可以创建一个实例化版本,节省不必要的实例化对象。毕竟,Transformers关乎着代码重用。
如果,总是将一个具体的类型转换成另一个具体的类型,那么可以很容易的创建一个Transformer实例:
Transformer<String, String> myTransformer = new Transformer<String, String>() { // ...Do your work here...};
那么scheduler Transformer(调度转换器)应该怎样实现呢?因为,它根本不需要关心类型,所以就无法定义一个泛型实例:
/** 编译无法通过;因为根本不知道 T 从何而来*/Transformer<T, T> myTransformer;
可能有人会这样定义Transformer<\Object, Object>,然而这并没有什么卵用,并且造成的后果就是Observable将失去其类型信息。
为了解决这个问题,我从Collections中得到了一些启发,这个包装类有这样一堆方法,能够创建类型安全并且不可变的空集合(比如,Collections.emptyList())。由于在其内部使用了一个无泛型实例,所以需要封装在一个添加泛型约束的方法里。
可以像下面这样定义我们的schedulers Transformer(调度转换器)实例:
final Observable.Transformer schedulersTransformer = new Observable.Transformer() { @Override public Object call(Object observable) { return ((Observable) observable).subscribeOn(Schedulers.newThread()) .observeOn(AndroidSchedulers.mainThread()); }}; <T> Observable.Transformer<T, T> applySchedulers() { return (Observable.Transformer<T, T>) schedulersTransformer;}
现在我们终于把他做成一个“单例”了(译者注:此单例非彼单例)。
警告:如果不做类型转换检查,可能陷入麻烦。确保Transformer真正与类型无关。否则,即使代码通过了编译,在运行时仍然存在抛出ClassCastException异常的隐患。在当前场景中,我们知道它是安全的,因为schedulers并不会与发送出的事件产生任何的互动操作。
线程控制:Scheduler
然而,在 RxJava 的默认规则中,事件的发出和消费都是在同一个线程的。也就是说,如果只用上面的方法,实现出来的只是一个同步的观察者模式。观察者模式本身的目的就是『后台处理,前台回调』的异步机制,因此异步对于 RxJava 是至关重要的。而要实现异步,则需要用到 RxJava 的另一个概念: Scheduler (调度器)。
在RxJava 中,Scheduler ——调度器,相当于线程控制器,RxJava 通过它来指定每一段代码应该运行在什么样的线程。RxJava 已经内置了几个 Scheduler ,它们已经适合大多数的使用场景:
- Schedulers.immediate(): 直接在当前线程运行,相当于不指定线程。这是默认的 Scheduler。
- Schedulers.newThread(): 总是启用新线程,并在新线程执行操作。
- Schedulers.io(): I/O 操作(读写文件、读写数据库、网络信息交互等)所使用的 Scheduler。行为模式和 newThread() 差不多,区别在于 io() 的内部实现是是用一个无数量上限的线程池,可以重用空闲的线程,因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中,可以避免创建不必要的线程。
- Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算,即不会被 I/O 等操作限制性能的操作,例如图形的计算。这个 Scheduler 使用的固定的线程池,大小为 CPU 核数。不要把 I/O 操作放在 computation() 中,否则 I/O 操作的等待时间会浪费 CPU。
- AndroidSchedulers.mainThread(),Android专用的,它指定的操作将在 Android 主线程运行。
有了这几个 Scheduler ,就可以使用 subscribeOn() 和 observeOn() 两个方法来对线程进行控制了。
- subscribeOn(): 指定subscribe()订阅所发生的线程,即 call() 执行的线程。或者叫做事件产生的线程。
- observeOn(): 指定Observer所运行在的线程,即onNext()执行的线程。或者叫做事件消费的线程。
文字叙述总归难理解,上代码:
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); } });
上面这段代码中,由于 subscribeOn(Schedulers.io()) 的指定,被创建的事件的内容 1、2、3、4 将会在 IO 线程发出;而由于 observeOn(AndroidScheculers.mainThread()) 的指定,因此 subscriber 数字的打印将发生在主线程 。事实上,这种在 subscribe() 之前写上两句 subscribeOn(Scheduler.io()) 和 observeOn(AndroidSchedulers.mainThread()) 的使用方式非常常见,它适用于多数的 『后台线程取数据,主线程显示』的程序策略。
有人问了,能不能多切换几次线程?
答案是肯定的。observeOn() 指定的是它之后的操作所在的线程。因此如果有多次切换线程的需求,只要在每个想要切换线程的位置调用一次 observeOn() 即可。上代码:
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() 指定
如上,通过 observeOn() 的多次调用,程序实现了线程的多次切换。
不过,不同于 observeOn() , subscribeOn() 的位置放在哪里都可以,但它是只能调用一次的。当使用了多个 subscribeOn() 的时候,只有第一个 subscribeOn() 起作用。
- 延伸:doOnSubscribe()
然而,虽然超过一个的 subscribeOn() 对事件处理的流程没有影响,但在流程之前却是可以利用的。
在前面讲 Subscriber 的时候,提到过 Subscriber 的 onStart() 可以用作流程开始前的初始化。然而 onStart() 由于在 subscribe() 发生时就被调用了,因此不能指定线程,而是只能执行在 subscribe() 被调用时的线程。这就导致如果 onStart() 中含有对线程有要求的代码(例如在界面上显示一个 ProgressBar,这必须在主线程执行),将会有线程非法的风险,因为有时你无法预测 subscribe() 将会在什么线程执行。
而与 Subscriber.onStart() 相对应的,有一个方法 Observable.doOnSubscribe() 。它和 Subscriber.onStart() 同样是在 subscribe() 调用后而且在事件发送前执行,但区别在于它可以指定线程。默认情况下, doOnSubscribe() 执行在 subscribe() 发生的线程;而如果在 doOnSubscribe() 之后有 subscribeOn() 的话,它将执行在离它最近的 subscribeOn() 所指定的线程。
- doOnSubscribe()之前的subscribeOn()不会影响它。
- doOnSubscribe()之后的subscribeOn(),且是最近的才会影响它。
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() ,就能指定准备工作的线程了。
- 延伸:doOnNext()
RxJava中给我们提供了一个操作符: doOnNext() ,这个操作符允许我们在每次输出一个元素之前做一些其他的事情,比如提示啊保存啊之类的操作。我们一般使用doOnNext()去保存/缓存网络结果。
Observable.just("android") .subscribeOn(Schedulers.io()) //指定耗时进程 .observeOn(Schedulers.newThread()) //指定doOnNext执行线程是新线程 .doOnNext(new Action1<String>() { @Override public void call(String name) { Log.d(tag, "doOnNext--"+name); try { Thread.sleep(2000); } catch (Exception e) { e.printStackTrace(); } } }) .observeOn(AndroidSchedulers.mainThread())//指定最后观察者在主线程 .subscribe(new Action1<String>() { @Override public void call(String name) { Log.d(tag, "subscribe--"+name); } });
可见doOnNext()是阻塞I/O的操作,直到doOnNext里的方法在新线程执行完毕,subscribe里的call才有机会在主线程执行。
但是现在我们可以使用Schedulers.io()创建非阻塞的版本:
Observable.just("android") .subscribeOn(Schedulers.io()) //指定耗时进程 .observeOn(Schedulers.newThread()) //指定doOnNext执行线程是新线程 .doOnNext(new Action1<String>() { @Override public void call(String name) { /**非阻塞的版本*/ Schedulers.io().createWorker().schedule(new Action0() { @Override public void call() { Log.d(tag, "doOnNext--"+name); try { Thread.sleep(2000); } catch (Exception e) { e.printStackTrace(); } } }); } }) .observeOn(AndroidSchedulers.mainThread())//指定最后观察者在主线程 .subscribe(new Action1<String>() { @Override public void call(String name) { Log.d(tag, "subscribe--"+name); } });
注意:RxJava自带了很多操作符,他们都有自己的用处,这里我就不一一介绍了,具体请参看这篇文章:RxJava 和 RxAndroid 二(操作符的使用)。
RxJava 的适用场景和使用方式
与 Retrofit 的结合
Retrofit 是 Square 的一个著名的网络请求库,没有用过的同学可以先看看这篇博客Android Retrofit框架解析。
Retrofit 除了提供了传统的 Callback 形式的 API,还有 RxJava 版本的 Observable 形式 API。下面我用对比的方式来介绍 Retrofit 的 RxJava 版 API 和传统版本的区别。
除了上面引入的RxJava依赖,还需要添加以下依赖:
compile 'com.squareup.retrofit2:retrofit:2.0.0-beta4' compile 'com.squareup.retrofit2:converter-gson:2.0.0-beta4' compile 'com.squareup.retrofit2:adapter-rxjava:2.0.0-beta4' compile 'com.google.code.gson:gson:2.6.2'
注意不要忘记加网络权限:
<uses-permission android:name="android.permission.INTERNET"/>
(1)Retrofit传统版本
我们使用豆瓣电影的Top250做测试连接,目标地址为
https://api.douban.com/v2/movie/top250?start=0&count=10
我们要创建一个接口取名为MovieService,代码如下:
public interface MovieService { @GET("top250") Call<MovieEntity> getTopMovie(@Query("start") int start, @Query("count") int count);}
来写getMovie方法的代码
/**进行网络请求*/private void getMovie(){ String baseUrl = "https://api.douban.com/v2/movie/"; Retrofit retrofit = new Retrofit.Builder() .baseUrl(baseUrl) .addConverterFactory(GsonConverterFactory.create()) .build(); MovieService movieService = retrofit.create(MovieService.class); Call<MovieEntity> call = movieService.getTopMovie(0, 10); call.enqueue(new Callback<MovieEntity>() { @Override public void onResponse(Call<MovieEntity> call, Response<MovieEntity> response) { resultTV.setText(response.body().toString()); } @Override public void onFailure(Call<MovieEntity> call, Throwable t) { resultTV.setText(t.getMessage()); } });}
以上为没有经过封装的、原生态的Retrofit写网络请求的代码。 我们可以封装创建Retrofit和service部分的代码,然后Activity用创建一个Callback作为参数给Call,这样Activity中只关注请求的结果,而且Call有cancel方法可以取消一个请求。
(2) Retrofit 的 RxJava 版
接下来看看Rxjava是怎么实现的吧。
在创建Retrofit的过程中添加如下代码:
Retrofit retrofit = new Retrofit.Builder() .baseUrl(baseUrl) .addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(RxJavaCallAdapterFactory.create()) .build();
这样一来我们定义的service返回值就不在是一个Call了,而是一个Observable。重新定义MovieService:
public interface MovieService { @GET("top250") Observable<MovieEntity> getTopMovie(@Query("start") int start, @Query("count") int count);}
getMovie方法改为:
//进行网络请求private void getMovie(){ String baseUrl = "https://api.douban.com/v2/movie/"; Retrofit retrofit = new Retrofit.Builder() .baseUrl(baseUrl) .addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(RxJavaCallAdapterFactory.create())//retrofit的初始化加了一行代码 .build(); MovieService movieService = retrofit.create(MovieService.class); movieService.getTopMovie(0, 10) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Subscriber<MovieEntity>() { @Override public void onCompleted() { Toast.makeText(MainActivity.this, "Get Top Movie Completed", Toast.LENGTH_SHORT).show(); } @Override public void onError(Throwable e) { resultTV.setText(e.getMessage()); } @Override public void onNext(MovieEntity movieEntity) { resultTV.setText(movieEntity.toString()); } });}
这样基本上就完成了Retrofit和Rxjava的结合。
有人觉得,这两种方式有啥区别,RxJava的实用性可以从下面例子慢慢体现了出来,逻辑越是复杂,RxJava的优势就越明显。
1)在做项目的时候,往往在登录后得到的并不是用户信息。一般登录后会得到token,然后根据token去获取用户的信息。他们的步骤是这样的:
1、登录
2、获取用户信息(前提:登录成功)
可以看得出来,这是一个嵌套的结构…嵌套啊!!!天呐,最怕嵌套的结构了。
使用RxJava + Retrofit来完成这样的请求:
//登录,获取token@GET("/login")public Observable<String> login( @Query("username") String username, @Query("password") String password);//根据token获取用户信息@GET("/user")public Observable<User> getUser( @Query("token") String token);//..................................service.login("11111", "22222") .flatMap(new Func1<String, Observable<User>>() { //得到token后获取用户信息 @Override public Observable<User> onNext(String token) { return service.getUser(token); }) .subscribeOn(Schedulers.newThread())//请求在新的线程中执行请求 .observeOn(Schedulers.io()) //请求完成后在io线程中执行 .doOnNext(new Action1<User>() { //保存用户信息到本地 @Override public void call(User userInfo) { saveUserInfo(userInfo); } }) .observeOn(AndroidSchedulers.mainThread())//在主线程中执行 .subscribe(new Observer<User>() { @Override public void onNext(User user) { //完成一次完整的登录请求 userView.setUser(user); } @Override public void onCompleted() { } @Override public void onError(Throwable error) { //请求失败 } });
RxBinding
想想你实现过多少次UI监听事件,有OnClickListener, TextChangeListener, 以及其它各种各样的回调事件,但是非常遗憾的是这些回调毫无一致性。一段时间后,你的fragment或者activity中由于各种匿名类而显得十分混乱。
使用RxBinding需要添加依赖:
compile 'com.jakewharton.rxbinding:rxbinding:0.4.0'
Android开发者对button点击事件的常规处理方式:
Button b = (Button)findViewById(R.id.button);b.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { // do some work here } });
使用RxBinding, 你可以以RxJava的形式实现同样的功能:
Button b = (Button)findViewById(R.id.button);Subscription buttonSub = RxView.clicks(b).subscribe(new Action1<Void>() { @Override public void call(Void aVoid) { // do some work here } });// make sure to unsubscribe the subscription
为EditText添加文本改变事件,常规处理方式:
final EditText name = (EditText) v.findViewById(R.id.name);name.addTextChangedListener(new TextWatcher() { @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { } @Override public void onTextChanged(CharSequence s, int start, int before, int count) { // do some work here with the updated text } @Override public void afterTextChanged(Editable s) { }});
用RxBinding实现同样功能是这样子的:
final EditText name = (EditText) v.findViewById(R.id.name);Subscription editTextSub = RxTextView.textChanges(name) .subscribe(new Action1<String>() { @Override //使用RxBinding实现了TextWatcher的onTextChanged方法 public void call(String value) { // do some work with the updated text } });// Make sure to unsubscribe the subscription
使用RxBinding时,你对这些监听事件的可以有一致的实现:RxJava的subscription。
应用:
(1)使用RxBinding之后,你可以使用RxJava operators来对响应的内容进行实时转换。假设你想察看一个EditText输入文字时文本的变化(查看指定类型的数据)。EditText的原始文本类型是CharSequence,而你要获取倒序的String类型的文本,你可以这样:
editTextSub = RxTextView.textChanges(et) .map(new Func1<CharSequence, String>() { @Override public String call(CharSequence charSequence) { return new StringBuilder(charSequence).reverse().toString(); } }) .subscribe(new Action1<String>() { @Override public void call(String value) { text.setText(value); } });
取消注册:
@Override public void onStop() { super.onStop(); editTextSub.unsubscribe(); }
(2)另外一个例子就是用于去抖动,也就是消除手抖导致的快速连环点击:
Subscription buttonSub = RxView.clicks(button7) //屏蔽某次点击后2S内的点击 .throttleFirst(2000, TimeUnit.MILLISECONDS) .subscribe(new Action1<Void>() { @Override public void call(Void aVoid) { Log.d(tag, "click"); } });
RxBus
在之前一篇文章Android EventBus事件总线剖析我介绍了EventBus的使用。最近正在学习Rxjava,如果在项目中已经使用了Rxjava,使用RxBus来代替EventBus应该是不错的选择。
RxBus 名字看起来像一个库,但它并不是一个库,而是一种模式,它的思想是使用 RxJava 来实现了 EventBus。
我这里用RxBus来实现前一篇文章的例子,直接看代码:
public class RxBus { private static RxBus rxBus; private final Subject<Object, Object> _bus = new SerializedSubject<>(PublishSubject.create()); private RxBus() { } public static RxBus getInstance() { if (rxBus == null) { synchronized (RxBus.class) { if (rxBus == null) { rxBus = new RxBus(); } } } return rxBus; } public void send(Object o) { _bus.onNext(o); } public Observable<Object> toObserverable() { return _bus; }}
public class ItemListFragment extends ListFragment { private Subscription rxSubscription; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); //事件的订阅 rxSubscription = RxBus.getInstance().toObserverable() .subscribe(new Action1<Object>() { @Override public void call(Object o) { if (o instanceof ItemListEvent) { ItemListEvent event = (ItemListEvent) o; setListAdapter(new ArrayAdapter<Item>(getActivity(), android.R.layout.simple_list_item_activated_1, android.R.id.text1, event.getItems())); } } }); } @Override public void onDestroy() { super.onDestroy(); //事件的取消 if(!rxSubscription.isUnsubscribed()) { rxSubscription.unsubscribe(); } } @Override public void onViewCreated(View view, Bundle savedInstanceState) { super.onViewCreated(view, savedInstanceState); //开启线程加载列表 new Thread() { public void run() {// try {// Thread.sleep(2000); //模拟延时// } catch (InterruptedException e) {// e.printStackTrace();// } //发布事件,在后台线程发的事件 RxBus.getInstance().send(new ItemListEvent(getItemList())); } }.start(); } private List<Item> getItemList() { List<Item> ITEMS = new ArrayList<Item>(); // Add 6 sample items. ITEMS.add(new Item("1", "Item 1")); ITEMS.add(new Item("2", "Item 2")); ITEMS.add(new Item("3", "Item 3")); ITEMS.add(new Item("4", "Item 4")); ITEMS.add(new Item("5", "Item 5")); ITEMS.add(new Item("6", "Item 6")); return ITEMS; } //左侧列表的点击事件 @Override public void onListItemClick(ListView listView, View view, int position, long id) { super.onListItemClick(listView, view, position, id); //发布事件,在ItemDetailFragment接收 RxBus.getInstance().send(getListView().getItemAtPosition(position)); }}
public class ItemDetailFragment extends Fragment { private TextView tvDetail; private Subscription rxSubscription; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); //事件的订阅 rxSubscription = RxBus.getInstance().toObserverable() .subscribe(new Action1<Object>() { @Override public void call(Object o) { if (o instanceof Item) { Item item = (Item) o; if (item != null) tvDetail.setText(item.content); } } }); } @Override public void onDestroy() { super.onDestroy(); if(!rxSubscription.isUnsubscribed()) { rxSubscription.unsubscribe(); } } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View rootView = inflater.inflate(R.layout.fragment_item_detail, container, false); tvDetail = (TextView) rootView.findViewById(R.id.text); return rootView; }}
RxLifecycle
上面写RxBinding和RxBus时一定要记得在生命周期结束的地方取消订阅事件,防止RxJava可能会引起的内存泄漏问题。缺点是每个acivity/fragment都要重写方法。
我们这里引入一个Rx家族一个新的框架—–RxLifecycle
Activity/Fragment需继承RxAppCompatActivity/RxFragment,目前支持的有RxAppCompatActivity、RxFragment、RxDialogFragment、RxFragmentActivity。
添加依赖:
compile'com.trello:rxlifecycle:0.3.0'compile'com.trello:rxlifecycle-components:0.3.0'
注意:Activity需要继承RxAppCompatActivity,fragment需要继承RxFragment
(1)bindToLifecycle()方法
在子类使用Observable中的compose操作符,调用,完成Observable发布的事件和当前的组件绑定,实现生命周期同步。从而实现当前组件生命周期结束时,自动取消对Observable订阅。
Observable.interval(1, TimeUnit.SECONDS) .compose(this.bindToLifecycle()) .subscribe(new Action1<Long>() { @Override public void call(Long num) { Log.i(TAG, " " +num); } });
(2)bindUntilEvent() 方法
使用ActivityEvent类,其中的CREATE、START、 RESUME、PAUSE、STOP、 DESTROY分别对应生命周期内的方法。使用bindUntilEvent指定在哪个生命周期方法调用时取消订阅。
//发射的内容,每1s发射一条数据 Observable.interval(1, TimeUnit.SECONDS) .doOnUnsubscribe(new Action0() { @Override public void call() { Log.e(tag, "Unsubscribing subscription"); } }) .compose(this.<Long>bindUntilEvent(ActivityEvent.PAUSE)) //pause取消订阅 //订阅subscriber .subscribe(new Action1<Long>() { @Override public void call(Long num) { Log.e(tag, "running until onPause(): " + num); } });
类型说明:
public enum ActivityEvent { CREATE, START, RESUME, PAUSE, STOP, DESTROY}
public enum FragmentEvent { ATTACH, CREATE, CREATE_VIEW, START, RESUME, PAUSE, STOP, DESTROY_VIEW, DESTROY, DETACH}
Demo下载地址
- RxJava的使用详解
- RxJava 的使用详解(一)
- RxJava 使用详解
- Rxjava使用详解
- RxJava使用详解
- RxJava使用详解二
- RxJava使用详解三
- RxJava 2.0 使用详解
- RxJava使用详解
- RxJava 2.0 使用详解
- RxJava 2.0 使用详解
- RxJava Android使用详解
- Rxjava使用详解
- RxJava使用详解
- RXJAVA使用详解
- 【RxJava】给 Android 开发者的 RxJava 详解
- RxJava和RxAndroid使用详解
- Android Retrofit + RxJava使用详解
- 清理 Xcode 文件
- 使用API Blueprint创建API文档
- arm linux下交叉编译valgrind工具进行内存泄露检测和性能分析
- 2017年中兴算法大赛 迪杰特斯拉派
- 七牛云存储android客户端及java服务端代码编写
- RxJava的使用详解
- 防止C++程序重复运行的几种方法
- mysql 常用操作
- Centos 7.2 安装 rabbitmq 3.6.10
- 自定义vue组件发布到npm
- Rviz教程(二):Markers: Sending Basic Shapes (C++)
- SQL Server数据库partition by 与ROW_NUMBER()函数使用详解
- django test 无法正常退出的问题
- Centos 7.2 下安装 jdk 1.8