Android开发中，有一个框架Rxjava大家做过android开发的应该都比较熟悉了，它是一个异步响应框架，能够快速在主线程和其它线程之间进行切换，并且在处理比较复杂的逻辑时候依然能够清晰地展示其操作逻辑，所以在开发过程中经常使用到，下面我就简单讲下Rxjava的一些个人理解。
Rxjava使用：
//创建Observable对象，实现subscribe回调
Observable observable=Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("xxx");//Observer onNext回调的实现
emitter.onNext("xxx");
emitter.onComplete();//Observer onNext回调的实现
}
});
//创建Observer对象
Observer<String> observer=new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG,"onSubscribe");
}
@Override
public void onNext(String value) {
Log.e(TAG,"onNext:"+value);
}
@Override
public void onError(Throwable e) {
Log.e(TAG,"onError="+e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG,"onComplete()");
}
};
//实现订阅关系
observable.subscribe(observer);
注：这里通过被观察者订阅观察者的方式实现了两者的关联，这样在被观察者中调用onNext，onComplete等方法时候，值就被传递到观察者响应的回调方法中去了。
上面说到的是旧的实现方式，现在一般都改为了链式调用方法，如下：
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("xxx");//Observer onNext回调的实现
emitter.onNext("xxx");
emitter.onComplete();//Observer onNext回调的实现
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG,"onSubscribe");
}
@Override
public void onNext(String value) {
Log.e(TAG,"onNext:"+value);
}
@Override
public void onError(Throwable e) {
Log.e(TAG,"onError="+e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG,"onComplete()");
}
});
通过对比就很容易发现，链式调用其实就是旧方式调用的组合
那么如何快速切换主线程与其他线程了，这里就需要使用到Schedulers和AndroidSchedules了，具体使用如下：
.SubcribleOn(Schedulers.io()) 被观察者中的操作在子线程操作
.ObserveOn(AndroidSchedules.mainThread()) 观察者中操作在主线程中操作
结合上面代码使用，如下：
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("xxx");//Observer onNext回调的实现
emitter.onNext("xxx");
emitter.onComplete();//Observer onNext回调的实现
}
}) .subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG,"onSubscribe");
}
@Override
public void onNext(String value) {
Log.e(TAG,"onNext:"+value);
}
@Override
public void onError(Throwable e) {
Log.e(TAG,"onError="+e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG,"onComplete()");
}
});
从上面的代码可以看得到当我在被观察者Observable中调用onNext和onComplete方法后，观察者Observer中就会在相应方法中立即得到相应，这就是响应式的方法，至于异步就是上面说的主线程与其他线程的切换，这样Rxjava还可以代替Handler和AsynTask进行相应操作。
那么他们到底是如何实现这个订阅关系的呢，这还需要从源码的方面分析下：
/**
* 创建被观察者(Observable)的创建和发送信息给观察者，对应最上面使用方式里面旧方法的第一步操作
**/
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext("xxx");
emitter.onNext("xxx");
emitter.onComplete();
}
})
/**
* 源码分析：Observable.create(new ObservableOnSubscribe<Integer>(){...}）
**/
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
...
// 仅贴出关键源码
return new ObservableCreate<T>(source);
// 创建ObservableCreate类对象 ->>分析1
// 注：传入source对象（即 我们手动创建的ObservableOnSubscribe对象）
}
/**
* 分析1：new ObservableCreate<T>(source)
**/
public final class ObservableCreate<T> extends Observable<T> {
// ObservableCreate类 = Observable的子类
...
// 仅贴出关键源码
final ObservableOnSubscribe<T> source;
// 构造函数
// 传入了传入source对象 = 手动创建的ObservableOnSubscribe对象
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
/**
* 重点关注：复写了subscribeActual（）
* 作用：订阅时，通过接口回调 调用被观察者（Observerable） 与 观察者（Observer）的方法
**/
@Override
protected void subscribeActual(Observer<? super T> observer) {
// 1. 创建1个CreateEmitter对象（封装成1个Disposable对象）
// 作用：发射事件
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
// 2. 调用观察者（Observer）的onSubscribe（）
// onSubscribe（）的实现 = 使用步骤2（创建观察者（Observer））时复写的onSubscribe(）
observer.onSubscribe(parent);
try {
// 3. 调用source对象的subscribe（）
// source对象 = 使用步骤1（创建被观察者（Observable））中创建的ObservableOnSubscribe对象
// subscribe（）的实现 = 使用步骤1（创建被观察者（Observable））中复写的subscribe（）->>分析2
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
/**
* 分析2：emitter.onNext("1");
* 此处仅讲解subscribe（）实现中的onNext（）
* onError（）、onComplete()类似，此处不作过多描述
**/
static final class CreateEmitter<T> extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
...
// 仅贴出关键代码
// onNext（）源码分析
@Override
public void onNext(T t) {
// 注：发送的事件不可为空
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
// 若无断开连接（调用Disposable.dispose()），则调用观察者（Observer）的同名方法 = onNext（）
// 观察者的onNext（）的内容 = 使用步骤2中复写内容
if (!isDisposed()) {
observer.onNext(t);
}
}
// onError（）、onComplete()类似，此处不作过多描述
// 特别说明：调用该2方法，最终都会自动调用dispose()，即断开观察者 & 被观察者的连接
@Override
public void onError(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();
}
} else {
RxJavaPlugins.onError(t);
}
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}从上面的源码中可以看到调用emitter.onNext方法和onComplete方法最终都调用到Observer中的onNext和onComplete中去
接下来就是订阅的实现：
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG,"onSubscribe");
}
@Override
public void onNext(String value) {
Log.e(TAG,"onNext:"+value);
}
@Override
public void onError(Throwable e) {
Log.e(TAG,"onError="+e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG,"onComplete()");
}
});
/**
* 源码分析：Observer类
**/
public interface Observer<T> {
// 注：Observer本质 = 1个接口
// 接口内含4个方法，分别用于 响应 对应于被观察者发送的不同事件
void onSubscribe(@NonNull Disposable d); // 内部参数：Disposable 对象，可结束事件
void onNext(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();
}
/**
* 特别说明：Subscriber类
* 定义：RxJava 内置的一个实现了 Observer 的抽象类
* 作用：扩展Observer 接口 = 新增了2个方法 =
* 1. onStart()：在还未响应事件前调用，用于初始化工作
* 2. unsubscribe()：用于取消订阅。在该方法被调用后，观察者将不再接收 & 响应事件
* 注：调用该方法前，先使用 isUnsubscribed() 判断状态，确定被观察者Observable是否还持有观察者Subscriber的引用；若引用不能及时释放，就会出现内存泄露
* 使用方式：与Observer使用几乎相同（实质上，Observer总是会先被转换成Subscriber再使用）
**/
Subscriber<String> subscriber = new Subscriber<Integer>() {
@Override
public void onSubscribe(Subscription s) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "对Next事件作出响应" + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
};
/**
* 源码分析：Observable.subscribe（observer）
* 说明：该方法属于 Observable 类的方法（注：传入1个 Observer 对象）
**/
@Override
public final void subscribe(Observer<? super T> observer) {
...
// 仅贴出关键源码
subscribeActual(observer);
// 继续往下看：分析1
}
/**
* Observable.subscribeActual(observer)
* 说明：属于抽象方法，由子类实现；此处的子类 = 步骤1创建被观察者（Observable）时创建的ObservableCreate类
* 即 在订阅时，实际上是调用了步骤1创建被观察者（Observable）时创建的ObservableCreate类里的subscribeActual（）
* 此时，你应该回头看上面的步骤1里的subscribeActual()，应该能理解RxJava的整个订阅流程了。
**/
protected abstract void subscribeActual(Observer<? super T> observer);在这里就可以看到订阅实际上从源码角度看又回到创建Observable时候ObservableCreate类，并将Observer对象传递过去，这样在Observable中调用onNext等方法，实际上是调到了Observer中相应方法中去了。现实中关于Rxjava的使用在应用开发的过程中基本上都会使用到，现在一种比较好的结合使用方式是Retrofit+mvp+Rxjava（Retrofit可以添加Rxava作为适配器，而MVP开发模式可以很好地将UI和逻辑区分），这里不做讲解。
以上是个人对Rxjava的一些认识，写的比较简单，各位如果有什么好的建议，可以提出，本人将虚心接受。