RxJava学习一：初识

首先介绍 Github地址：RxJava 、RxAndroid 

引入依赖： 
compile 'io.reactivex:rxjava:x.y.z' 
compile 'io.reactivex:rxandroid:x.y.z' 

（版本号是文章发布时的最新稳定版）

部分内容参考：http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

顺便提几个demo参考：MovieGuide、RxVolley、CaMnter / EasyGank、一个用于学习RxJava操作符的APP

      Rxjava在android开发中越来越火，观看各位大神的介绍，自己加以学习和整理。刚接触时就被其强大的功能吸引住了；错过了就要再等一万年了啪啪啪啪啪！！

github官方文档介绍“a library for composing asynchronous and event-based programs using observable sequences for the Java VM”（译：在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）；激情的发现这不是我们日常开发中所需要处理的棘手问题吗！

RxJava核心零部件为Observables（被观察者，事件源）和Subscribers（观察者）。Observables发出一系列事件，Subscribers处理这些事件。而所谓的事件可以理解为你所需要处理的事件，比如：click、event等等。此时你可以结合设计模式中的观察者模式，但是有一点不同，那就是如果一个Observerble没有任何的的Subscriber，那么这个Observable是不会发出任何事件的，而且rxjava更为强大之处在于“异步”，简洁、低调而奢华。

一个 Observable 可以有多个 Subscribers，并且通过 Observable 发出的每一个 item，该 item 将会被发送到 Subscriber.onNext() 方法来进行处理。一旦 Observable 不再发出 items，它将会调用 Subscriber.onCompleted() 方法，或如果有一个出错的话 Observable 会调用 Subscriber.onError() 方法。

现在，我们知道了很多关于 Observable 和 Subscriber 类，我们可以继续去介绍有关 Observables 的创建和订阅。

