Rxjava

zoukankan html css js c++ java

Rxjava
从开始最开始学习RxJava到现在也有一段时间了，还记得去年第一次看RxJava的文章就是扔物线的的这篇文章给 Android 开发者的 RxJava 详解，那一次我看了整整一个下午，由于在那之前我完全没接触过RxJava，也不知道那是个什么，看完很多地方都还不是很理解，整个人都是晕晕的，当然收获也还是有的，至少对RxJava有了一个初步的概念。那次之后我就没再去碰过RxJava了，当时心里想的是，如果后面需要这方面的东西我再来学习也不迟。
时间差不多过了半年，RxJava也越来越火了，使用RxJava的开发者也是越来越多，github上关于的开源库中使用RxJava的也越来越多。当我再去看一些开源库的时候，由于很多地方都用到了RxJava，就发现很多代码都看不懂了，这也就激起了再次去学习RxJava的动力，随后就在网上各种的查找RxJava相关的学习资料，从头学习，我又去看了一遍给 Android 开发者的 RxJava 详解，收获还是很多的，本文也是对这段时间我学习RxJava的一个小结，以下知识点主要针对于Android开发者。

本文的学习目录

1.RxJava是什么
2.在Android中怎么去使用RxJava
3.RxJava操作符的介绍
4.RxJava在生产环境中的使用
5.RxJava学习的参考资料

1.RxJava是什么

要知道RxJava是什么，那么你应该先去了解一下Rx。Rx的全称是Reactive Extensions，直译过来就是响应式扩展。Rx基于观察者模式，他是一种编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流。ReactiveX.io给的定义是，Rx是一个使用可观察数据流进行异步编程的编程接口，ReactiveX结合了观察者模式、迭代器模式和函数式编程的精华。Rx已经渗透到了各个语言中，有了Rx所以才有了 RxJava，Rx.NET、RxJS、RxSwift、Rx.rb、RxPHP等等，更详细的可以去这里看看languages

那么RxJava到底是什么，我对于他的理解就针对于Java语言的一个异步的响应式编程库。

2.怎么去使用RxJava

在gradle文件的dependencies中加入以下代码即可（以下版本可能不是最新的，需要最新的可到RxAndroid查看）
```
  compile 'io.reactivex:rxandroid:1.2.0'
  compile 'io.reactivex:rxjava:1.1.5'
```
3.RxJava操作符的介绍

有了以上的配置，我们就可以在Android中使用RxJava了。对于RxJava的使用，最重要的还是对于操作符的学习，熟悉了操作符才能更好的使用RxJava。RxJava中的操作符是非常丰富的，关于RxJava操作符介绍的文章已经是属于一搜就是一大堆的那种了，所以本文就不多做介绍了，在这里给大家推荐一个学习操作符比较好的地方Operaters

4.RxJava在生产环境中的使用

想必学习RxJava的同学，在学习完操作符之后，最想知道的是怎么将其用在我们平时的开发当中去，本节就带大家去了解一下怎么去应用RxJava。

RxBinding
节流(防止按钮的重复点击)
轮询，定时操作
RxPermissions
RxBus
RxJava与Retrofit
等待你们的补充~~~

(1) RxBinding

RxBinding是JakeWharton大牛用RxJava为Android控件编写的一个控件绑定库，并且为各个包下的控件都编写相应的库，如下所示
```
Platform bindings:
compile 'com.jakewharton.rxbinding:rxbinding:0.4.0'

'support-v4' library bindings:
compile 'com.jakewharton.rxbinding:rxbinding-support-v4:0.4.0'

'appcompat-v7' library bindings:
compile 'com.jakewharton.rxbinding:rxbinding-appcompat-v7:0.4.0'

'design' library bindings:
compile 'com.jakewharton.rxbinding:rxbinding-design:0.4.0'

'recyclerview-v7' library bindings:
compile 'com.jakewharton.rxbinding:rxbinding-recyclerview-v7:0.4.0'

'leanback-v17' library bindings:
compile 'com.jakewharton.rxbinding:rxbinding-leanback-v17:0.4.0'
```
我们只需引入对应地库就可以使用了。

