注明：摘选自给 Android 开发者的 RxJava 详解,做该篇文章的笔记

一.创建 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(); 
    }
});

以上代码可以写成如下：

1.just(T...): 将传入的参数依次发送出来。

Observable observable = Observable.just("Hello", "Hi", "Aloha");
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

2.from(T[]) / from(Iterable<? extends T>) : 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。

String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

二.创建 Observer-观察者

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

也可以写成如下

1.subsriber

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

除了 Observer 接口之外，RxJava 还内置了一个实现了 Observer 的抽象类：Subscriber。 Subscriber 对 Observer 接口进行了一些扩展，但他们的基本使用方式是完全一样的。不仅基本使用方式一样，实质上，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能，选择 Observer 和 Subscriber 是完全一样的。它们的区别对于使用者来说主要有两点：

• onStart(): 这是 Subscriber 增加的方法。它会在 subscribe 刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行）， onStart() 就不适用了，因为它总是在 subscribe 所发生的线程被调用，而不能指定线程。要在指定的线程来做准备工作，可以使用 doOnSubscribe() 方法，具体可以在后面的文中看到。
• unsubscribe(): 这是 Subscriber 所实现的另一个接口 Subscription 的方法，用于取消订阅。在这个方法被调用后，Subscriber 将不再接收事件。一般在这个方法调用前，可以使用 isUnsubscribed() 先判断一下状态。 unsubscribe() 这个方法很重要，因为在 subscribe() 之后， Observable 会持有 Subscriber 的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（例如 onPause() onStop() 等方法中）调用 unsubscribe() 来解除引用关系，以避免内存泄露的发生。

2.RxJava 会自动根据定义创建出 Subscriber 。形式如下：

Action1,Action0

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

三.Subscribe (订阅)

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

Observable.subscribe(Subscriber) 的内部实现是这样的（仅核心代码）：

// 注意：这不是 subscribe() 的源码，而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
// 如果需要看源码，可以去 RxJava 的 GitHub 仓库下载。
public Subscription subscribe(Subscriber subscriber) { 
    subscriber.onStart(); 
    onSubscribe.call(subscriber); 
    return subscriber;
}

案例：由 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(); 
    }
});

四.线程控制 —— 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。
• Android 还有一个专用的 AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行。

有了这几个 Scheduler ，就可以使用 subscribeOn() 和 observeOn() 两个方法来对线程进行控制了。

• subscribeOn(): 指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。
• observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。

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(); 
   }
}).subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
.observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
.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(); 
   }
});

加载图片将会发生在 IO 线程，而设置图片则被设定在了主线程。这就意味着，即使加载图片耗费了几十甚至几百毫秒的时间，也不会造成丝毫界面的卡顿。

五. 变换

所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。

1.map

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

如下需求：打印出每个学生所需要修的所有课程的名称
按照现有阶段的知识，会如下编写：

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

3.变换的原理：lift()

lift() 的内部实现（仅核心代码）：

// 注意：这不是 lift() 的源码，而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
// 如果需要看源码，可以去 RxJava 的 GitHub 仓库下载。
public <R> Observable<R> lift(Operator<? extends R, ? super T> operator) { 
    return Observable.create(new OnSubscribe<R>() { 
        @Override 
        public void call(Subscriber subscriber) { 
            Subscriber newSubscriber = operator.call(subscriber); 
            newSubscriber.onStart(); 
            onSubscribe.call(newSubscriber); 
        } 
    });
}

以下案例：将事件中的 Integer 对象转换成 String 的例子

observable.lift(new Observable.Operator<String, Integer>() { 
    @Override 
    public Subscriber<? super Integer> call(final Subscriber<? super String> subscriber) { 
        // 将事件序列中的 Integer 对象转换为 String 对象 
        return new Subscriber<Integer>() { 
            @Override 
            public void onNext(Integer integer) { 
                subscriber.onNext("" + integer); 
            } 
            @Override 
            public void onCompleted() { 
                subscriber.onCompleted(); 
            } 
            @Override 
            public void onError(Throwable e) { 
                subscriber.onError(e); 
            } 
        }; 
    }
});

lift（）像一种代理机制，通过事件拦截和处理实现事件序列的变换。

4.compose: 对 Observable 整体的变换

除了lift()之外，Observable还有一个变换方法叫做compose(Transformer)。它和lift()的区别在于，lift()是针对事件项和事件序列的，而compose()是针对Observable自身进行变换。
举个例子，假设在程序中有多个 Observable ，并且他们都需要应用一组相同的 lift() 变换。你可以这么写：

第一阶段优化：

可读性、可维护性都提高了。可是 Observable 被一个方法包起来，这种方式对于 Observale 的灵活性似乎还是增添了那么点限制。怎么办？这个时候，就应该用 compose() 来解决了：

延伸：doOnSubscribe()

前面讲 Subscriber 的时候，提到过 Subscriber 的 onStart() 可以用作流程开始前的初始化。然而 onStart() 由于在 subscribe() 发生时就被调用了，因此不能指定线程，而是只能执行在 subscribe() 被调用时的线程。这就导致如果 onStart() 中含有对线程有要求的代码（例如在界面上显示一个 ProgressBar，这必须在主线程执行），将会有线程非法的风险，因为有时你无法预测 subscribe() 将会在什么线程执行。

而与 Subscriber.onStart() 相对应的，有一个方法 Observable.doOnSubscribe() 。它和 Subscriber.onStart() 同样是在 subscribe() 调用后而且在事件发送前执行，但区别在于它可以指定线程。默认情况下， doOnSubscribe() 执行在 subscribe() 发生的线程；而如果在 doOnSubscribe() 之后有 subscribeOn() 的话，它将执行在离它最近的 subscribeOn() 所指定的线程。

示例代码：

如上，在 doOnSubscribe()的后面跟一个 subscribeOn() ，就能指定准备工作的线程了。