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