比如我们对Button添加一个单击事件就可以这样做了
```
  Button button = (Button) findViewById(R.id.button);

        RxView.clicks(button).subscribe(new Action1<Void>() {
            @Override
            public void call(Void aVoid) {
              Log.i("test", "clicked");
            }
        });
```
到这里，你肯定会说，这并没有没什么卵用，还不如直接设置一个setOnClickListener来的方便，直接。继续往下看

通常情况下，如果我们要防止一个按钮重复点击会怎么做？设置一个第一次按下的时间，然后在第二次点击的时候去判断？NO NO NO，这样做都太low了，我们来看看用RxBing怎样去实现
```
RxView.clicks(button).debounce(300, TimeUnit.MILLISECONDS).subscribe(new Action1<Void>() {
            @Override
            public void call(Void aVoid) {
                Log.i("test", "clicked");
            }
        });
```
很爽吧，这里过滤掉了在300ms内的重复点击，只需加一个操作符就可以了，而不用我们去编写一大堆并且还容易出错的逻辑代码了。

这里使用最多的一个地方就是在我们做搜索的时候，再结合filter操作，去过滤掉那些没必要的查询操作，来减小服务器的压力和客户端的流量输出。

(2) 轮询，定时操作
在做App的时候，有些地方我们可能会时不时的去请求服务器，以至于客户端的数据是最新的，在RxJava中可以这样做
```
   //每隔两秒执行一次
   Observable.interval(2, 2, TimeUnit.SECONDS).subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                //TODO WHAT YOU WANT
            }
        });
```
在两秒后去执行一些操作（比如启动页跳转到主页面）
```
 Observable.timer(2, TimeUnit.SECONDS).subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                //TODO WHAT YOU WANT
            }
        });
```
(3) RxPermissions
RxPermissions也是国外的大牛开发的基于RxJava的Android权限管理库，他让6.0以上的权限管理更加的简单，如果有适配6.0以上的手机的需求，这个库是个不错的选择。下面我们来看看基本的用法。
```
   // 请求相机权限
    RxPermissions.getInstance(this)
    .request(Manifest.permission.CAMERA)
    .subscribe(granted -> {
        if (granted) { // 用户同意了（在6.0之前的手机始终都为true）
          //可以拍照了
        } else {
           //可以在这里提示用户，或者再次请求
        }
    });
```
当然，如果我想一次请求多个权限呢，每次都去写上面的代码肯定是个不好的做法，RxPermissions的作者也考虑到了这一点，在Api里提供了一个多参数的重载
```
//取得相机权限和读取手机状态
RxPermissions.getInstance(this)
    .request(Manifest.permission.CAMERA,
             Manifest.permission.READ_PHONE_STATE)
    .subscribe(granted -> {
        if (granted) {

        } else {

        }
    });
```
更多的资料还请去github上去查看。
(4) RxBus
有了RxJava，EventBus、Otto什么的都可以靠边了，因为RxJava本身就自带了这个功能，我们只需做一下简单的封装就可以使用了，也顺便减少了我们项目的体积。
```
public class RxBus {

    private final Subject<Object, Object> _bus;

    private static class RxBusHolder {
        private static final RxBus instance = new RxBus();
    }

    private RxBus() {
        _bus = new SerializedSubject<>(PublishSubject.create());
    }

    public static synchronized RxBus getInstance() {
        return RxBusHolder.instance;
    }

    public void post(Object o) {
        _bus.onNext(o);
    }

    public <T> Observable<T> toObserverable(Class<T> eventType) {
        return _bus.ofType(eventType);
}
```
怎么去使用？
在需要发送消息的地方
```
RxBus.getInstance().post("SomeChange");
```
在需要接收消息的地方
```
 Subscription mSubscription = RxBus.getInstance().toObserverable(String.class).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                handleRxMsg(s);
            }
});
```
不要忘了在适当的地方去取消这个订阅（以免发生内存泄漏）
```
mSubscription.unsubscribe();
```
到这里可能你有个疑问，Subject是个什么鬼！
其实Subject同时充当了Observer和Observable的角色，他可以发射数据也可以接收数据，有AsyncSubject、BehaviorSubject、PublishSubject、ReplaySubject四种，详细的介绍请看Subject

(5) RxJava与Retrofit

Retrofit可能大家都不太陌生了，如果你还不知道的话，那么赶紧去学习吧，这么强大的框架怎么能不知道呢！

后面的讲解是基于了解过Retrofit的同学

