说明
本文是对
Android RxJava操作符详解系列： 变换操作符
Android RxJava 实战系列：优雅实现 网络请求嵌套回调
做一个笔记。
目录
image.png
1.作用
对事件序列中的事件 / 整个事件序列 进行加工处理（即变换），使得其转变成不同的事件 / 整个事件序列
2.类型
常见操作符有：
image.png
3.应用场景&对应操作符介绍
3.1map()
- 作用：对被观察者发送的每一个事件都通过指定的函数处理，从而变成另一种事件。
即被观察者发送的事件转换为任意的类型事件- 应用场景
数据类型转换
// 采用RxJava基于事件流的链式操作
Observable.create(new ObservableOnSubscribe<Integer>() {
// 1. 被观察者发送事件 = 参数为整型 = 1、2、3
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
// 2. 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换：整型变换成字符串类型
}).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "使用 Map变换操作符 将事件" + integer +"的参数从 整型"+integer + " 变换成 字符串类型" + integer ;
}
}).subscribe(new Consumer<String>() {
// 3. 观察者接收事件时，是接收到变换后的事件 = 字符串类型
@Override
public void accept(String s) throws Exception {
Log.d(TAG, s);
}
});
map()将参数中的Integer 类型对象转换成一个String类型 对象后返回
同时，事件的参数类型也由
Integer类型变成了String类型
3.2 FlatMap（）
- 作用：将被观察者发送的事件序列进行 拆分&单独转换，再合并成一个新的事件序列，最后再进行发送。
- 原理:
1.为事件序列中每个事件都创建一个 Observable 对象；
2.将对每个 原始事件 转换后的 新事件 都放入到对应 Observable对象；
3.将新建的每个Observable 都合并到一个 新建的、总的Observable 对象；
4.新建的、总的Observable 对象 将 新合并的事件序列 发送给观察者（Observer）
无序的将被观察者发送的整个事件序列进行变换
// 采用RxJava基于事件流的链式操作
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
// 采用flatMap（）变换操作符
}).flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
final List<String> list = new ArrayList<>();
for (int i = 0; i < 3; i++) {
list.add("我是事件 " + integer + "拆分后的子事件" + i);
// 通过flatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送三个String事件
// 最终合并，再发送给被观察者
}
return Observable.fromIterable(list);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, s);
}
});
image.png
注：新合并生成的事件序列顺序是无序的，即 与旧序列发送事件的顺序无关
3.3 ConcatMap（）
- 作用：类似FlatMap（）操作符
与FlatMap（）的 区别在于：拆分 & 重新合并生成的事件序列 的顺序 = 被观察者旧序列生产的顺序
3.4 Buffer（）
- 作用 :
定期从 被观察者（Obervable）需要发送的事件中 获取一定数量的事件 & 放到缓存区中，最终发送- 应用场景:
缓存被观察者发送的事件
// 被观察者 需要发送5个数字
Observable.just(1, 2, 3, 4, 5)
.buffer(3, 1) // 设置缓存区大小 & 步长
// 缓存区大小 = 每次从被观察者中获取的事件数量
// 步长 = 每次获取新事件的数量
.subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(List<Integer> stringList) {
//
Log.d(TAG, " 缓存区里的事件数量 = " + stringList.size());
for (Integer value : stringList) {
Log.d(TAG, " 事件 = " + value);
}
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应" );
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
image.png
4.实际开发需求案例
- 变换操作符的主要开发需求场景 = 嵌套回调（Callback hell）
- 需要进行嵌套网络请求：即在第1个网络请求成功后，继续再进行一次网络请求
如 先进行 用户注册 的网络请求, 待注册成功后回再继续发送 用户登录 的网络请求
public class MainActivity extends AppCompatActivity {
private static final String TAG = "Rxjava";
// 定义Observable接口类型的网络请求对象
Observable<Translation1> observable1;
Observable<Translation2> observable2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 步骤1：创建Retrofit对象
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://fy.iciba.com/") // 设置 网络请求 Url
.addConverterFactory(GsonConverterFactory.create()) //设置使用Gson解析(记得加入依赖)
.addCallAdapterFactory(RxJava2CallAdapterFactory.create()) // 支持RxJava
.build();
// 步骤2：创建 网络请求接口 的实例
GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);
// 步骤3：采用Observable<...>形式 对 2个网络请求 进行封装
observable1 = request.getCall();
observable2 = request.getCall_2();
observable1.subscribeOn(Schedulers.io()) // （初始被观察者）切换到IO线程进行网络请求1
.observeOn(AndroidSchedulers.mainThread()) // （新观察者）切换到主线程 处理网络请求1的结果
.doOnNext(new Consumer<Translation1>() {
@Override
public void accept(Translation1 result) throws Exception {
Log.d(TAG, "第1次网络请求成功");
result.show();
// 对第1次网络请求返回的结果进行操作 = 显示翻译结果
}
})
.observeOn(Schedulers.io()) // （新被观察者，同时也是新观察者）切换到IO线程去发起登录请求
// 特别注意：因为flatMap是对初始被观察者作变换，所以对于旧被观察者，它是新观察者，所以通过observeOn切换线程
// 但对于初始观察者，它则是新的被观察者
.flatMap(new Function<Translation1, ObservableSource<Translation2>>() { // 作变换，即作嵌套网络请求
@Override
public ObservableSource<Translation2> apply(Translation1 result) throws Exception {
// 将网络请求1转换成网络请求2，即发送网络请求2
return observable2;
}
})
.observeOn(AndroidSchedulers.mainThread()) // （初始观察者）切换到主线程 处理网络请求2的结果
.subscribe(new Consumer<Translation2>() {
@Override
public void accept(Translation2 result) throws Exception {
Log.d(TAG, "第2次网络请求成功");
result.show();
// 对第2次网络请求返回的结果进行操作 = 显示翻译结果
}
}, new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
System.out.println("登录失败");
}
});
}
}
image.png
原文链接：
Android RxJava操作符详解系列： 变换操作符
Android RxJava 实战系列：优雅实现 网络请求嵌套回调
