3.RxJava详解

一、RxJava 到底是什么

异步（取代AsyncTask/Handler/XXX/...?）

 

二、RxJava 好在哪

 

简洁（逻辑的简洁，.一步一走）

 

举例：

题目：将文件夹中的图片都取出来，放到界面上显示。

1.Thread

new Thread() {

    @Override

    public void run() {

        super.run();

        for (File folder : folders) {

            File[] files = folder.listFiles();

            for (File file : files) {

                if (file.getName().endsWith(".png")) {

                    final Bitmap bitmap = getBitmapFromFile(file);

                    getActivity().runOnUiThread(new Runnable() {

                        @Override

                        public void run() {

                            imageCollectorView.addImage(bitmap);

                        }

                    });

                }

            }

        }

    }}.start();

2.RxJava

Observable.from(folders)

    .flatMap(new Func1<File, Observable<File>>() {

        @Override

        public Observable<File> call(File file) {

            return Observable.from(file.listFiles());

        }

    })

    .filter(new Func1<File, Boolean>() {

        @Override

        public Boolean call(File file) {

            return file.getName().endsWith(".png");

        }

    })

    .map(new Func1<File, Bitmap>() {

        @Override

        public Bitmap call(File file) {

            return getBitmapFromFile(file);

        }

    })

    .subscribeOn(Schedulers.io())

    .observeOn(AndroidSchedulers.mainThread())

    .subscribe(new Action1<Bitmap>() {

        @Override

        public void call(Bitmap bitmap) {

            imageCollectorView.addImage(bitmap);

        }

    });

---

三、API 介绍和原理简析

 

1.概念：扩展的观察者模式

1）观察者模式：

观察者通过 注册(Register)或者称为订阅(Subscribe)的方式，通过警报，让被观察者发生某种行为的时候，通知一下观察者。

例如：onClickListener():view按钮被点击的时候，view相当于被观察者，就会触发onClickListener的监听，通知调用OnClick被观察者，两者是通过setOnClickListner订阅的。

                        

2）RxJava的观察者模式

RxJava有4个基本概念：Observable(被观察者)，Observer(观察者)，subscribe(订阅)，onNext()...->onCompleted()/onError()（事件）。

2.基本实现

1）创建Observer：它决定事件触发的时候有怎样的行动。（new）

①

Observer<String> observer = new Observer<String>() {

    @Override

    public void onNext(String s) {

        Log.d(tag, "Item: " + s);

    }

 

    @Override

    public void onCompleted() {

        Log.d(tag, "Completed!");

    }

 

    @Override

    public void onError(Throwable e) {

        Log.d(tag, "Error!");

    }};

②实现了Observer的抽象类Subscriber:

Subscriber<String> subscriber = new Subscriber<String>() {

    @Override

    public void onNext(String s) {

        Log.d(tag, "Item: " + s);

    }

 

    @Override

    public void onCompleted() {

        Log.d(tag, "Completed!");

    }

 

    @Override

    public void onError(Throwable e) {

        Log.d(tag, "Error!");

    }};

Subscriber比Observer多的东西：

onStart():在事件未发生之前调用，准备工作，执行在工作线程；doOnAubscribe()指定线程来做准备工作。

unsubscribe()取消订阅，在onStop()方法里边调用，释放资源，防止内存泄露。

 

2）创建Observable:它决定什么时候触发事件，触发怎样的事件。（onCreate()）

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

    @Override

    public void call(Subscriber<? super String> subscriber) {

        subscriber.onNext("Hello");

        subscriber.onNext("Hi");

        subscriber.onNext("Aloha");

        subscriber.onCompleted();

    }});

由此可见，传入了一个subscriber作为参数，Observable在被订阅的时候调用call(),事件就会依序执行。

简单写法：

Observable observable = Observable.just("Hello", "Hi", "Aloha");

 

String[] words = {"Hello", "Hi", "Aloha"};        Observable observable = Observable.from(words);

 

3）subscribe(订阅)

observable.subscribe(observer);

// 或者：

observable.subscribe(subscriber);

注：Observable.subscribe(subscriber)订阅的内部实现：

public Subscription subscribe(Subscriber subscriber) {

    subscriber.onStart();            //准备

    onSubscribe.call(subscriber);    //事件发送的逻辑开始

    return subscriber;               //返回监听对象

}

                

除了 subscribe(Observer) 和 subscribe(Subscriber) ，subscribe() 还支持不完整定义的回调，RxJava 会自动根据定义创建出Subscriber 。形式如下：

Action1<String> onNextAction = new Action1<String>() {

    // onNext()

    @Override

    public void call(String s) {

        Log.d(tag, s);

    }

};

Action1<Throwable> onErrorAction = new Action1<Throwable>() {

    // onError()

    @Override

    public void call(Throwable throwable) {

        // Error handling

    }

};

Action0 onCompletedAction = new Action0() {

    // onCompleted()

    @Override

    public void call() {

        Log.d(tag, "completed");

    }

};

 

// 自动创建 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);

实例：

由id取得图片并显示

int drawableRes = ...;

ImageView imageView = ...;

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

    @Override

    public void call(Subscriber<? super Drawable> subscriber) {

        Drawable drawable = getTheme().getDrawable(drawableRes));

        subscriber.onNext(drawable);

        subscriber.onCompleted();

    }

}).subscribe(new Observer<Drawable>() {

    @Override

    public void onNext(Drawable drawable) {

        imageView.setImageDrawable(drawable);

    }

 

    @Override

    public void onCompleted() {

    }

 

    @Override

    public void onError(Throwable e) {

        Toast.makeText(activity, "Error!", Toast.LENGTH_SHORT).show();

    }

});

3.线程控制——Scheduler(调度器)

在不指定线程的情况下，RxJava遵循线程不变的原则。（在哪个线程调用subscribe()，就在哪个线程生产事件，消费事件）

1）Scheduler的API

• Schedulers.immediate():当前线程。
• Schedulers.newThread():新启线程。
• Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。（*）
• Schedulers.computation(): 计算所使用的 Scheduler。
• AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行。
• subscribeOn(): 指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。
• observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。

Observable.just(1, 2, 3, 4)

    .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程

    .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程

    .subscribe(new Action1<Integer>() {

        @Override

        public void call(Integer number) {

            Log.d(tag, "number:" + number);

        }

    });