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 {
//
4000
通过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中文文档