关于Retrofit的基本使用可能我们都不是太陌生，对于请求后的结果都是在一个回调接口里接收，对于结果的处理并不是太灵活，一大堆的回调会让你以后回过来看代码的时候看的醉生梦死。
RxJava很好的解决了这个问题，我们来看看Retrofit的怎么去适配RxJava吧。

gradle文件的引用
```
compile 'com.squareup.retrofit2:retrofit:2.0.2'
compile 'com.squareup.retrofit2:converter-gson:2.0.2'
compile 'com.squareup.retrofit2:adapter-rxjava:2.0.2'//RxJava与Retrofit的适配器
```
这里我以请求 http://gank.io/api/data/Android/10/1 为例。

返回的结果大致是这样的

于是我定义了一个GankResultBean去接收这个结果。

其中ResultsBean就是results中的每一个条目。
好了，下面我们来看看适配了RxJava的Retrofit怎么去使用吧
首先我们定义一个接口
```
 public interface RxGankService {
        @GET("all/20/{page}")
        Observable<GankResultBean> getAndroidData(@Path("page") int page);
    }
```
值得注意的是这里返回的是Observable<GankResultBean>而不是常规的 Call<GankResultBean>

接着就可以做请求了
```
 Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://gank.io/api/data/")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())//这个就是用来适配RxJava的
                .build();

RxGankService rxGankService = retrofit.create(RxGankService.class);
        final Observable<GankResultBean> observable = rxGankService.getAndroidData(1);
        observable
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Func1<GankResultBean, List<GankResultBean.ResultsBean>>() {
                    @Override
                    public List<GankResultBean.ResultsBean> call(GankResultBean gankResultBean) {
                        return gankResultBean.getResults();
                    }
                })
                .flatMap(new Func1<List<GankResultBean.ResultsBean>, Observable<GankResultBean.ResultsBean>>() {
                    @Override
                    public Observable<GankResultBean.ResultsBean> call(List<GankResultBean.ResultsBean> resultsBeen) {
                        return Observable.from(resultsBeen);
                    }
                })
                .filter(new Func1<GankResultBean.ResultsBean, Boolean>() {
                    @Override
                    public Boolean call(GankResultBean.ResultsBean resultsBean) {
                        return "Android".equals(resultsBean.getType());
                    }
                })
                .subscribe(new Subscriber<GankResultBean.ResultsBean>() {
                    @Override
                    public void onCompleted() {
                        Log.i("test", "onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        e.printStackTrace();
                    }

                    @Override
                    public void onNext(GankResultBean.ResultsBean resultsBean) {
                        textView.append(resultsBean + "
");
                    }
                });
```
这里是为了演示才使用了这么多的操作符，在实际使用的时候根据具体情况而定。
下面简单解释下上面这段代码
observeOn(AndroidSchedulers.mainThread())：订阅者的回调在主线程
subscribeOn(Schedulers.io())：订阅发生在io线程
map:一般我们不会关心error字段，我们关心的只是results，所以在这里做了一个映射让用户接收的是List<GankResultBean.ResultsBean>而不是包含有error的GankResultBean
flatMap:让结果一条一条的发射出去，而不是一个集合
filter：只接收Type为Android的数据

以上的例子用流的方式是不是很好的解决了对请求结果的处理，对结果的处理可以做到随心所欲，并且逻辑还很清晰。

以上几个点就是我了解的关于RxJava的应用。如果你还有其他方面的应用，还望补充。

5.RxJava学习的参考资料

这里我将我学习RxJava以来收集的关于RxJava分享出来，以方便大家的查阅。

学习RxJava的第一手资料,官方的wiki:wiki
我学习RxJava看的第一篇文章：给 Android 开发者的 RxJava 详解(这个大家肯定都知道)
大头鬼总结的RxJava学习资料：Awesome-RxJava
RxJava文档中文翻译：Rx和RxJava文档中文翻译项目

其他：
RxJava操作符图解（需科学上网）
RxJava处理网络连接失败和timer()、interval()、delay()之间的区别
 Architecting Android with RxJava
使用RxJava 提升用户体验
 用RxJava实现事件总线(Event Bus)
Intro to Rx
Implementing an Event Bus With RxJava - RxBus
可能是东半球最全的RxJava使用场景小结
 RxWeekend——RxJava周末狂欢

