RXAndroid入门

使用如下android需要在build.gradle中加入compile 'io.reactivex:rxandroid:1.2.1'

一、在UI现场观察

 //需要导入compile 'io.reactivex:rxandroid:1.2.1'
        Observable<Integer> averageObservable =
                MathObservable.sumInteger(Observable.just(11, 2, 3, 4, 5))
                .subscribeOn(Schedulers.newThread())                                        //subscribeOn 操作符声明你要在子线程执行运算
                .observeOn(AndroidSchedulers.mainThread());                                 //observeOn 操作符声明你要在主线程等待 Observable 的结果

        final Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            int result = -1;
            @Override
            public void onNext(Integer s) {
                result = s;
                Log.e(TAG, "onNext................." + s+"..............."+Thread.currentThread().getName());
            }

            @Override
            public void onCompleted() {
                tvContent.setText(result+"");
                Log.e(TAG, "onCompleted................."+Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };
        averageObservable.subscribe(subscriber);

运行结果：

二、RXAndroid中handler的使用

Android使用一个叫 Handler 的类绑定异步通信到消息循环。为了在任意线程 观察 一个Observable，需要创建一个与那个类关联的 Handler，然后使用AndroidSchedulers.handlerThread 、HandlerScheduler.from(handler)调度器：

Observable在一个新的线程执行：

 private void testObserveHandler() {
        final Handler[] observeHandler = new Handler[1];
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                observeHandler[0] = new Handler(Looper.myLooper()){
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        switch (msg.what){
                            case 1:
                                int result = (int) msg.obj;
                                Log.e(TAG, "handmessage................." + result + ".............." + Thread.currentThread().getName());
                                break;
                            default:
                                break;
                        }
                    }
                };
                Looper.loop();
            }
        });
        MathObservable.sumInteger(Observable.just(11, 2, 3, 4, 5))
                .subscribeOn(Schedulers.newThread())                                        //subscribeOn 操作符声明你要在子线程执行运算
                .observeOn(HandlerScheduler.from(observeHandler[0]))                        //observeOn 操作符声明subscribe在子线程中执行
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e(TAG, "sendMessage................." + integer + "............" + Thread.currentThread().getName());
                        Message message = new Message();
                        message.what = 1;
                        message.obj = integer;
                        try {
                            Thread.sleep(10 * 1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if (observeHandler[0] != null) {
                            observeHandler[0].sendMessage(message);
                        }
                    }
                });

    }

运行结果：

三、Observable何时应该订阅和取消订阅

在Android上，要在异步操作中访问框架中的对象有些棘手，那是因为Andoid系统可以决定销毁(destroy)一个 Activity，例如，当一个后台线程还在运行的时候，如果这个线程尝试访问一个已经死掉的Activity中的View对象，会导致异常退出(Crash)。（这也会导致内存泄露，因为 Activity 已经不可见了，你的后台线程还持有它的引用。）

这仍然是在Android上使用RxJava需要关注的一个问题，但是通过使用 Subscription和其它Observable操作符，你可以优雅地解决这个问题。通常来说，当你在Activity中订阅一个Observable的结果时（无论是直接的还是通过一个内部类），你必须在 onDestroy 里取消订阅，就像下面例子里展示的那样：

// MyActivity
private Subscription subscription;

protected void onCreate(Bundle savedInstanceState) {
    this.subscription = observable.subscribe(this);
}

...

protected void onDestroy() {
    this.subscription.unsubscribe();
    super.onDestroy();
}

这样确保所有指向订阅者(这个Activity)的引用尽快释放，不会再有通知通过 onNext 发射给这个订阅者。

有一个问题，如果由于屏幕方向的变化导致这个 Activity 被销毁，在 onCreate 中这个Observable会再次启动。你可以使用 cache 或 replay 操作符阻止它发生，这些操作符保证Observable在 Activity 的生命周期内存在（你可以在一个全局的缓存中保存它，比如放在Fragment中。）你可以使用任何操作符，只要能保证：当订阅者订阅一个已经在运行的Observable时，在它与Activity 解除关联的这段时间里发射的数据都会被回放，并且来自这个Observable的任何离线通知都会正常分发。