RxJava使用场景整理

Rxjava是什么（异步库、响应式编程）

基于自己的理解简单的下一个定义： RxJava是一个使用Java语言实现基于观察者模式拓展而来的高效异步库。

1.缓存的逻辑处理

取数据时先检查是否有内存缓存，然后再检查是否有文件缓存，再从网络上请求数据，任何一个条件满足则不执行后面的操作，如我们平时去请求图片的逻辑。

Observable<String> memory = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
if (memoryCache != null) {
subscriber.onNext(memoryCache);
} else {
subscriber.onCompleted();
}
}
});
Observable<String> disk = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
String cachePref = rxPreferences.getString("cache").get();
if (!TextUtils.isEmpty(cachePref)) {
subscriber.onNext(cachePref);
} else {
subscriber.onCompleted();
}
}
});

Observable<String> network = Observable.just("network");

//依次检查memory、disk、network
Observable.concat(memory, disk, network)
.first()
.subscribeOn(Schedulers.newThread())
.subscribe(s -> {
memoryCache = "memory";
System.out.println("--------------subscribe: " + s);
});

2.使用merge合并两个数据源

例如一组数据来自网络，一组数据来自文件，需要合并两组数据一起展示

Observable.merge(getDataFromFile(), getDataFromNet())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {
log.d("done loading all data");
}

@Override
public void onError(Throwable e) {
log.d("error");
}

@Override
public void onNext(String data) {
log.d("all merged data will pass here one by one!")
});

3.一个API的请求依赖另一个接口返回的数据（解决嵌套回调的问题）

例如要登录获取到token后再去获取用户详情

NetworkService.getToken("username", "password")
.flatMap(s -> NetworkService.getUserInfo(s))
.subscribe(s -> {
System.out.println("message: " + s);
});

4.每个HTTP请求都带token给服务器 [如果token过期则获取新token]

一般请情况下,很多公司的提api接口, 请求的的时候都需要带有token, 该token在用户第一次启动app或者登陆的时候去获取. 以后的所有请求都需要带该Token

如果token过期, 服务器将返回401, 这时候就需要去请求获取token的接口, 如果获取成功接着在请求原来的接口.

这个时候就两个回调的嵌套了. 实现起来比较费劲, 而且也不够优雅. 代码的可维护性变得很差.

可以使用 onErrorResumeNext 来处理这样的业务逻辑.

5. HTTP 请求重试

当请求网络的时候出现错误, 我们需要重试, 如果不停的重试也没有多大意义, 出现错误延迟多少秒然后重试.

所以使用RxJava可以设置最多重试次数和延迟的时间

6.使用throttleFirst防止按钮重复点击（点击防抖）

debounce也能达到同样的效果

RxView.clicks(button)
.throttleFirst(1, TimeUnit.SECONDS)
.subscribe(new Observer<Object>() {
@Override
public void onCompleted() {
log.d ("completed");
}

@Override
public void onError(Throwable e) {
log.e("error");
}

@Override
public void onNext(Object o) {
log.d("button clicked");
}
});

7.搜索防抖

现在几乎所有的App都有搜索功能 , 一般情况我们监听EditText控件,当值发生改变去请求搜索接口. 这将导致2个问题:

可能导致很多没有意义的请求,耗费用户流量(因为控件的值没更改一次立即就会去请求网络)

可能导致最终的结果不是用户想要的. 例如,用户一开始输入关键字’AB’ 这个时候出现两个请求, 一个请求是A关键字, 一个请求是AB关键字.

表面上是’A’请求先发出去, ‘AB’请求后发出去. 如果后发出去的’AB’请求先返回, ‘A’请求后返回,那么’A’请求后的结果将会覆盖’AB’请求的结果.

从而导致搜索结果不正确.

很多文章说使用 debounce 操作可以解决这个问题.

但是, RxJava也不能完全解决这个问题, 可以使用 debounce 操作符 也只能从一定程度上减少这种情况的出现.

比如: 一开始用户输入了AB两个字符, 在某个时间段内, 用户没有输入新的关键字, 将会发出搜索请求, 此时用户又输入新的关键字C,

那就输入框就是ABC了, 在某个时间段内, 用户没有输入新的关键字, 将会发出搜索新的请求. 如果’ABC’的请求返回比’AB’的快, 那么AB请求的结果将会覆盖’ABC’请求的结果,从而导致不正确的结果

