Rxjava2学习笔记三：RxJava2进阶使用-map操作符

参考链接：
https://www.jianshu.com/p/464fa025229e
Rxjava2学习笔记一：RxJava2基本使用
https://www.jianshu.com/p/cf1dbe7654fc
Rxjava2学习笔记二：RxJava2进阶使用-zip操作符
https://www.jianshu.com/p/ef8b620fdc4c

一.map操作符

• 1.map是Rxjava中的变换操作符,它的作用是对上游发送的每一个事件应用一个函数，使得每一个事件都按照指定的函数变化
  

  Alt text

• 2.map中的函数作用是将圆形事件转换为矩形事件, 从而导致下游接收到的事件就变为了矩形，如下：

    Observable.create(new ObservableOnSubscribe<Integer>() {
                        @Override
                        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                            emitter.onNext(1);
                            emitter.onNext(2);
                            emitter.onNext(3);
                        }
                    }).map(new Function<Integer, String>() {//Integer转换为String
                        @Override
                        public String apply(Integer integer) throws Exception {
                            return "This is result " + integer;
                        }
                    }).subscribe(new Consumer<String>() {
                        @Override
                        public void accept(String s) throws Exception {
                            Log.d(TAG, s);
                        }
                    });
  

  上游我们发送的是数字类型，下游接受的是String类型，中间起转换作用的就是map操作符(上游发来的事件转换为任意的类型)。
  运行结果：
  D/TAG: This is result 1
  D/TAG: This is result 2
  D/TAG: This is result 3

FlatMap

• 1.FlatMap将一个发送事件的上游Observable变换为多个发送事件的Observables，然后将它们发射的事件合并后放进一个单独的Observable里,注：concatMap和FlatMap一样的作用，只是contactMap是有序的，FlatMap是无序的
  

  Alt text
  上游发送了三个事件, 分别是1,2,3, 注意它们的颜色
  中间flatMap的作用是将圆形的事件转换为一个发送矩形事件和三角形事件的新的上游Observable
  eg:

    Observable.create(new ObservableOnSubscribe<Integer>() {
                @Override
                public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                    emitter.onNext(1);
                    emitter.onNext(2);
                    emitter.onNext(3);
                }
            }).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("I am value " + integer);
                    }
                    return Observable.fromIterable(list).delay(10,TimeUnit.MILLISECONDS);
                }
            }).subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    Log.d(TAG, s);
                }
            });  
  

打印结果：

    D/TAG: I am value 1  
    D/TAG: I am value 1  
    D/TAG: I am value 1  
    D/TAG: I am value 3  
    D/TAG: I am value 3 
    D/TAG: I am value 3  
    D/TAG: I am value 2  
    D/TAG: I am value 2  
    D/TAG: I am value 2  

实际使用场景

• 1.需求：嵌套的网络请求, 首先需要去请求注册, 待注册成功回调了再去请求登录的接口

• 2.实现
  接口-

    public interface Api {
        @GET
        Observable<LoginResponse> login(@Body LoginRequest request);
    
        @GET
        Observable<RegisterResponse> register(@Body RegisterRequest request);
    }  
  

  网络请求-

      api.register(new RegisterRequest())            //发起注册请求
                    .subscribeOn(Schedulers.io())               //在IO线程进行网络请求
                    .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求注册结果
                    .doOnNext(new Consumer<RegisterResponse>() {
                        @Override
                        public void accept(RegisterResponse registerResponse) throws Exception {
                            //先根据注册的响应结果去做一些操作
                        }
                    })
                    .observeOn(Schedulers.io())                 //回到IO线程去发起登录请求
                    .flatMap(new Function<RegisterResponse, ObservableSource<LoginResponse>>() {
                        @Override
                        public ObservableSource<LoginResponse> apply(RegisterResponse registerResponse) throws Exception {
                            return api.login(new LoginRequest());//发起登陆请求
                        }
                    })
                    .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求登录的结果
                    .subscribe(new Consumer<LoginResponse>() {
                        @Override
                        public void accept(LoginResponse loginResponse) throws Exception {
                            Toast.makeText(MainActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
                        }
                    }, new Consumer<Throwable>() {
                        @Override
                        public void accept(Throwable throwable) throws Exception {
                            Toast.makeText(MainActivity.this, "登录失败", Toast.LENGTH_SHORT).show();
                        }
                    });