RxJava笔记

RxJava介绍

github: Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM
(一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库)

特点：异步、简洁（链式调用）

实现方式：扩展的观察者模式

基本概念：Observable (被观察者)、 Observer (观察者)、 subscribe(订阅) 、event(事件)。Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。

RxJava常用方法

常用方法比较：

1. ActionX： 无返回值
   FuncX：有返回值
2. map：一对一
   flatMap：一对多
3. lift：针对事件项和事件序列
   compose：针对Observable自身进行变换

4. subscribeOn和observeOn:

   • subscribeOn的调用切换之前的线程。
   • observeOn的调用切换之后的线程。
   • observeOn之后，不可再调用subscribeOn 切换线程
     特别补充：
   • 下面提到的“操作”包括产生事件、用操作符操作事件以及最终的通过 subscriber 消费事件
   • 只有第一subscribeOn() 起作用（所以多个 subscribeOn() 毛意义）
   • 这个 subscribeOn() 控制从流程开始的第一个操作，直到遇到第一个 observeOn()
   • observeOn() 可以使用多次，每个 observeOn() 将导致一次线程切换()，这次切换开始于这次 observeOn() 的下一个操作
   • 不论是 subscribeOn() 还是 observeOn()，每次线程切换如果不受到下一个 observeOn() 的干预，线程将不再改变，不会自动切换到其他线程

常用方法介绍：

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…): 将传入的参数依次发送出来。

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

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

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

4. map(): 事件对象的直接变换，用来把一个事件转换为另一个事件,是 RxJava 最常用的变换。

   Observable.just("Hellp Map Operator")
   .map(new Func1<String, Integer>() {
       @Override
       public Integer call(String s) {
           return 2015;//通过第一个map转成Integer
       }
   }).map(new Func1<Integer, String>() {
       @Override
       public String call(Integer integer) {
           return String.valueOf(integer);//再通过第二个map转成String
       }
   }).subscribe(new Action1<String>() {
       @Override
       public void call(String s) {
           System.out.println(s);
       }
   });

5. flatMap():transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable.

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

资源来源

[1]. 给Android开发者的RxJava详解
[2]. RxJava操作符学习笔记
[3].谜之RxJava（三）