RxJava学习笔记一

RxJava GitHub主页:https://github.com/ReactiveX/RxJava

RxJava是什么

RxJava是Netflix推出的一个基于JVM的Microsoft Reactive Extensions 扩展,提供Java, Scala, Clojure, 和 Groovy语言实现,Netflix也是美国很牛X的一个公司,《纸牌屋》就是该公司的自制剧之一,这是题外话,我们看一下 RxJava在 GitHub 主页上的简介。

RxJava is a Java VM implementation of [Reactive Extensions]( http://reactivex.io ): a library for composing asynchronous and event-based programs by using observable sequences.

It extends the [observer pattern]( http://en.wikipedia.org/wiki/Observer_pattern ) to support sequences of data/events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety and concurrent data structures.

RxJava是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库。它采用观察者模式来支持数据/事件的序列,增加了操作符,允许以声明的方式(链式语法)将异步操作序列组合在一起。

Reactive Extensions (Rx) 最初是由微软在.Net中实现的一个综合了异步和基于事件驱动编程的库包。开发者可以用Observables来表达异步数据流,使用LinQ操作查询异步数据流,使用Schedulers参数化异步数据流中并发。2012年Netflix为了应对不断增长的业务需求开始将.NET Rx迁移到JVM上面。并于2013年2月份正式向外展示了RxJava。

除了RxJava和Rx .Net,基于Rx还有许多其它项目如RxJS、RxCpp、RxPy等等。

RxJava简单的说它就是一个Java中处理异步任务的库,允许我们用简介的语法操作复杂的异步业务逻辑。

为什么使用RxJava

异步处理简洁

RxJava流行的主要原因都要归于它处理异步任务逻辑的简洁。从上面我们也知道它的主要目的也是用于处理异步任务。在Android中谷歌官方为了处理异步业务提供了两个类AsyncTask 和Handler,在RxJava没有流行之间,如果不想使用这两个类,开发者要自定义一个回调来更新UI。可能有些开发者说了,不使用这两个类,还有更简单的方式runOnUiThread,事实上runOnUiThread也是使用的Handler机制实现的。即使这个不说我们在从网络获取数据的时候,也都要开启一个子线程才能发起网络请求。如果我们使用RxAndroid来实现这个操作,就简洁许多了。

Observable.create(new Observable.OnSubscribe() {
	@Override
	public void call(Subscriber subscriber) {
		//子线程发起网络请求
		String result = HttpUtils.getInstance().get(url);
		subscriber.onNext(result);
	}
}).observeOn(AndroidSchedulers.mainThread()).subscribeOn(Schedulers.io()).subscribe(new Subscriber() {
	@Override
	public void onCompleted() {
	}
	@Override
	public void onError(Throwable e) {

	}
	@Override
	public void onNext(String s) {
		//主线程更新UI
		textView.setText(s);
	}
});

有没有这种感觉,所有的业务操作一气呵成。RxJava采用链式语法,结构上看上去非常优雅,允许用户连续设计各种行为,从而实现按人的惯性思维进行快速开发。接触过jQuery的开发者,多数都会被jQuery中链式调用的优雅所折服,现在RxJava也是采用了链式语法,不得不说这也是它可以风靡的主要原因之一。

提供了丰富的操作符

RxJava提供了丰富的操作符,如果现有的操作符满足不了需求,还可以自定义操作符。下面操作符节选自知乎中谁来讲讲Rxjava、rxandroid中的操作符的作用? 的回答:

创建操作:用于创建Observable的操作符

  • Create — 通过调用观察者的方法从头创建一个Observable
  • Defer — 在观察者订阅之前不创建这个Observable,为每一个观察者创建一个新的Observable
  • Empty/Never/Throw — 创建行为受限的特殊Observable
  • From — 将其它的对象或数据结构转换为Observable
  • Interval — 创建一个定时发射整数序列的Observable
  • Just — 将对象或者对象集合转换为一个会发射这些对象的Observable
  • Range — 创建发射指定范围的整数序列的Observable
  • Repeat — 创建重复发射特定的数据或数据序列的Observable
  • Start — 创建发射一个函数的返回值的Observable
  • Timer — 创建在一个指定的延迟之后发射单个数据的Observable

变换操作:对Observable发射的数据进行变换,详细解释可以看每个操作符的文档

  • Buffer — 缓存,可以简单的理解为缓存,它定期从Observable收集数据到一个集合,然后把这些数据集合打包发射,而不是一次发射一个
  • FlatMap — 扁平映射,将Observable发射的数据变换为Observables集合,然后将这些Observable发射的数据平坦化的放进一个单独的Observable,可以认为是一个将嵌套的数据结构展开的过程。
  • GroupBy — 分组,将原来的Observable分拆为Observable集合,将原始Observable发射的数据按Key分组,每一个Observable发射一组不同的数据
  • Map — 映射,通过对序列的每一项都应用一个函数变换Observable发射的数据,实质是对序列中的每一项执行一个函数,函数的参数就是这个数据项
  • Scan — 扫描,对Observable发射的每一项数据应用一个函数,然后按顺序依次发射这些值
  • Window — 窗口,定期将来自Observable的数据分拆成一些Observable窗口,然后发射这些窗口,而不是每次发射一项。类似于Buffer,但Buffer发射的是数据,Window发射的是Observable,每一个Observable发射原始Observable的数据的一个子集

过滤操作:从Observable发射的数据中进行选择

  • Debounce — 只有在空闲了一段时间后才发射数据,通俗的说,就是如果一段时间没有操作,就执行一次操作
  • Distinct — 去重,过滤掉重复数据项
  • ElementAt — 取值,取特定位置的数据项
  • Filter — 过滤,过滤掉没有通过谓词测试的数据项,只发射通过测试的
  • First — 首项,只发射满足条件的第一条数据
  • IgnoreElements — 忽略所有的数据,只保留终止通知(onError或onCompleted)
  • Last — 末项,只发射最后一条数据
  • Sample — 取样,定期发射最新的数据,等于是数据抽样,有的实现里叫ThrottleFirst
  • Skip — 跳过前面的若干项数据
  • SkipLast — 跳过后面的若干项数据
  • Take — 只保留前面的若干项数据
  • TakeLast — 只保留后面的若干项数据

组合操作:将多个Observable组合成一个单一的Observable

  • And/Then/When — 通过模式(And条件)和计划(Then次序)组合两个或多个Observable发射的数据集
  • CombineLatest — 当两个Observables中的任何一个发射了一个数据时,通过一个指定的函数组合每个Observable发射的最新数据(一共两个数据),然后发射这个函数的结果
  • Join — 无论何时,如果一个Observable发射了一个数据项,只要在另一个Observable发射的数据项定义的时间窗口内,就将两个Observable发射的数据合并发射
  • Merge — 将两个Observable发射的数据组合并成一个
  • StartWith — 在发射原来的Observable的数据序列之前,先发射一个指定的数据序列或数据项
  • Switch — 将一个发射Observable序列的Observable转换为这样一个Observable:它逐个发射那些Observable最近发射的数据
  • Zip — 打包,使用一个指定的函数将多个Observable发射的数据组合在一起,然后将这个函数的结果作为单项数据发射

错误处理:从错误通知中恢复

  • Catch — 捕获,继续序列操作,将错误替换为正常的数据,从onError通知中恢复
  • Retry — 重试,如果Observable发射了一个错误通知,重新订阅它,期待它正常终止

辅助操作:用于处理Observable的操作符

  • Delay — 延迟一段时间发射结果数据
  • Do — 注册一个动作占用一些Observable的生命周期事件,相当于Mock某个操作
  • Materialize/Dematerialize — 将发射的数据和通知都当做数据发射,或者反过来
  • ObserveOn — 指定观察者观察Observable的调度程序(工作线程)
  • Serialize — 强制Observable按次序发射数据并且功能是有效的
  • Subscribe — 收到Observable发射的数据和通知后执行的操作
  • SubscribeOn — 指定Observable应该在哪个调度程序上执行
  • TimeInterval — 将一个Observable转换为发射两个数据之间所耗费时间的Observable
  • Timeout — 添加超时机制,如果过了指定的一段时间没有发射数据,就发射一个错误通知
  • Timestamp — 给Observable发射的每个数据项添加一个时间戳
  • Using — 创建一个只在Observable的生命周期内存在的一次性资源

条件和布尔操作:用于单个或多个数据项,也可用于Observable

  • All — 判断Observable发射的所有的数据项是否都满足某个条件
  • Amb — 给定多个Observable,只让第一个发射数据的Observable发射全部数据
  • Contains — 判断Observable是否会发射一个指定的数据项
  • DefaultIfEmpty — 发射来自原始Observable的数据,如果原始Observable没有发射数据,就发射一个默认数据
  • SequenceEqual — 判断两个Observable是否按相同的数据序列
  • SkipUntil — 丢弃原始Observable发射的数据,直到第二个Observable发射了一个数据,然后发射原始Observable的剩余数据
  • SkipWhile — 丢弃原始Observable发射的数据,直到一个特定的条件为假,然后发射原始Observable剩余的数据
  • TakeUntil — 发射来自原始Observable的数据,直到第二个Observable发射了一个数据或一个通知
  • TakeWhile — 发射原始Observable的数据,直到一个特定的条件为真,然后跳过剩余的数据

算术和聚合操作:

  • Average — 计算Observable发射的数据序列的平均值,然后发射这个结果
  • Concat — 不交错的连接多个Observable的数据
  • Count — 计算Observable发射的数据个数,然后发射这个结果
  • Max — 计算并发射数据序列的最大值
  • Min — 计算并发射数据序列的最小值
  • Reduce — 按顺序对数据序列的每一个应用某个函数,然后返回这个值
  • Sum — 计算并发射数据序列的和

连接操作:一些有精确可控的订阅行为的特殊Observable

  • Connect — 指示一个可连接的Observable开始发射数据给订阅者
  • Publish — 将一个普通的Observable转换为可连接的
  • RefCount — 使一个可连接的Observable表现得像一个普通的Observable
  • Replay — 确保所有的观察者收到同样的数据序列,即使他们在Observable开始发射数据之后才订阅

转换操作:

  • To — 将Observable转换为其它的对象或数据结构
  • Blocking 阻塞Observable的操作符

操作符决策树

  • 直接创建一个Observable(创建操作)
  • 组合多个Observable(组合操作)
  • 对Observable发射的数据执行变换操作(变换操作)
  • 从Observable发射的数据中取特定的值(过滤操作)
  • 转发Observable的部分值(条件/布尔/过滤操作)
  • 对Observable发射的数据序列求值(算术/聚合操作)

因为记录笔记,操作符就罗列出来了。实际开发中不需要都记住,掌握常用的几个(如,just, map,flatMap和filter等等),其它的使用时查阅文档即可,用几次自然就掌握了。

下面是利用操作符遍历输出一个二维数组,这里就可以看出RxJava操作符的便利之处了。

String array[][]={{"a0","a1"},{"b0","b1"},{"c0","c1","c2"}};
Observable.from(array).flatMap(new Func1>() {
	@Override
	public Observable call(String[] t) {
		return Observable.from(t);
	}
}).subscribe(new Action1() {
	@Override
	public void call(String t) {
		System.out.println(t);
	}
});

RxJava入门

链式调用

Observable.create(new OnSubscribe() {
	@Override
	public void call(Subscriber subscriber) {
		subscriber.onNext("hello world!");
		subscriber.onCompleted();
	}
}).subscribe(new Subscriber() {
	@Override
	public void onNext(String t) {
		System.out.println("onNext:"+t);
	}
	@Override
	public void onCompleted() {
		System.out.println("onCompleted");
	}
	@Override
	public void onError(Throwable e) {
	}
});

非链式调用

//订阅者
Subscriber subscriber=new Subscriber() {
	@Override
	public void onNext(String t) {
		System.out.println(t);//小二上酒!
	}
	@Override
	public void onError(Throwable e) {
		
	}
	@Override
	public void onCompleted() {
		System.out.println("onCompleted");
	}
};
//被观察者
Observable observable=Observable.create(new OnSubscribe() {
	@Override
	public void call(Subscriber subscriber) {
		subscriber.onNext("小二上酒!");
		subscriber.onCompleted();
	}
});
observable.subscribe(subscriber);

自定义代码实现RxJava HelloWorld程序

如果自定义实现RxJava入门这种调用方式,OnSubscribe是一个关键所在,它是连接观察者(订阅者)与被观察者的一个纽带。

Onsubscribe是一个接口,接口中有一个call方法,将Observer观察者(订阅者)作为入参传入,Observer就可以在call方法中将数据回调出去,然后再在Observable调用subscribe方法时实例化Observer,就可以获得call方法中相应的数据了。

Observable代码如下:

public class Observable {

	final OnSubscribe onSubscribe;

	protected Observable(OnSubscribe f) {
		this.onSubscribe = f;
	}

	public static  Observable create(OnSubscribe f) {
		return new Observable(f);
	}

	public final void subscribe(Observer observer) {
		onSubscribe.call(observer);
	}
	
	public interface OnSubscribe extends Action<observer> {
    }
}

//Action
public interface Action {
	void call(T t);
}
</observer

Observer源码如下:

public interface Observer {
	void onUpdate(T t);
}

测试代码如下:

//链式调用
Observable.create(new OnSubscribe() {
	@Override
	public void call(Observer observer) {
		observer.onUpdate("hello world");
	}
}).subscribe(new Observer() {
	@Override
	public void onUpdate(String t) {
		System.out.println(t);//hello world
	}
});

//非链式调用
Observable observable=Observable.create(new OnSubscribe() {
	@Override
	public void call(Observer observer) {
		observer.onUpdate("hello world");
	}
});

Observer observer=new Observer(){
	@Override
	public void onUpdate(String t) {
		System.out.println(t);//hello world
	}
} ;
observable.subscribe(observer);

小结

本篇博客基本上就是一个学习RxJava的引言,当然了在正式学习RxJava之前有必要熟悉一下观察者模式。有关操作符的使用以及针对Android开发的RxAndroid准备另起一篇博客记录一下。也许本文的示例太过简单,没有很强的说服力,如果想系统学习一下RxJava,可以在GitHub上下载下来的示例对比着宝石图运行一下。每一个操作符都配备了一张宝石图,它对事件处理时的顺序、方式以及什么时候结束描述的非常直观。

参考资料

给 Android 开发者的 RxJava 详解

RxJava系列1(简介)

Rx (Reactive Extensions)介绍

https://www.zhihu.com/question/32209660/answer/63984697

评论

您确定要删除吗?删除之后不可恢复