最后：为了跟上时代的步伐，是时候学习RxJava了
操作符分类

ReactiveX的每种编程语言的实现都实现了一组操作符的集合。不同的实现之间有很多重叠的部分，也有一些操作符只存在特定的实现中。每种实现都倾向于用那种编程语言中他们熟悉的上下文中相似的方法给这些操作符命名。

本文首先会给出ReactiveX的核心操作符列表和对应的文档链接，后面还有一个决策树用于帮助你根据具体的场景选择合适的操作符。最后有一个语言特定实现的按字母排序的操作符列表。

如果你想实现你自己的操作符，可以参考这里：实现自定义操作符

创建操作

用于创建Observable的操作符

Create — 通过调用观察者的方法从头创建一个Observable

Defer — 在观察者订阅之前不创建这个Observable，为每一个观察者创建一个新的Observable

Empty/Never/Throw — 创建行为受限的特殊Observable

From — 将其它的对象或数据结构转换为Observable

Interval — 创建一个定时发射整数序列的Observable

Just — 将对象或者对象集合转换为一个会发射这些对象的Observable

Range — 创建发射指定范围的整数序列的Observable

Repeat — 创建重复发射特定的数据或数据序列的Observable

Start — 创建发射一个函数的返回值的Observable

Timer — 创建在一个指定的延迟之后发射单个数据的Observable

变换操作

这些操作符可用于对Observable发射的数据进行变换，详细解释可以看每个操作符的文档

Buffer — 缓存，可以简单的理解为缓存，它定期从Observable收集数据到一个集合，然后把这些数据集合打包发射，而不是一次发射一个

FlatMap — 扁平映射，将Observable发射的数据变换为Observables集合，然后将这些Observable发射的数据平坦化的放进一个单独的Observable，可以认为是一个将嵌套的数据结构展开的过程。

GroupBy — 分组，将原来的Observable分拆为Observable集合，将原始Observable发射的数据按Key分组，每一个Observable发射一组不同的数据

Map — 映射，通过对序列的每一项都应用一个函数变换Observable发射的数据，实质是对序列中的每一项执行一个函数，函数的参数就是这个数据项

Scan — 扫描，对Observable发射的每一项数据应用一个函数，然后按顺序依次发射这些值

Window — 窗口，定期将来自Observable的数据分拆成一些Observable窗口，然后发射这些窗口，而不是每次发射一项。类似于Buffer，但Buffer发射的是数据，Window发射的是Observable，每一个Observable发射原始Observable的数据的一个子集

过滤操作

这些操作符用于从Observable发射的数据中进行选择

Debounce — 只有在空闲了一段时间后才发射数据，通俗的说，就是如果一段时间没有操作，就执行一次操作

Distinct — 去重，过滤掉重复数据项

ElementAt — 取值，取特定位置的数据项

Filter — 过滤，过滤掉没有通过谓词测试的数据项，只发射通过测试的

First — 首项，只发射满足条件的第一条数据

IgnoreElements — 忽略所有的数据，只保留终止通知(onError或onCompleted)

Last — 末项，只发射最后一条数据

Sample — 取样，定期发射最新的数据，等于是数据抽样，有的实现里叫ThrottleFirst

Skip — 跳过前面的若干项数据

SkipLast — 跳过后面的若干项数据

Take — 只保留前面的若干项数据

TakeLast — 只保留后面的若干项数据

组合操作

组合操作符用于将多个Observable组合成一个单一的Observable

And/Then/When — 通过模式(And条件)和计划(Then次序)组合两个或多个Observable发射的数据集

CombineLatest — 当两个Observables中的任何一个发射了一个数据时，通过一个指定的函数组合每个Observable发射的最新数据（一共两个数据），然后发射这个函数的结果

Join — 无论何时，如果一个Observable发射了一个数据项，只要在另一个Observable发射的数据项定义的时间窗口内，就将两个Observable发射的数据合并发射

Merge — 将两个Observable发射的数据组合并成一个

StartWith — 在发射原来的Observable的数据序列之前，先发射一个指定的数据序列或数据项

Switch — 将一个发射Observable序列的Observable转换为这样一个Observable：它逐个发射那些Observable最近发射的数据

Zip — 打包，使用一个指定的函数将多个Observable发射的数据组合在一起，然后将这个函数的结果作为单项数据发射

