美文网首页
Rxjava---操作符篇---变换操作符

Rxjava---操作符篇---变换操作符

作者: 一期一会la | 来源:发表于2018-08-06 16:44 被阅读13次

    说明

    本文是对
    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 实战系列:优雅实现 网络请求嵌套回调

    相关文章

      网友评论

          本文标题:Rxjava---操作符篇---变换操作符

          本文链接:https://www.haomeiwen.com/subject/qmdgvftx.html