RxJava2.0_1：基础学习和理解

参考：

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

http://blog.csdn.net/u012702547/article/details/52175520

http://www.jianshu.com/p/98da2c2e3576

引入rxJava所能解决的事情

1、通过链式调用让流程结构更叫清晰。

2、解决回调嵌套问题

eg：1、查询数据库
2、网络请求
3、点击相应等

这些具有先后逻辑顺序的异步事情都可以通过Rxjava来解决。

基础

RxJava最核心的两个东西是Observable（被观察者，事件源）和Subscriber（观察者）。Observable发出一系列事件，Subscriber处理这些事件。而对于Observerables来说我们可以无限地去对他的数据进行相应的处理。

一个Observable可以发出零个或者多个事件，知道结束或者出错。每发出一个事件，就会调用它的Subscriber的onNext方法，最后调用Subscriber.onNext()或者Subscriber.onError()结束。

Rxjava的看起来很想设计模式中的观察者模式，但是有一点明显不同，那就是如果一个Observerble没有任何的的Subscriber，那么这个Observable是不会触发出任何事件的。

简单的流程：

RxJava它是一个异步库，这个异步库可以让我们用非常简洁的代码来处理复杂数据流或者事件。Observable用户发送消息，而Observer用于消费消息，在实际开发中，我们更多的是选择Observer的一个子类Subscriber来消费消息。在消息发送的过程中，Observable可以发送任意数量任意类型的消息（甚至一个将一个触摸事件当作一个消息发出），当Observable所发送的消息被成功处理或者消息出错时，一个流程结束。Observable会用它的每一个Subscriber（观察者）的onNext方法进行消息处理，在消息成功处理后以onComplete()方法结束流程，如果消息在处理的过程中出现了任何异常，则以onError()方法结束流程。

Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("哈哈哈哈");
                subscriber.onNext("lalalala");
                subscriber.onCompleted();
            }
        })
                .subscribe(new Observer<String>() {
                    @Override
                    public void onCompleted() {
                        Log.d("google_lenve_fb", "onCompleted: onCompleted()");
                    }  

                    @Override
                    public void onError(Throwable e) {
                        Log.d("google_lenve_fb", "onError:onError() ");
                    }  

                    @Override
                    public void onNext(String s) {
                        Log.d("google_lenve_fb", "onNext: " + s);
                    }
                });

对象简介

Observable (可观察者，即被观察者)、Observer (观察者)、subscribe (订阅)、事件。Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。

Observable (可观察者，即被观察者)：

它决定什么时候触发事件以及触发怎样的事件。

Observer和subscriber (观察者):

public abstract class Subscriber<T> implements Observer<T>, Subscription

public interface Observer<T>{   public void onNext(T t)；
   public void onCompleted();
   public void onError(Throwable e);
}

observer和subscriber很多时候都差不多，他们的主要区别有两个：

onStart():用于做一些准备工作，例如数据的清零或重置。它总是在 subscribe 所发生的线程被调用，而不能指定线程。
unsubscribe(): 用于取消订阅，subscribe() 之后， Observable 会持有 Subscriber 的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（例如 onPause() onStop() 等方法中）调用 unsubscribe() 来解除引用关系，以避免内存泄露的发生。

subscribe (订阅):

创建了 Observable 和 Observer 之后，再用 subscribe() 方法将它们联结起来，整条链子就可以工作了。

observable.subscribe(observer);
// 或者：
observable.subscribe(subscriber);

整体关系：

常用操作符

from函数

Observale中的from函数接受一个数组，这个方法返回一个按数组元素的顺序来发射这些数据的Observale。

Observable.from(new String[]{"竹外桃花三两枝", "春江水暖鸭先知"})
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onCompleted() {  

                    }  

                    @Override
                    public void onError(Throwable e) {  

                    }  

                    @Override
                    public void onNext(String s) {
                        Log.d("google_lenve_fb", "onNext: " + s);
                    }
                });

印的结果：

D/google_lenve_fb: onNext: 竹外桃花三两枝
D/google_lenve_fb: onNext: 春江水暖鸭先知

just函数

接受最多10个参数，返回一个按参数顺序发射这些数据的Observable。

Observable.just("Hello", "World", "Hello", "RxJava!","塞外秋来风景异","衡阳雁去无留意"
        ,"四面边声连角起","千嶂里","长烟落日孤城闭","浊酒一杯家万里")
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onCompleted() {  

                    }  

                    @Override
                    public void onError(Throwable e) {  

                    }  

                    @Override
                    public void onNext(String s) {
                        Log.d("google_lenve_fb", "onNext: " + s);
                    }
                });

打印结果：

D/google_lenve_fb: onNext: Hello
D/google_lenve_fb: onNext: World
D/google_lenve_fb: onNext: Hello
D/google_lenve_fb: onNext: RxJava!
D/google_lenve_fb: onNext: 塞外秋来风景异
D/google_lenve_fb: onNext: 衡阳雁去无留意
D/google_lenve_fb: onNext: 四面边声连角起
D/google_lenve_fb: onNext: 千嶂里
D/google_lenve_fb: onNext: 长烟落日孤城闭
D/google_lenve_fb: onNext: 浊酒一杯家万里

map函数

对Observable创建的原始数据进行二次加工，然后再被观察者获取。

Observable.from(new String[]{"醉里挑灯看剑","梦回吹角连营"})
                .map(new Func1<String, String>() {
                    @Override
                    public String call(String s) {
                        return s + "---辛弃疾";
                    }
                })
                .subscribe(new Observer<String>() {
                    @Override
                    public void onCompleted() {  

                    }  

                    @Override
                    public void onError(Throwable e) {  

                    }  

                    @Override
                    public void onNext(String s) {
                        Log.d("google_lenve_fb", "onNext: " + s);
                    }
                });

打印结果

D/google_lenve_fb: onNext: 醉里挑灯看剑---辛弃疾
D/google_lenve_fb: onNext: 梦回吹角连营---辛弃疾

flatMap函数

接受一个Observable函数作为输入函数，然后在这个输入的基础上再创建一个新的Observable进行输出。

Observable.just("落霞与孤鹜齐飞", "秋水共长天一色")
                .flatMap(new Func1<String, Observable<String>>() {
                    @Override
                    public Observable<String> call(String s) {
                        return Observable.from(new  String[]{s + "冯唐易老", s + "李广难封"});
                    }
                }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {  

            }  

            @Override
            public void onError(Throwable e) {  

            }  

            @Override
            public void onNext(String s) {
                Log.d("google_lenve_fb", "onNext: " + s);
            }
        });

打印结果：

D/google_lenve_fb: onNext: 落霞与孤鹜齐飞冯唐易老
D/google_lenve_fb: onNext: 落霞与孤鹜齐飞李广难封
D/google_lenve_fb: onNext: 秋水共长天一色冯唐易老
D/google_lenve_fb: onNext: 秋水共长天一色李广难封

subscribeOn函数和observeOn函数

subscribeOn()主要改变的是订阅的线程，即call()执行的线程;
observeOn()主要改变的是发送的线程，即onNext()执行的线程。

线程：

AndroidSchedulers.mainThread()：主线程

Schedulers.io()：处理IO的线程

Schedulers.newThread()：新创建的线程.

Schedulers.computation()：计算的线程