以实战立足，坚信实践出真知，唯有理论结合实践才能真正理解并掌握所学的知识。
Rxjava:https://github.com/ReactiveX/RxJava
Reativex:https://github.com/ReactiveX
Table of Contents
一.内容
1.提供相关资料，如何集成。
2.学习简单入门使用，类程序语言的"Hello World"。
二.简单集成
1.开发环境
AndroidStudio3.5
classpath 'com.android.tools.build:gradle:3.5.0'
distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip
compileSdkVersion 28
minSdkVersion 21
buildToolsVersion "28.0.3"2.添加依赖
使用的rxjava版本为3.0.0-RC2,由于目前rxandroid还没有升级到3.0，所以采用的版本为2.1.0
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'androidx.appcompat:appcompat:1.0.2'
implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'androidx.test:runner:1.2.0'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
implementation "io.reactivex.rxjava3:rxjava:3.0.0-RC2"
// implementation 'io.reactivex.rxjava2:rxjava:2.2.2'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.0'
}
3.lambda支持(可选)
ladmbda会让代码更加简洁，当然也是可以不使用的。
使用要求:jdk1.8,minSdkVersion 21。
compileOptions {
sourceCompatibility = 1.8
targetCompatibility = 1.8
}
三.使用入门
1.观察者模式
RxJava使用的就是一种观察者模式，所以这里做一下对比。
通用观察者模式:
RxJava观察者模式
RxJava主要有:Obervable(被观察者),Observer(观察者)，subscribe(订阅)，事件序列。与通用的观察者模式所不同的是RxJava把多个事件作为一个序列，有开始(onSubscribe),结束(onComplete),错误(onError),多个事件(onNext()),也就是说在开始之后，结束或者出错之前可以发送多个事件给观察者。有点类似Android的事件序列，从手指按下开始MotionEvent.ACTION_DOWN，手指抬起结束MotionEvent.ACTION_UP，中间会有多个MotionEvent.ACTION_MOVE事件传递。不过这里需要注意的是RxJava中onError()和onComplete()只能调用一个。
2.RxJava使用步骤
响应式编程
数据源产生数据并发发射给订阅了这个数据的观察者。所以主要分为三步：
第一步:创建被观察者(数据源)并生产数据
第二步:创建观察者
第三步:订阅(关系绑定)
1.创建被观察者(数据源)并生产数据
//1.创建被观察者
Observable<Integer> observableByFrom = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Throwable {
//创建数据并发送，包括状态和错误信息
//数据发送
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onNext(4);
emitter.onNext(5);
//异常发送
//emitter.onError(new IllegalArgumentException("Test Exception!"));
//完成事件发送
emitter.onComplete();
//可以理解为监听回调
}
});
//lambda 方式
Observable<Integer> observableByFromWithLambda = Observable.create((emitter -> {
emitter.onNext(1);
emitter.onComplete();
}));ObservableOnSubscribe是一个函数式接口，只有一个void subscribe(@NonNull ObservableEmitter<T> emitter)方法。其中ObservableEmitter是发射器，数据就是通过其进行发送的。值得注意的是RxJava提供了很多的Obervable和ObservableEmitte，这里暂不展开，后续会更新。
2.创建观察者
//2.创建观察者/订阅者
Observer<Integer> observer = new Observer<Integer>() {
/**
* 订阅时被调用
* @param d
*/
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe(Disposable d) called!");
}
/**
* 发送数据时被多次调用
* @param o
*/
@Override
public void onNext(Integer o) {
Log.d(TAG, "nNext(Integer o) called!" + String.valueOf(o));
}
/**
* 出错时被调用
* @param e
*/
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError(Throwable e) called!" + e.toString());
}
/**
* 完成时被调用
*/
@Override
public void onComplete() {
Log.d(TAG, "onComplete called!");
}
};上面代码中因为我们的数据是整形，所以泛型类的参数是Integer。方法 public void onSubscribe(Disposable d)中的形参Disposable的作用是可以通过其判断Obervable与Observer 之间的订阅关系，d.dispose();(取消/解除订阅) d.isDisposed();(是否一已经解除订阅)。
3.订阅(关系绑定)
//订阅,此时触发1步中subscribe方法的执行
observableByFrom.subscribe(observer);
4.示例程序执行结果
5.调用时序图
6.源码解析
首先我们从创建Observable开始，当我们调用Obervable.create(xx)的时候，看看发生了什么，点进源码。
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
//ObservableCreate构造函数
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}可以看到其内部创建了一个使用我们传进去的source参数的ObservableCreate对象，在其构造方法中，把source赋值给了成员变量记录，之后返回 RxJavaPlugins.onAssembly后的Obserable对象。
然后我们再来看下observableFrom.subscribe(observer);的调用过程。
可以看到在1处做了参数的校验，在2处执行实际的订阅，所以再来看下2处的调用。
@Override
protected void subscribeActual(Observer<? super T> observer) {
//1.构建发射器
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
//2.调用Observer的onSubscribe方法
observer.onSubscribe(parent);
try {
//3.调用Observable的subscribe方法
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}结合上边的时序图，整个调用流程非常清晰的展示在我们面前。
1.在订阅的方法中，创建了发射器parent，
2. 调用了Observer的onSubscribe方法，并把发射器parent作为形参传递进去，这里要说明一下，CreateEmitter实现了Disposable接口，所以在Observer的onSubscribe方法中接收到的参数为Disposable。
3.调用source也就是(Observable)的subscribe方法，并把发射器parent传递进去。
4.执行之前我们在subscribe(ObservableEmitter<Integer> emitter)写的代码。
到这里整个订阅的流程就梳理完毕了，接下来我们再来看下subscribe(ObservableEmitter<Integer> emitter)中发射数据的代码调用。
首先调用了多次emitter.onNext(T value);
@Override
public void onNext(T t) {
//1.参数校验
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
//2.判断是否解绑或者终止，没有的话调用onNext(t);
if (!isDisposed()) {
observer.onNext(t);
}
}在这段代码中做了两件事:1.参数校验，不满足的话直接调用onError,并在其内部调用dispose。 2.判断是否解绑或终止，然后调用observer.onNext(t)方法，此时数据就传递给了Observer。
@Override
public void onError(Throwable t) {
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public boolean tryOnError(Throwable t) {
if (t == null) {
t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
}
if (!isDisposed()) {
try {
observer.onError(t);
} finally {
dispose();
}
return true;
}
return false;
}接着调用了emitter.onComplete();
@Override
public void onComplete() {
//1.判断是否解绑或者终止，没有的话调用onComplete();
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}在这段代码中做了一件事:1.判断是否解绑或终止，然后调用observer.onComplete()方法，最后调用dispose。 所以由此可知在调用onError和onComplete之后是无法在继续发送数据的了。至此示例的源码解析完成。
四.总结
本文只是一个 基于RxJava3的入门级文章，后续会从入门->进阶->掌握的流程来更新。
