RxJava的使用（一）

RxJava能夠將異步的事件組成線性的代碼結構。能夠使複雜的代碼結構在邏輯上簡潔化。

引入依賴：

compile ‘io.reactivex:rxjava:1.0.14’
compile ‘io.reactivex:rxandroid:1.0.1’

使用（一）

創建Observable

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("1");
                subscriber.onNext("2");
                subscriber.onNext("3");
                subscriber.onNext("4");
                subscriber.onNext("5");
                subscriber.onNext("6");
                subscriber.onCompleted();
            }
        });

創建Obsever

Observer obsetver = new Observer<String>(){

            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.i("chuyibo",s);
            }
        };

調用Observable的subscribe()方法。創建的Observer作爲參數傳遞進去。

observable.subscribe(obsetver);

使用（二）

創建Observable

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("1");
                subscriber.onNext("2");
                subscriber.onNext("3");
                subscriber.onNext("4");
                subscriber.onNext("5");
                subscriber.onNext("6");
                subscriber.onNext("7");
            }
        });

創建Subscriber

Subscriber subscriber = new Subscriber<String>(){

            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.i("chuyibo",s);
            }
        };

調用Observable的subscribe()方法。創建的Subscriber作爲參數傳遞進去。

observable.subscribe(subscriber);

Observer與Subscriber

Observer最終會被轉化爲Subscriber使用，Subscriber比Observer多了onStart()、unsubscribe()方法。

• onStart()：在 subscribe（訂閱）剛開始，而事件還未發送之前被調用，可以用於做一些準備工作。
• unsubscribe()：取消訂閱。調用該方法，Subscriber 不再接收事件。一般在該方法調前，使用 isUnsubscribed() 判斷一下狀態。因爲在 subscribe() 之後， Observable 會持有 Subscriber 的引用，這個引用如果不被釋放，有可能內存泄露。所以要在不使用的時候（例如 onPause() onStop() 等方法中）調用 unsubscribe() 解除引用。

subscribe()方法

public Subscription subscribe(Subscriber subscriber) {

    //激活創建的Subscriber
    subscriber.onStart();

    //將創建的Subscriber作爲參數傳遞給OnSubscribe的call()方法
    onSubscribe.call(subscriber);
    return subscriber;
}

Action1、Action0不完整回調的使用

Action1 onNextAction = new Action1<String>(){

         // onNext()
         @Override
         public void call(String s) {
             Log.i("chuyibo",s);
         }
     };
Action1 onErrorAction = new Action1<Throwable>(){

         // onError()
         @Override
         public void call(Throwable throwable) {

         }
     };
Action0 onCompletedAction = new Action0(){

        // onCompleted()
         @Override
         public void call() {

         }
     };

//自動創建 Subscriber ，並使用 onNextAction 來定義 onNext()
observable.subscribe(onNextAction);
        //自動創建 Subscriber ，並使用 onNextAction 和 onErrorAction 來定義 onNext() 和 onError()
observable.subscribe(onNextAction,onErrorAction);
        //自動創建 Subscriber ，並使用 onNextAction、 onErrorAction 和 onCompletedAction 來定義 onNext()、 onError() 和 onCompleted()
observable.subscribe(onNextAction,onErrorAction,onCompletedAction);

just()、from()創建Observable

Observable observable = Observable.just("1","2","3","4","5","6","8");
// 將會依次調用：
// onNext("1");
// onNext("2");
// onNext("3");
// onNext("4");
// onNext("5");
// onNext("6");
// onNext("7");
// onNext("8");
// onCompleted();       

String[] s = {"1","2","3","4","5","6","8"};
Observable observable = Observable.from(s);
// 將會依次調用：
// onNext("1");
// onNext("2");
// onNext("3");
// onNext("4");
// onNext("5");
// onNext("6");
// onNext("7");
// onNext("8");
// onCompleted();   

map()、flatMap()轉換

1.map()轉換

public class Student{
        String name;
        List<String> course = new ArrayList<String>();

        public Student(String name){
            this.name = name;
            course.add("英語");
            course.add("語文");
            course.add("數學");
            course.add("物理");
            course.add("化學");
            course.add("生物");
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public List<String> getCourse() {
            return course;
        }

        public void setCourse(List<String> course) {
            this.course = course;
        }
    }

List<Student> students = new ArrayList<Student>();
        for(int i = 0;i < 5;i++){
            Student student = new Student("小明"+i);
            students.add(student);
        }

 Observable.from(students)
         .map(new Func1<Student, String>() {
             @Override
             public String call(Student student) {
                 return student.getName();
             }
         })
         .subscribe(new Action1<String>() {
             @Override
             public void call(String s) {
                 Log.i("chuyibo",s);
             }
         });

2.flatMap()轉換

List<Student> students = new ArrayList<Student>();
        for(int i = 0;i < 5;i++){
            Student student = new Student("小明"+i);
            students.add(student);
        }

Observable.from(students)
        .flatMap(new Func1<Student, Observable<String>>() {
            @Override
            public Observable<String> call(Student student) {
                return Observable.from(student.getCourse());
            }
        })
        .subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i("chuyibo",s);
            }
        });

線程切換

subscribeOn()

指定 subscribe() 所發生的線程，即 Observable.OnSubscribe 被激活時所處的線程。或者叫做事件產生的線程。只能調用一次的。

observeOn()

指定 Subscriber 所運行在的線程。或者叫做事件消費的線程。 可以多次調用及多次切換線程，指定的是它之後的操作所在的線程。

RxJava內置的Scheduler

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。
AndroidSchedulers.mainThread()：它指定的操作將在 Android 主線程運行。