参考原文:https://blog.csdn.net/sqm8822/article/details/79142458
步骤1:添加Retrofit库的依赖
步骤2:创建 接收服务器返回数据 的类
步骤3:创建 用于描述网络请求 的接口
步骤4:创建 Retrofit 实例
步骤5:创建 网络请求接口实例 并 配置网络请求参数
步骤6:发送网络请求(异步 / 同步)
封装了 数据转换、线程切换的操作
步骤7: 处理服务器返回的数据
RxJava 的本质可以压缩为异步这一个词。说到根上,它就是一个实现异步操作的库,而别的定语都是基于这之上的。
Rx框架的优点,它可以避免回调嵌套,更优雅地切换线程实现异步处理数据。配合一些操作符,可以让处理事件流的代码更加简洁,逻辑更加清晰。
RxJava 的异步实现,是通过一种扩展的观察者模式来实现的。
Schedular是 RxJava 是实现异步至关重要的的一个概念。
基于以上的概念, RxJava 的基本实现主要有三点:
1) 创建 Observer:Observer 即观察者,它决定事件触发的时候将有怎样的行为。 RxJava 中的 Observer
接口的实现方式:
Observer observer=new Observer() {
@Override
public void onCompleted() {
Log.d("xsm", "Item: " + "onCompleted");
}
@Override
public void onError(Throwable e) {
Log.d("xsm", "Item: " + "onError");
}
@Override
public void onNext(Object o) {
Log.d("xsm", "Item: " + o.toString());
}
};
除了 Observer
接口之外,RxJava 还内置了一个实现了 Observer
的抽象类:Subscriber
。 Subscriber
对 Observer
接口进行了一些扩展,但他们的基本使用方式是完全一样的:
/**
* Subscriber:实现了 Observer 的抽象类。Subscriber 对 Observer 接口进行了一些扩展,
* 但他们的基本使用方式是完全一样的:在 RxJava 的 subscribe 过程中,Observer 也总是会先被转换成一个 Subscriber 再使用。
* 只想使用基本功能,选择 Observer 和 Subscriber 是完全一样的。
*
* 它们的区别对于使用者来说主要有两点:
* onStart():这是 Subscriber 增加的方法。它会在 subscribe 刚开始,而事件还未发送之前被调用,可以用于做一些准备工作,
* 例如数据的清零或重置。这是一个可选方法,默认情况下它的实现为空。需要注意的是,如果对准备工作的线程有要求
* (例如弹出一个显示进度的对话框,这必须在主线程执行), onStart() 就不适用了,因为它总是在 subscribe 所发生的线程被调用,
* 而不能指定线程。要在指定的线程来做准备工作,可以使用 doOnSubscribe() 方法,具体可以在后面的文中看到。
* unsubscribe():这是 Subscriber 所实现的另一个接口 Subscription 的方法,用于取消订阅。在这个方法被调用后,
* Subscriber 将不再接收事件。一般在这个方法调用前,可以使用 isUnsubscribed() 先判断一下状态。
* unsubscribe() 这个方法很重要,因为在 subscribe() 之后, Observable 会持有 Subscriber 的引用,
* 这个引用如果不能及时被释放,将有内存泄露的风险。所以最好保持一个原则:要在不再使用的时候尽快在合适的地方
* (例如 onPause() onStop() 等方法中)调用 unsubscribe() 来解除引用关系,以避免内存泄露的发生。
*/
Subscriber subscriber=new Subscriber() {
@Override
public void onCompleted() {
Log.d("xsm", "Item: " + "onCompleted");
}
@Override
public void onError(Throwable e) {
Log.d("xsm", "Item: " + "onError");
}
@Override
public void onNext(Object o) {
Log.d("xsm", "Item: " + o.toString());
}
/**
*这是 Subscriber 增加的方法。它会在 subscribe 刚开始,而事件还未发送之前被调用,可以用于做一些准备工作,
*例如数据的清零或重置。这是一个可选方法,默认情况下它的实现为空。
*/
@Override
public void onStart() {
super.onStart();
}
};
RxJava 2.0引入的Consumer相当于1.0时候的Action。如果只是想简洁的获得处理结果,则可以使用RxJava 2.0引入到的Consumer。
Observer mObserver = new Observer() {
@Override
public void onNext(String s) {
Log.d(TAG, "onNext - Start");
Log.d(TAG, String.valueOf(s));
Log.d(TAG, "onNext - End");
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, e.toString(), e);
}
};
//如果只是接受处理结果,那么可以用Consumer(消费)
Consumer mConsumer = new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "accept - Start");
Log.d(TAG, String.valueOf(s));
Log.d(TAG, "accept - End");
}
};
2) 创建 Observable
Observable 即被观察者,它决定什么时候触发事件以及触发怎样的事件。 RxJava 使用 create()
方法来创建一个 Observable ,并为它定义事件触发规则:
/**
* Observable 即被观察者,它决定什么时候触发事件以及触发怎样的事件。 RxJava 使用 create() 方法来创建一个 Observable ,
* 并为它定义事件触发规则;
* 可以看到,这里传入了一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中,它的作用相当于一个计划表,
* 当 Observable 被订阅的时候,OnSubscribe 的 call() 方法会自动被调用,事件序列就会依照设定依次触发(对于上面的代码,就是观察者Subscriber
* 将会被调用三次 onNext() 和一次 onCompleted())。这样,由被观察者调用了观察者的回调方法,就实现了由被观察者向观察者的事件传递,即观察者模式。
*/
Observable observable=Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber extends String> subscriber) {
subscriber.onNext("Hello");
subscriber.onNext("Hi");
subscriber.onNext("Aloha");
subscriber.onCompleted();
}
});
// create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法, RxJava 还提供了一些方法用来快捷创建事件队列,例如:
// just(T...): 将传入的参数依次发送出来。
Observable observable1=Observable.just("Hello", "Hi", "Aloha");
// from(T[]) / from(Iterable extends T>) : 将传入的数组或 Iterable 拆分成具体对象后,依次发送出来。
String[] str={"Hello", "Hi", "Aloha"};
Observable observable2=Observable.from(str);
// 查看源码你会发现,just和from是实现原理是一样的
3) Subscribe (订阅)
创建了 Observable
和 Observer
之后,再用 subscribe()
方法将它们联结起来,整条链子就可以工作了。代码形式很简单:
3. 线程控制 —— Scheduler (一)
在不指定线程的情况下, RxJava 遵循的是线程不变的原则,即:在哪个线程调用 subscribe(),就在哪个线程生产事件;在哪个线程生产事件,就在哪个线程消费事件。如果需要切换线程,就需要用到 Scheduler (调度器)。
1) Scheduler 的 API (一)
在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。
另外, Android 还有一个专用的 AndroidSchedulers.mainThread(),它指定的操作将在 Android 主线程运行。
有了这几个 Scheduler ,就可以使用 subscribeOn() 和 observeOn() 两个方法来对线程进行控制了。 * subscribeOn(): 指定 subscribe() 所发生的线程,即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。 * observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。
observable.just(1, 2, 3, 4)
.subscribeOn(Schedulers.io()) //指定 subscribe() 所发生的线程,即 Observable.OnSubscribe 被激活时所处的线程。
.observeOn(AndroidSchedulers.mainThread())// observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。
.subscribe(new Action1() {
@Override
public void call(Integer integer) {
}
});
4. 变换
所谓变换,就是将事件序列中的对象或整个序列进行加工处理,转换成不同的事件或事件序列。
map()
: 事件对象的直接变换,具体功能上面已经介绍过。它是 RxJava 最常用的变换。 map()
的示意图:
Observable.just("images/logo.png") // 输入类型 String
.map(new Func1() {
@Override
public Bitmap call(String s) {//参数类型string
return getBitmapFromPath(s);;//返回类型bitmap
}
})
.subscribe(new Action1() {
@Override
public void call(Bitmap bitmap) {
showBitmap(bitmap);
}
});
这段代码中出现的 Action1 。 Action1是 RxJava 的一个接口,有参有返回值;Action0是 RxJava 的一个接口,它只有一个方法 call(),这个方法是无参无返回值的;由于 onCompleted() 方法也是无参无返回值的,因此 Action0 可以被当成一个包装对象,将 onCompleted() 的内容打包起来将自己作为一个参数传入 subscribe() 以实现不完整定义的回调。实际上 RxJava 是提供了多个 ActionX 形式的接口 (例如 Action2, Action3) 的,它们可以被用以包装不同的无返回值的方法。Func1 的类。它和 Action1 非常相似,也是 RxJava 的一个接口,用于包装含有一个参数的方法。 Func1 和 Action 的区别在于, Func1 包装的是有返回值的方法。另外,和 ActionX 一样, FuncX 也有多个,用于不同参数个数的方法。FuncX和 ActionX 的区别在 FuncX 包装的是有返回值的方法。
flatMap()
: 这是一个很有用但非常难理解的变换,因此我决定花多些篇幅来介绍它。 首先假设这么一种需求:假设有一个数据结构『学生』,现在需要打印出一组学生的名字。实现原理:
1. 使用传入的事件对象创建一个 Observable 对象;2. 并不发送这个 Observable, 而是将它激活,于是它开始发送事件;3. 每一个创建出来的 Observable 发送的事件,都被汇入同一个 Observable ,而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。这三个步骤,把事件拆成了两级,通过一组新创建的 Observable 将初始的对象『铺平』之后通过统一路径分发了下去。而这个『铺平』就是 flatMap() 所谓的 flat。
3) compose: 对 Observable 整体的变换
除了 lift()
之外, Observable
还有一个变换方法叫做 compose(Transformer)
。它和 lift()
的区别在于, lift()
是针对事件项和事件序列的,而 compose()
是针对 Observable
自身进行变换。
public class LiftAllTransformer implements Observable.Transformer {
@Override
public Observable call(Observable observable) {
return observable
.lift1()
.lift2()
.lift3()
.lift4();
}
}
Transformer liftAll = new LiftAllTransformer();
observable1.compose(liftAll).subscribe(subscriber1);
5. 线程控制:Scheduler (二)
除了灵活的变换,RxJava 另一个牛逼的地方,就是线程的自由控制。
1) Scheduler 的 API (二):多次切换线程
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() 指定
2) Scheduler 的原理(二)
其实, subscribeOn()
和 observeOn()
的内部实现,也是用的 lift()
。
当使用了多个 subscribeOn()
的时候,只有第一个 subscribeOn()
起作用。在前面讲 Subscriber
的时候,提到过 Subscriber
的 onStart()
可以用作流程开始前的初始化。与 Subscriber.onStart()
相对应的,有一个方法 Observable.doOnSubscribe()
。它和 Subscriber.onStart()
同样是在 subscribe()
调用后而且在事件发送前执行,但区别在于它可以指定线程。默认情况下, doOnSubscribe()
执行在 subscribe()
发生的线程;而如果在 doOnSubscribe()
之后有 subscribeOn()
的话,它将执行在离它最近的 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);