错误处理

这些操作符用于从错误通知中恢复

Catch — 捕获，继续序列操作，将错误替换为正常的数据，从onError通知中恢复

Retry — 重试，如果Observable发射了一个错误通知，重新订阅它，期待它正常终止

辅助操作

一组用于处理Observable的操作符

Delay — 延迟一段时间发射结果数据

Do — 注册一个动作占用一些Observable的生命周期事件，相当于Mock某个操作

Materialize/Dematerialize — 将发射的数据和通知都当做数据发射，或者反过来

ObserveOn — 指定观察者观察Observable的调度程序（工作线程）

Serialize — 强制Observable按次序发射数据并且功能是有效的

Subscribe — 收到Observable发射的数据和通知后执行的操作

SubscribeOn — 指定Observable应该在哪个调度程序上执行

TimeInterval — 将一个Observable转换为发射两个数据之间所耗费时间的Observable

Timeout — 添加超时机制，如果过了指定的一段时间没有发射数据，就发射一个错误通知

Timestamp — 给Observable发射的每个数据项添加一个时间戳

Using — 创建一个只在Observable的生命周期内存在的一次性资源

条件和布尔操作

这些操作符可用于单个或多个数据项，也可用于Observable

All — 判断Observable发射的所有的数据项是否都满足某个条件

Amb — 给定多个Observable，只让第一个发射数据的Observable发射全部数据

Contains — 判断Observable是否会发射一个指定的数据项

DefaultIfEmpty — 发射来自原始Observable的数据，如果原始Observable没有发射数据，就发射一个默认数据

SequenceEqual — 判断两个Observable是否按相同的数据序列

SkipUntil — 丢弃原始Observable发射的数据，直到第二个Observable发射了一个数据，然后发射原始Observable的剩余数据

SkipWhile — 丢弃原始Observable发射的数据，直到一个特定的条件为假，然后发射原始Observable剩余的数据

TakeUntil — 发射来自原始Observable的数据，直到第二个Observable发射了一个数据或一个通知

TakeWhile — 发射原始Observable的数据，直到一个特定的条件为真，然后跳过剩余的数据

算术和聚合操作

这些操作符可用于整个数据序列

Average — 计算Observable发射的数据序列的平均值，然后发射这个结果

Concat — 不交错的连接多个Observable的数据

Count — 计算Observable发射的数据个数，然后发射这个结果

Max — 计算并发射数据序列的最大值

Min — 计算并发射数据序列的最小值

Reduce — 按顺序对数据序列的每一个应用某个函数，然后返回这个值

Sum — 计算并发射数据序列的和

连接操作

一些有精确可控的订阅行为的特殊Observable

Connect — 指示一个可连接的Observable开始发射数据给订阅者

Publish — 将一个普通的Observable转换为可连接的

RefCount — 使一个可连接的Observable表现得像一个普通的Observable

Replay — 确保所有的观察者收到同样的数据序列，即使他们在Observable开始发射数据之后才订阅

转换操作

To — 将Observable转换为其它的对象或数据结构

Blocking 阻塞Observable的操作符

操作符决策树

几种主要的需求

直接创建一个Observable（创建操作）

组合多个Observable（组合操作）

对Observable发射的数据执行变换操作（变换操作）

从Observable发射的数据中取特定的值（过滤操作）

转发Observable的部分值（条件/布尔/过滤操作）

对Observable发射的数据序列求值（算术/聚合操作）
查看全文

相关阅读:
【JZOJ5603】【NOI2018模拟3.27】Xjz
【JZOJ5605】【NOI2018模拟3.26】Arg
【agc004e】Salvage Robots
【agc004c】AND Grid
【agc004d】Teleporter
【agc002f】Leftmost Ball
【agc002d】Stamp Rally
【arc068F】Solitaire
51nod 1172 Partial Sums V2
快速数论变换NTT模板

原文地址：https://www.cnblogs.com/GeChuangGuang/p/5593076.html

本文的学习目录

1.RxJava是什么

2.怎么去使用RxJava

3.RxJava操作符的介绍

4.RxJava在生产环境中的使用

5.RxJava学习的参考资料

操作符分类

创建操作

变换操作

过滤操作

组合操作

错误处理

辅助操作

条件和布尔操作

算术和聚合操作

连接操作

转换操作

操作符决策树