Observable<List<String>> stringObservable = Observable.create(new Observable.OnSubscribe() {   @Override   public void call(Subscriber subscriber) {   subscriber.onNext(listDatas.get(0));   subscriber.onNext(listDatas.get(1));   subscriber.onNext(listDatas.get(2));//连续发出三组数据   subscriber.onCompleted();   }});  

创建一个 Subscriber，响应这些发出的数据流。

Subscriber stringSubscriber = new Subscriber() {   @Override   public void onCompleted() {   System.out.println("Complete!");   }   @Override   public void onError(Throwable e) {   }   @Override   public void onNext(List<String> value) {   System.out.println("onNext: " + value);   }};  

stringObservable.subscribe(stringSubscriber);//最后调用此方法建立连接

我们的 Subscriber 只是简单的把任何发出的 items 打印出来，完成之后通知我们。一旦你有一个 Observable 和一个 Subscriber，可以通过 Observable.subscribe() 方法将他们联系起来。

上面所有这些代码可以简单的通过使用 Observable.just() 方法来创建一个 Observable 去发出这些定义的值，并且我们的 Subscriber 可以改变成匿名的内部类，如下：

Observable.just(getListData()).subscribe(new Subscriber() {   @Override   public void onCompleted() {   System.out.println("Complete!");   }   @Override   public void onError(Throwable e) {}   @Override   public void onNext(Integer value) {   System.out.println("onNext: " + value);   }});  //onNext()方法被调用，被发送的数据列表会作为参数传入；既然不再有数据可以发送（我们在Observable.just()中只让Observable发送一个数据），onComplete()方法会被调用。

在这个例子中我们不关心Observable何时完成数据的传输，所以我们不用在onComplete()方法里写代码。而且在这里不会有异常抛出，所以我们也不用管onError()方法。

操作符：

感谢大圣：程序亦非猿 的《RxJava操作符学习笔记》

通过create（）、just( )、from( )绑定（输入）事件来构造对象；备注：Observable.from()方法，它接收一个集合作为输入，然后每次输出一个元素给subscriber；

通过map( )、filter( )将输入的事件进行过滤成我们希望获取的事件，返回结果给观察者响应；

通过Observable.flatMap()接收一个Observable的输出作为输入，同时输出另外一个Observable。

Take()指定最多输出量；doOnNext()允许我们在每次输出一个元素之前做一些额外的事情；

lift（）对目标订阅者进行层层包装，通过Observable.Operator，让包装后的订阅者可以直接处理的事件。

compose（）是对多个lift()的封装；

 throttleFirst()在每次事件触发后的一定时间间隔内丢弃新的事件，用作防抖什么的，按一次后，多少时间内再按了也没用。

onStart() 这是 Subscriber增加的方法。它会在 subscribe刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行）， onStart()就不适用了，因为它总是在 subscribe所发生的线程被调用，而不能指定线程。要在指定的线程来做准备工作，可以使用 doOnSubscribe()方法，具体可以在后面的文中看到。

unSubscribe()这是 Subscriber所实现的另一个接口 Subscription的方法，用于取消订阅。在这个方法被调用后，Subscriber将不再接收事件。一般在这个方法调用前，可以使用isUnsubscribed()先判断一下状态。 unsubscribe()这个方法很重要，因为在 subscribe()之后， Observable会持有 Subscriber的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（例如 onPause()onStop()等方法中）调用 unsubscribe()来解除引用关系，以避免内存泄露的发生。

重点：线程控制与异步操作

首先介绍一下：Scheduler：线程控制

Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定   .subscribeOn(Schedulers.io())   .observeOn(Schedulers.newThread())    .map(mapOperator) // 新线程，由 observeOn() 指定   .observeOn(Schedulers.io())    .map(mapOperator2) // IO 线程，由 observeOn() 指定   .observeOn(AndroidSchedulers.mainThread)    .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定

·        Schedulers.immediate():直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。

·        Schedulers.newThread():总是启用新线程，并在新线程执行操作。

·        Schedulers.io(): I/O操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread()更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。

·        Schedulers.computation():计算所使用的 Scheduler。这个计算指的是 CPU密集型计算，即不会被 I/O等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O操作放在 computation() 中，否则 I/O操作的等待时间会浪费 CPU。

·        另外， Android还有一个专用的 AndroidSchedulers.mainThread()，它指定的操作将在 Android主线程运行。

有了这几个 Scheduler ，就可以使用 subscribeOn() 和 observeOn() 两个方法来对线程进行控制了。

·        subscribeOn():指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。

·        observeOn():指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。

在 Android开发中有一个常见的场景是需要在后台线程去分担一定量的工作，一旦该任务完成，会将结果回调到主线程去显示结果。

在 Android中，我们有多种方法来做这样的事：用 AsyncTasks， Services 等。

而在rxjava中如何完美解决的呢？

Observable operationObservable = Observable.create(newObservable.OnSubscribe() {
   @Override
   public void call(Subscribersubscriber) {
       subscriber.onNext(doLongOperation());
       subscriber.onCompleted();
   }
})
       .subscribeOn(Schedulers.io())// subscribeOn the I/O thread
      .observeOn(AndroidSchedulers.mainThread()); // observeOn the UI Thread
//创建了 Observable 将会调用 doLongOperation() 方法，将返回的结果作为参数给 onNext() 方法。
public String doLongOperation() {
   try {
            Thread.sleep(1000);
   } catch (InterruptedException e){
           
   }
   return "isComplete!";
}

添加了一个新的 button,被点击时，我们需要给我们的 Observable 做订阅。

rxOperationButton.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(final View v){
            v.setEnabled(false);
            operationObservable.subscribe(newSubscriber() {
                    @Override
                    public void onCompleted() {
                             v.setEnabled(true);
                    }
                    @Override
                    public void onError(Throwable e) {}
                    @Override
                    public void onNext(String value) {
                             Toast.makeText(this, value, Toast.LENGTH_LONG).show();
                    }
            });
   }
});  

对于任何 Observable你可以定义在两个不同的线程，Observable 会操作在它上面。使用 Observable.observeOn()可以定义在一个线程上，可以用来监听和检查从 Observable 最新发出的 items （Subscriber 的onNext，onCompleted 和 onError 方法会执行在 observeOn 所指定的线程上），并使用Observable.subscribeOn() 来定义一个线程，将其运行我们 Observable 的代码（长时间运行的操作）。

RxJava 默认情况下是单线程的，你会需要利用 observeOn() 和 subscribeOn() 方法为你的应用带来多线程操作。RxJava 附带了几个现成的 Schedulers 给 Observables 使用，如：Schedulers.io() （用于 I/O 操作），Schedulers.computation()（计算工作），和Schedulers.newThread()（为任务创建的新线程）。然而，从 Android 的角度来看，你可能想知道如何把订阅代码执行到主线程。我们可以用 RxAndroid 库来实现这一目标。

我们修改 Observable将用 Schedulers.io() 去订阅，并用AndroidSchedulers.mainThread() 方法将观察的结果返回到 UI 线程上。现在，当我们点击按钮，我们可以看到当操作运行时它将不再阻塞 UI 线程。

如果你一直在关注代码，你可能会注意到你调用的Observable.subscribe()的返回值是一个 Subscription 对象。Subscription 类只有两个方法，unsubscribe() 和 isUnsubscribed()。为了防止可能的内存泄露，在你的 Activity 或 Fragment 的 onDestroy 里，用 Subscription.isUnsubscribed() 检查你的Subscription 是否是 unsubscribed。如果调用了 Subscription.unsubscribe() ，Unsubscribing将会对 items 停止通知给你的 Subscriber，并允许垃圾回收机制释放对象，防止任何 RxJava 造成内存泄露。如果你正在处理多个 Observables 和 Subscribers，所有的 Subscription 对象可以添加到 CompositeSubscription，然后可以使用CompositeSubscription.unsubscribe() 方法在同一时间进行退订(unsubscribed)。

后续：继续深入学习线程操作。自己留着看看就可以了，方便自己记录学习Ok！！

参考：《给 Android开发者的 RxJava 详解》http://blog.csdn.net/meegomeego/article/details/49155989；

          《RxJava入门》http://www.open-open.com/lib/view/open1447245102194.html；