RXJava学习笔记

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

一.创建 Observable-被观察者

Observable observable = Observable.create(new Observable.OnSubscribe() { 
    @Override 
    public void call(Subscriber 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) : 将传入的数组或 Iterable 拆分成具体对象后,依次发送出来。
String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 将会依次调用:
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

二.创建 Observer-观察者

Observer observer = new Observer() { 
   @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 subscriber = new Subscriber() { 
   @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 onNextAction = new Action1() { 
   // onNext() 
   @Override 
   public void call(String s) { 
      Log.d(tag, s); 
   }
};
Action1 onErrorAction = new Action1() { 
   // 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() { 
    @Override 
    public void call(Subscriber subscriber) { 
        Drawable drawable = getTheme().getDrawable(drawableRes)); 
        subscriber.onNext(drawable); 
        subscriber.onCompleted(); 
    }
}).subscribe(new Observer() { 
    @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() { 
   @Override 
   public void call(Subscriber subscriber) { 
      Drawable drawable = getTheme().getDrawable(drawableRes)); 
      subscriber.onNext(drawable);
      subscriber.onCompleted(); 
   }
}).subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
.observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
.subscribe(new Observer() { 
   @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() { 
   @Override 
   public Bitmap call(String filePath) { // 参数类型 String 
      return getBitmapFromPath(filePath); // 返回类型 Bitmap 
   } 
}) .subscribe(new Action1() { 
   @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 subscriber = new Subscriber() { 
   @Override 
   public void onNext(Student student) { 
      List 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 subscriber = new Subscriber() { 
    @Override 
    public void onNext(Course course) { 
        Log.d(tag, course.getName()); 
    } 
    ...
};
Observable.from(students) 
.flatMap(new Func1>() { 
    @Override 
    public Observable call(Student student) { 
        return Observable.from(student.getCourses()); 
    } 
}).subscribe(subscriber);
3.变换的原理:lift()

lift() 的内部实现(仅核心代码):

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

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

observable.lift(new Observable.Operator() { 
    @Override 
    public Subscriber call(final Subscriber subscriber) { 
        // 将事件序列中的 Integer 对象转换为 String 对象 
        return new Subscriber() { 
            @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() 变换。你可以这么写:

RXJava学习笔记_第1张图片

第一阶段优化:

RXJava学习笔记_第2张图片

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

RXJava学习笔记_第3张图片

延伸:doOnSubscribe()

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

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

示例代码:


RXJava学习笔记_第4张图片

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

你可能感兴趣的:(RXJava学习笔记)