RxJava 使用详情

一概要：

RxJava已经被越来越多的人使用，提及。个人也觉得非常好用，优秀。这里做一个简单的归纳。

1，RxJava是什么：GitHub上介绍（翻译）：一个在Java VM上使用可观测的序列来组成异步的，

基于事件的程序的库。简单点：一个实现异步操作的库。类似Handler，与AsyncTask。

2，RxJava优点是什么：相对于Handler/AsyncTask，RxJava使用非常简洁。使用一个链式引用就可以

将整个事件序列串联起来。

3，配置参考github：

https://github.com/ReactiveX/RxJava

https://github.com/ReactiveX/RxAndroid

二原理简析：

#RxJava的异步实现，是通过一个扩展的观察者模式来实现的。

#RxJava有四个基本概念：Observable（被观察者），Observer（观察者），subscribe（订阅），事件。

Observable与Observer通过subscribe来实现订阅关系，从而Observable可以在需要的时候发出事件通知Observer。

#与传统的观察者模式不同，RxJava的回调方法中除了onNext(类似onClick， onEvent)，还定义了两个特殊的方法

onError, (事件队列异常)，onComplete（事件队列结束语onError互斥）

三使用：

#基本使用

创建Observer（观察者），决定事件触发时的行为。（Subscriber是对Obsever封装了的观察者，比Observer多了

两个方法：onStart（在subscribe刚开始，事件还未被发送之前调用），onunsubscribe（取消订阅）。

        Observer<String> observer = new Observer<String>() {
            @Override
            public void onCompleted() {
                LogUtil.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable throwable) {
                LogUtil.i(TAG, "onError");
            }

            @Override
            public void onNext(String s) {
                LogUtil.i(TAG, "onNext:" + s);
            }
        };

创建Observable（被观察者），决定事件什么时候触发，以及触发怎么的事件。

        Observable observable = Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("1 times");
                subscriber.onNext("2 times");
                subscriber.onNext("3 times");
                subscriber.onCompleted();
            }
        });

#这里OnSubscribe作为create的参数，会被存储在observable对象中，相当于observable的计划表，当Observable

被订阅时，OnSubscribe的call方法就会被调用。然后就会触发订阅者（即观察者的）onNext（三次），onCompleted。

#create是创建事件序列的最基本方法。RxJava还提供其他创建事件序列的快捷方法，from、just...；

from方法：

        Observable observable = Observable.from(new String[]{"1 times", "2 times", "3 times"});
        //将会依次调用
        //onNext("1 times");
        //onNext("2 times");
        //onNext("3 times");
        //onCompleted();

j ust方法：

        Observable observable = Observable.just("1 times", "2 times", "3 times");
        //将会依次调用
        //onNext("1 times");
        //onNext("2 times");
        //onNext("3 times");
        //onCompleted();

Subscribe订阅，创建Observable与Observer之后，subscribe方法将两者联系起来。

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

subscribe的主要核心代码：

        // 注意：这不是 subscribe() 的源码，而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
        public Subscription subscribe(Subscriber subscriber) {
            subscriber.onStart();
            onSubscribe.call(subscriber);
            return subscriber;
        }

#重点onSubscribe.call(subscriber)方法，前面分析的create方法，方法中的参数OnSubscribe，作为ObServable的计划表。
除了subscribe（Observer）和subscribe（Subscriber）方法外，还支持不完整定义回调：

        Action1<String> nextAction = new Action1<String>() {
            @Override
            public void call(String s) {

            }
        };
        Action1<Throwable> errorAction = new Action1<Throwable>() {
            @Override
            public void call(Throwable o) {

            }
        };
        Action0 completeAction = new Action0() {
            @Override
            public void call() {

            }
        };
        //自动创建Subscriber，使用nextAction,来定义onNext
        observable.subscribe(nextAction);
        //自动创建Subscriber，使用nextAction，errorAction来定义onNext与onError
        observable.subscribe(nextAction, errorAction);
        //自动创建Subscriber，使用nextAction，errorAction，completeAction来定义onNext，onError，onComplete
        observable.subscribe(nextAction, errorAction, completeAction);

下面举两个例子：

1，将字符串数组names中的字符串依次打印出来。

        //将数组names中的所有字符串打印出来。
        String[] names = new String[]{"wangwu", "zhangsan", "lisi"};
        Observable.from(names)
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        LogUtil.i(TAG, "name:" + s);
                    }
                });

