RxJava基本用法

说到异步操作，通常Android会使用Handler和AsyncTask,但是随着请求的数量越来越多，逻辑越来越复杂，RxJava依然能保持比较清晰的逻辑。RxJava就是创建一个Observable对象，通过各种操作符把想要处理的数据加工成想要的成品，然后发射给Subscriber。

使用前在Android Studio配置gradle

 compile 'io.reactivex:rxandroid:1.2.1' compile 'io.reactivex:rxjava:1.2.0'

1.创建观察者

    //创建观察者处理Observable对象发出的字符串    Subscriber subscriber = new Subscriber<String>() {        @Override        public void onStart() {            Log.d("TAG","onStart");        }        @Override        public void onCompleted() {            Log.d("TAG","onCompleted");        }        @Override        public void onError(Throwable e) {            Log.d("Tag","onError");        }        @Override        public void onNext(String s) {            Log.d("TAG","onNext"+s);        }    };

onStart：在事件还未发送前调用，可用于准备工作，如数据的重置或者重置，它是一个可选方法，默认实现为空。需要注意的是如果对工作的线程有要求，比如：弹出一个AlertDialog、ProgressBar等必须在主线程运行的任务，就不能用onStart()方法，因为它总是在subscribe方法所发生的线程中调用，而不能指定线程，要在指定的线程来做准备工作，可以使用 Observable的doOnSubscribe() 方法完成初始化。
onCompleted：事件队列完结，RxJava不仅把每个事件单独处理，其还会把他们看作一个队列，当没有新的onNext发出时，需要触发onCompleted方法作为完成的标志。
onError：事件队列异常。在事件处理过程中出现异常时，onError()方法会被触发，同时队列会被自动终止，不允许在有事件发出。
onNext : 普通事件，将要处理的事件添加到事件队列中

2.创建被观察者

    //创建被观察者，它决定什么时候触发事件以及触发怎么样的事件    rx.Observable observable = rx.Observable.create(new rx.Observable.OnSub    scribe<String>() {        @Override        public void call(Subscriber<? super String> subscriber) {            subscriber.onStart();            subscriber.onNext("AAAAA");            subscriber.onNext("BBBBB");            subscriber.onCompleted();        }    });

如上所示通过不断地调用subscriber方法，不断的将事件添加到任务队列中。也可以使用just方法实现：

Observable observable = Observable.just("AAAA","BBBB","CCCC");

上述代码会依次调用onNext(“AAAA”)、onNext(“BBBB”)、onNext(“CCCC”)、onCompleted()，当然也可以用from方法来实现：

String[] words = {"aaaa","bbbb","cccc"};Observable observable = Observable.from(words);ArrayList list = new ArrayList();   list.add("aaaa");   list.add("bbbb");   list.add("cccc");Observable observable = Observable.from(list); 

订阅只需要一行代码就可以了

observable.subscribe(subscriber);

订阅过程：

public final Subscription subscribe(Subscriber<? super T> subscriber) {    return Observable.subscribe(subscriber, this);}static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {...    subscriber.onStart();    if (!(subscriber instanceof SafeSubscriber)) {         subscriber = new SafeSubscriber<T>(subscriber);    }    try {         RxJavaHooks.onObservableStart(observable, observable.onSubscribe).         call(subscriber);         return RxJavaHooks.onObservableReturn(subscriber);     } catch (Throwable e) {...       return Subscriptions.unsubscribed();     }}public static <T> Observable.OnSubscribe<T> onObservableStart(Observable<T> instance, Observable.OnSubscribe<T> onSubscribe) {     Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> f      = onObservableStart;     if (f != null) {         return f.call(instance, onSubscribe);     }     return onSubscribe;}public static Subscription onObservableReturn(Subscription subscription) {    Func1<Subscription, Subscription> f = onObservableReturn;    if (f != null) {         return f.call(subscription);    }    return subscription;}

1.首先调用Subscriber.onStart()
2.调用RxJavaHooks.onObservableStart(observable, observable.onSubscribe)方法返回一个onSubscribe，然后调用onSubscribe的call方法，在这里，事件发送的逻辑开始运行。
3.调用RxJavaHooks.onObservableReturn(subscriber);即将传入的Subscriber 作为 Subscription 返回

不完整回调:
除了 subscribe(Observer) 和 subscribe(Subscriber) ，subscribe() 还支持不完整定义的回调

   Action1<String> onNextAction1 = new Action1<String>() {        @Override        public void call(String s) {            Log.d("TAG","onNext"+s);        }    };    Action1<Throwable> onErrorAction1 = new Action1<Throwable>() {        @Override        public void call(Throwable throwable) {            Log.d("TAG","onError");        }    };    Action0 onCompletedAction = new Action0() {        @Override        public void call() {            Log.d("TAG","onCompleted");        }    };observable.subscribe(onNextAction1,onErrorAction1,onCompletedAction);Observable.from(list).subscribe(onNextAction1);

定义了onNextAction1处理onNext的回调，onErrorAction1处理onError的回调，onCompletedAction处理onCompleted的回调，然后把他们传递给subscribe方法，如下：

Observable.create(new Observable.OnSubscribe<String>() {     @Override     public void call(Subscriber<? super String> subscriber) {         subscriber.onNext("AAAAAA");     }}).subscribe(new Action1<String>() {     @Override     public void call(String s) {          Log.d("TAG","onNext:"+s);     }    });

线程控制：

Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 SchedulerSchedulers.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 主线程运行。

在RxJava中使用subscribeOn和observeOn操作符控制线程；subscribeOn用于指定Observable自身在哪个线程上运行，如果Observable需要执行耗时操作，一般可以让其在新开的子线程运行，observeOn用来指定Observer所运行的线程，也就是发射出的数据在哪个线程上使用，一般情况会指定在主线程中运行，这样就可以修改UI：

Observable.create(new Observable.OnSubscribe<String>() {   @Override   public void call(Subscriber<? super String> subscriber) {      Log.d("TAG",Thread.currentThread().getName());      subscriber.onNext("AAAAAA");   }}).subscribeOn(Schedulers.io())  .observeOn(AndroidSchedulers.mainThread())  .subscribe(new Action1<String>() {      @Override      public void call(String s) {         Log.d("TAG",Thread.currentThread().getName());         Log.d("TAG","onNext:"+s);      }   });

subscribeOn(Schedulers.io())表示Observable运行在新开的线程，observeOn(AndroidSchedulers.mainThread())表示subscriber 数字的打印将发生在主线程。