RxJava 学习--使用摘要

作为一个有理想的程序猿，既然大家都说 RxJava 这么好用,所以抽空必须好好学习。读《给 Android 开发者的 RxJava 详解》 摘要：

• 简介：RxJava-------->异步
  一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库
• 基本实现
  一、 创建观察者：（两种方式：Observer 、Subscriber，两者效果等价）

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!");
    }
};

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!");
    }
};

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

1. 使用 create() 方法来创建一个 Observable ：

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();
    }
});

2. just(T...): 将传入的参数依次发送出来, eg:
   Observable observable = Observable.just("Hello", "Hi", "Aloha");
3. from(T[]) / from(Iterable<? extends T>) : 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来, eg:

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

三、Subscribe (订阅,将观察者与被观察者联系起来)

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

• subscribe() 还支持不完整定义的回调，RxJava 会自动根据定义创建出 Subscriber（订阅者，即观察者）eg:

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);

• 线程控制 —— Scheduler

1. Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。
2. Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。
3. Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。
4. Schedulers.computation(): 计算所使用的 Scheduler。
5. AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行。
   eg:

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);
        }
    });

• 变换（map()、flatMap()）

1. map() ,一对一的转化, eg:

Observable.just("images/logo.png") // 输入类型 String
    .map(new Func1<String, Bitmap>() {
        @Override
        public Bitmap call(String filePath) { // 参数类型 String
            return getBitmapFromPath(filePath); // 返回类型 Bitmap
        }
    })
    .subscribe(new Action1<Bitmap>() {
        @Override
        public void call(Bitmap bitmap) { // 参数类型 Bitmap
            showBitmap(bitmap);
        }
    });

这里出现了一个叫做 Func1 的类。它和 Action1 非常相似，也是 RxJava 的一个接口，用于包装含有一个参数的方法。 Func1 和 Action 的区别在于， Func1 包装的是有返回值的方法。另外，和 ActionX 一样， FuncX 也有多个，用于不同参数个数的方法。FuncX 和 ActionX 的区别在 FuncX 包装的是有返回值的方法。

2. flatMap() , 一对多的转化, eg:

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);

日常主要用到的两个变换函数

• 最后，《给 Android 开发者的 RxJava 详解》 这篇文章好长好长，要耐着性子看，一次不了然，多看几次。。。