2，由图片id，取得图片并显示：

        int resId = R.drawable.aa2;

        Observable.create(new Observable.OnSubscribe<Drawable>() {

            @Override
            public void call(Subscriber<? super Drawable> subscriber) {
                LogUtil.i(TAG, "currentThread:" + Thread.currentThread());
                Drawable drawable = MainActivity.this.getResources().getDrawable(R.drawable.aa2);
                subscriber.onNext(drawable);
                subscriber.onCompleted();
            }
        })
                .subscribe(new Subscriber<Drawable>() {

                    @Override
                    public void onStart() {
                        super.onStart();
                        LogUtil.i(TAG, "onStart");
                    }

                    @Override
                    public void onNext(Drawable drawable) {
                        LogUtil.i(TAG, "currentThread:" + Thread.currentThread());
                        LogUtil.i(TAG, "onNext");
                        iv_content.setImageDrawable(drawable);
                    }

                    @Override
                    public void onError(Throwable throwable) {
                        LogUtil.i(TAG, "onError");
                    }

                    @Override
                    public void onCompleted() {
                        LogUtil.i(TAG, "onCompleted");
                    }
                });

高级使用：

1，变换：map、flatMap：将事件序列中的事件或整个事件序列，加工成不同的事件，或事件序列。

场景一，已知学生数组，打印学生的姓名：

        Student[] students = ...;
        Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onNext(String name) {
                Log.d(tag, name);
            }
    ...
        };
        Observable.from(students)
                .map(new Func1<Student, String>() {
                    @Override
                    public String call(Student student) {
                        return student.getName();
                    }
                })
                .subscribe(subscriber);

场景二，已知学生数组，打印学生的所选课程（课程不唯一）：
我们当然可以使用for循环：

        Student[] students = ...;
        Subscriber<Student> subscriber = new Subscriber<Student>() {
            @Override
            public void onNext(Student student) {
                List<Course> courses = student.getCourses();
                for (int i = 0; i < courses.size(); i++) {
                    Course course = courses.get(i);
                    Log.d(tag, course.getName());
                }
            }
    ...
        };
        Observable.from(students)
                .subscribe(subscriber);

或者flatMap：

        Student[] students = ...;
        Subscriber<Course> subscriber = new Subscriber<Course>() {
            @Override
            public void onNext(Course course) {
                Log.d(tag, course.getName());
            }
    ...
        };
        Observable.from(students)
                .flatMap(new Func1<Student, Observable<Course>>() {
                    @Override
                    public Observable<Course> call(Student student) {
                        return Observable.from(student.getCourses());
                    }
                })
                .subscribe(subscriber);

#flatMap与map不同，call方法返回的是Observable对象。

线程控制要求，利用subscribeOn与observeOn来实现线程控制。subscribeOn实现的是事件发送所在线程，observeOn

事件消耗所在线程（下一个操作），onserveOn可以调用多次，即事件消耗可以多次线程切换。

Scheduler实现异步操作：

        Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.newThread())
                .map(mapOperator) // 新线程，由 observeOn() 指定
                .observeOn(Schedulers.io())
                .map(mapOperator2) // IO 线程，由 observeOn() 指定
                .observeOn(AndroidSchedulers.mainThread)
                .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定

延伸doOnSubscribe，与subscriber的onStart方法一样在subscribe之后，事件发送前被调用。但是不同点是doOnSubscribe可以

被指定线程。默认情况下doOnSubscribe与subscribe所在的线程相同，如果在doOnSubscribe后又subscribeOn（）定义线程，则

依从doOnSubscribe之后的最近的subscribeOn所指定线程：

        Observable.create(onSubscribe)
                .subscribeOn(Schedulers.io())
                .doOnSubscribe(new Action0() {
                    @Override
                    public void call() {
                        progressBar.setVisibility(View.VISIBLE); // 需要在主线程执行
                    }
                })
                .subscribeOn(AndroidSchedulers.mainThread()) // 指定主线程
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(subscriber);

四避免内存泄漏：

使用CompositeSubscription，收集每一次Subscription，然后在onDestroy中统一注销。

CompositeSubscription compositeSubscription = new CompositeSubscription();//第一步，初始化CompositeSubscrpiton

        compositeSubscription.add(    //第二步，add Subscription
                Observable.from(names)
                        .subscribe(new Action1<String>() {
                            @Override
                            public void call(String s) {
                                LogUtil.i(TAG, "name:" + s);
                            }
                        })
        );

    @Override
    protected void onDestroy() {
        super.onDestroy();//在Activity销毁的时候，统一取消订阅，释放资源
        if(compositeSubscription.isUnsubscribed()){
            compositeSubscription.unsubscribe();
        }
    }

文章参考：http://gank.io/post/560e15be2dca930e00da1083#toc_1