RxTextView.textChangeEvents(inputEditText)
.debounce(400, TimeUnit.MILLISECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<TextViewTextChangeEvent>() {
@Override
public void onCompleted() {
log.d("onComplete");
}

@Override
public void onError(Throwable e) {
log.d("Error");
}

@Override
public void onNext(TextViewTextChangeEvent onTextChangeEvent) {
log.d(format("Searching for %s", onTextChangeEvent.text().toString()));
}
});

8.RxJava代替EventBus广播效果

注意：RxBus并不是一个库，而是一种模式，是使用了RxJava的思想来达到EventBus的广播效果。

9.使用combineLatest合并最近N个结点

例如：注册的时候所有输入信息（邮箱、密码、电话号码等）合法才点亮注册按钮。

Observable<CharSequence> _emailChangeObservable = RxTextView.textChanges(_email).skip(1);
Observable<CharSequence> _passwordChangeObservable = RxTextView.textChanges(_password).skip(1);
Observable<CharSequence>   _numberChangeObservable = RxTextView.textChanges(_number).skip(1);

Observable.combineLatest(_emailChangeObservable,
_passwordChangeObservable,
_numberChangeObservable,
new Func3<CharSequence, CharSequence, CharSequence, Boolean>() {
@Override
public Boolean call(CharSequence newEmail,
CharSequence newPassword,
CharSequence newNumber) {

Log.d("xiayong",newEmail+" "+newPassword+" "+newNumber);
boolean emailValid = !isEmpty(newEmail) &&
EMAIL_ADDRESS.matcher(newEmail).matches();
if (!emailValid) {
_email.setError("Invalid Email!");
}

boolean passValid = !isEmpty(newPassword) && newPassword.length() > 8;
if (!passValid) {
_password.setError("Invalid Password!");
}

boolean numValid = !isEmpty(newNumber);
if (numValid) {
int num = Integer.parseInt(newNumber.toString());
numValid = num > 0 && num <= 100;
}
if (!numValid) {
_number.setError("Invalid Number!");
}

return emailValid && passValid && numValid;

}
})//
.subscribe(new Observer<Boolean>() {
@Override
public void onCompleted() {
log.d("completed");
}

@Override
public void onError(Throwable e) {
log.d("Error");
}

@Override
public void onNext(Boolean formValid) {
_btnValidIndicator.setEnabled(formValid);
}
});

10.使用timer做定时操作。当有“x秒后执行y操作”类似的需求的时候，想到使用timer

例如：2秒后输出日志“hello world”，然后结束。

Observable.timer(2, TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onCompleted() {
log.d ("completed");
}

@Override
public void onError(Throwable e) {
log.e("error");
}

@Override
public void onNext(Long number) {
log.d ("hello world");
}
});

11.使用interval做周期性操作。当有“每隔xx秒后执行yy操作”类似的需求的时候，想到使用interval

例如：每隔2秒输出日志“helloworld”。

Observable.interval(2, TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onCompleted() {
log.d ("completed");
}

@Override
public void onError(Throwable e) {
log.e("error");
}

@Override
public void onNext(Long number) {
log.d ("hello world");
}
});

12.使用schedulePeriodically做轮询请求

Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(final Subscriber<? super String> observer) {

Schedulers.newThread().createWorker()
.schedulePeriodically(new Action0() {
@Override
public void call() {
observer.onNext(doNetworkCallAndGetStringResult());
}
}, INITIAL_DELAY, POLLING_INTERVAL, TimeUnit.MILLISECONDS);
}
}).subscribe(new Action1<String>() {
@Override
public void call(String s) {
log.d("polling….”));
}
})

13.RxJava进行数组、list的遍历，做一些数据变换

Observable.just("1", "2", "2", "3", "4", "5")
.map(Integer::parseInt)
.filter(s -> s > 1)
.distinct()
.take(3)
.reduce((integer, integer2) -> integer.intValue() + integer2.intValue())
.subscribe(System.out::println);//9

14.结合RxJava做网络请求框架,链式调用，逻辑清晰，自由切换线程，解决嵌套回调.

15.响应式的界面

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
RxSharedPreferences rxPreferences = RxSharedPreferences.create(preferences);

Preference<Boolean> checked = rxPreferences.getBoolean("checked", true);

CheckBox checkBox = (CheckBox) findViewById(R.id.cb_test);
RxCompoundButton.checkedChanges(checkBox)
.subscribe(checked.asAction());

参考

http://blog.csdn.net/lzyzsd/article/details/50120801

http://blog.csdn.net/theone10211024/article/details/50435325

http://blog.csdn.net/johnny901114/article/details/51042840

https://github.com/fashare2015/rxjava_for_android