Rx_java（5）Rx_java2操作符(Map、Flatmap)介绍-登录并获取用户信息小案例

相关文章

• 观察者模式实例讲解
• 使用java中的类（Observable与Observer）实现观察者模式
• Rx_java2的基本使用
• Rx_java2中的线程控制
• Rx_java2操作符介绍2(debounce 、filter 、switchMap )
• Rx_java2操作符介绍3（throttleFirst、debounce ）
• Retrofit结合RxJava2使用

写在前面

Rxjava中有很多操作符，这里不会全部都讲，可以在RxJava中文文档中自己去看所有的操作符。

Map操作符

下面是RxJava中文文档中对于Map操作符的介绍。

下面以一个简单的例子来说明map操作符：
下面的代码功能就是在Observable中传入一个int类型的数字，通过map操作，转换为String类型。
首先通过just创建一个Observable对象，并且传入一个int类型的数字。
然后通过map来转换，在代码注释中已经写的很明白了。

 Observable<String> mapObservable = Observable
                // 通过just创建Observable对象（还可以通过create/from等创建）
                .just(1)
                // function对象中第一个参数为input参数，第二个参数为output参数
                .map(new Function<Integer, String>() {
            @Override
            public String apply(@NonNull Integer integer) throws Exception {
                // 通过mapFunction功能方法转化成我们需要类型
                return mapFunction(integer);
            }
        });


//******执行转换的功能函数

 public String mapFunction(Integer integer){
        return integer + "";
    }

其实map操作符，就是一个转换机器，就想工厂加工火腿肠一样，这头进去的是猪，在转换机器的加工后，那头出来的是火腿肠，而这个转换方法具体的操作，由你自己定。

flatMap操作符

下面先贴出RxJava中文文档中flatMap的部分介绍（请在文档中自己查看全部详细介绍）

实例-登陆获取用户信息（flatMap的使用）

首相，我们创建一个UserParam类，里面有俩个参数，就是我们登陆需要的用户名和密码。

本Markdown编辑器使用[StackEdit][6]修改而来，用它写博客，将会带来全新的体验哦：

/**
 * description: 
 * author: dujun
 * created at: 2018/1/4 14:37 
 * update: 2018/1/4
 * version: 
 */
public class UserParam {

    public String username;
    public String password;

    public UserParam(String username, String password) {
        this.username = username;
        this.password = password;
    }
}

然后创建登陆成功json所对应的对象，登陆成功后，服务器返回的json为

{success:200,message:"登录成功",user_id:101}

联网获取json的方法这里仿造一个，就是传入UserParam(里面有用户名和密码)。，然后从网络获取json。

public static String login(UserParam userParam ){
        return "{success:1,message:\"登录成功\",user_id:101}";
    }

然后把这个json转换为一个对象，所以先创建这个对象的模型为：

/**
 * description:
 * author: dujun
 * created at: 2018/1/4 14:43 
 * update: 2018/1/4
 * version: 
 */
public class BaseResult {

    public int success;
    public String message;
    public int user_id;
}

我们现在执行登录代码，全过程为传入用户名和密码(UserParam)，返回登录结果信息的对象（BaseResult）

 Observable<BaseResult> resultObservable = Observable.just(getUserParam()).flatMap(new Function<UserParam, ObservableSource<BaseResult>>() {
            @Override
            public ObservableSource<BaseResult> apply(@NonNull UserParam userParam) throws Exception {
                // 登录，并返回json登录结果信息
                String json = HttpUtils.login(userParam);

                // 把json数据转化为对象
                Gson gson = new Gson();
                BaseResult baseResult = gson.fromJson(json, BaseResult.class);
                return Observable.just(baseResult);
            }
        });

此时，我们获取到Observable，直接绑定一个Observer接受BaseResult对象即可，
但是，我们此时只是获取到了登录结果。获取到了user_id，我们还需要通过user_id去获取用户信息。
我们看到在flatMap的apply方法中，返回的是一个ObservableSource对象，也就是说，flatMap又一次返回了一个发射数据的Observable，这也是flatMap和map最大的区别，flapMap可以连续返回发射数据的Observable，
所以我们继续用flatMapcao操作符去获取用户信息

我们看看获取用户信息方法：

   /**
     *
     * @param userId 用户id
     * @return 用户信息json
     */
    public static String getUserInfo(int userId){
        return "{head_url:\"www\",username:\"对面五只狗\",id:\"101\"}";
    }

让后继续创建用户信息模型

/**
 * description: 
 * author: dujun
 * created at: 2018/1/4 15:21 
 * update: 2018/1/4
 * version: 
 */
public class User {


    public String head_url;
    public String id;
    public String username;

    public User(String head_url, String id, String username) {
        this.head_url = head_url;
        this.id = id;
        this.username = username;
    }
}

接下的过程就是传入BaseResult(包含用户id)最后获取到用户信息的模型的过程。

下面代码是一个完整的通过俩个flatMap变化最终获取Obervable的过程。

Observable<User> userObservable = Observable
                .just(getUserParam())
                .flatMap(new Function<UserParam, ObservableSource<BaseResult>>() {
                    @Override
                    public ObservableSource<BaseResult> apply(@NonNull UserParam userParam) throws Exception {
                        // 登录，并返回json登录结果信息
                        String json = HttpUtils.login(userParam);

                        Gson gson = new Gson();
                        BaseResult baseResult = gson.fromJson(json, BaseResult.class);
                        return Observable.just(baseResult);
                    }
                })

                // 继续调用flatMap转换

                .flatMap(new Function<BaseResult, ObservableSource<User>>() {
                    @Override
                    public ObservableSource<User> apply(@NonNull BaseResult baseResult) throws Exception {
                        // 获取用户信息
                        String json = HttpUtils.getUserInfo(baseResult.user_id);
                        // 把json转换为User对象的过程
                        Gson gson = new Gson();
                        User user = gson.fromJson(json, User.class);

                        // 返回Observable对象，发送User
                        return Observable.just(user);
                    }
                });

以上过程，进过俩个flatMap操作符的转换，最终的结果返回了一个 Observable对象，然后创建Observer绑定即可

userObservable.subscribe(new Observer<User>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull User user) {
                // 获取到User实例对象
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

写在后面

本篇文章中讲解了Rxjava中map和flatMap操作符的使用，下篇将继续讲解操作符，操作符有太多，要想详细了解，请看RxJava中文文档