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() {
        @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() {
        @Override
        public void call(Subscriber 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(SubscriberT> subscriber) {
    return Observable.subscribe(subscriber, this);
}

static <T> Subscription subscribe(SubscriberT> 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 f 
     = onObservableStart;
     if (f != null) {
         return f.call(instance, onSubscribe);
     }
     return onSubscribe;
}


public static Subscription onObservableReturn(Subscription subscription) {
    Func1 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 onNextAction1 = new Action1() {
        @Override
        public void call(String s) {
            Log.d("TAG","onNext"+s);
        }
    };

    Action1 onErrorAction1 = new Action1() {
        @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() {
     @Override
     public void call(Subscribersuper String> subscriber) {
         subscriber.onNext("AAAAAA");
     }
}).subscribe(new Action1() {
     @Override
     public void call(String s) {
          Log.d("TAG","onNext:"+s);
     }
    });

线程控制：

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 主线程运行。

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

Observable.create(new Observable.OnSubscribe() {
   @Override
   public void call(Subscriber subscriber) {
      Log.d("TAG",Thread.currentThread().getName());
      subscriber.onNext("AAAAAA");
   }
}).subscribeOn(Schedulers.io())
  .observeOn(AndroidSchedulers.mainThread())
  .subscribe(new Action1() {
      @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 数字的打印将发生在主线程。