一图理解Rxjava2底层机制
Rxjava是一种响应式编程实现，响应式编程就是定义业务逻辑关系
比如正常的编程b = a + 1；这个是一个指令。执行到这里的时候，b的值已经被计算出来了
如果b <= a + 1;这是定义b和a的关系，具体的值还没有，直到 a.onNext(1);
Rxjava 订阅和事件分发机制
Rxjava其实就是一个通过Observable的subcribe向上通知和onNext向下汇报事件的过程，最后交给observer处理。
具体调用流程如下：
1.public final Disposable subscribe(Consumer onNext)
2.public final Disposable subscribe(Consumer onNext, Consumer onError)
3.public final Disposable subscribe(Consumer onNext, Consumer onError,
Action onComplete, Consumer onSubscribe)
4.public final void subscribe(Observer observer);
上面1~3的接口会被封装为Observer的LambdaObserver，然后调用4.subscribe(Observer observer)，
Rxjava链式调用
由于RXjava支持链式调用，从而让observable形成一个observable双向链表，Observable的source引用上一个Observable,并创建一个observer给上一个Observable引用，从而使得上一个obserable能够回调回来，形成向上的链条，进而形成一个双向链表。
具体到一个案例：
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).map(new Function() {
@Override
public Student apply(Integer id) throws Exception {
return new Student(id);
}
}).flatMap(new Function>() {
@Override
public ObservableSource apply(Student student) throws Exception {
return Observable.just(new Course("math", student), new Course("eng", student));
}
}).lift(new ObservableOperator(){
@Override
public Observer apply(final Observer actual) {
return new Observer() {
@Override
public void onSubscribe(Disposable d) {
actual.onSubscribe(d);
}
@Override
public void onComplete() {
actual.onComplete();
}
@Override
public void onError(Throwable e) {
actual.onError(e);
}
@Override
public void onNext(Course course) {
actual.onNext(course.getScore());
}
};
}
}).subscribe(new Consumer() {
@Override
public void accept(String score) throws Exception {
}
});
我们来分段分析：
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).map(new Function() {
@Override
public Student apply(Integer id) throws Exception {
return new Student(id);
}
}).flatMap(new Function>() {
@Override
public ObservableSource apply(Student student) throws Exception {
return Observable.just(new Course("math", student), new Course("eng", student));
}
}).lift(new ObservableOperator(){
@Override
public Observer apply(final Observer actual) {
return new Observer() {
@Override
public void onSubscribe(Disposable d) {
actual.onSubscribe(d);
}
@Override
public void onComplete() {
actual.onComplete();
}
@Override
public void onError(Throwable e) {
actual.onError(e);
}
@Override
public void onNext(Course course) {
actual.onNext(course.getScore());
}
};
}
})
在调用subscrible之前，只构造了source这个单向链表
当执行最后面的subscribe
.subscribe(new Consumer() {
@Override
public void accept(String score) throws Exception {
}
}); 会从下到上一直调用subscrible直到最顶层的ObservableOnSubscribe的subscrible
new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
//这个函数是最后一个subscribe
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
} subscrible这个向上调用的过程就是构造Observer的过程，会构造每一层的ObserverWrap,比如最先构造OperatorObserver，最后构造CreateEmitter。
然后下面的代码会从上往下一路调用前面构造的Observer.
public void subscribe(ObservableEmitter e) throws Exception {
//如果我们将这个e保存为全局变量，就可以在任意地点任意时间激发事件了
e.onNext(1);
e.onNext(2);
e.onNext(3);
} 调用图如下：
concatMap如何保证事件的时序
我们知道flatmap和concatMap都支持新增observable发射新的事件, 但是flatmap没法保证时序，而concatMap保证时序
concatmap保证时序的原因是它每次调用Obserable.subscribe后会等到onSubscribe调用onComplete,然后才会调用下一个Obserable.subscribe，从而保证了时序。
具体源码如下：
class SourceObserver {
@Override
public void onNext(T t) {
if (done) {
return;
}
if (fusionMode == QueueDisposable.NONE) {
//先都放在队列
queue.offer(t);
}
//只能一个一个处理
drain();
}
void drain() {
if (getAndIncrement() != 0) {
return;
}
for (;;) {
if (disposed) {
queue.clear();
return;
}
//保证了只能一个一个处理
if (!active) {
boolean d = done;
T t;
try {
t = queue.poll();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
dispose();
queue.clear();
downstream.onError(ex);
return;
}
boolean empty = t == null;
if (d && empty) {
disposed = true;
downstream.onComplete();
return;
}
if (!empty) {
ObservableSource o;
active = true;
o.subscribe(inner);
}
}
if (decrementAndGet() == 0) {
break;
}
}
}
InnerObserver {
@Override
public void onComplete() {
parent.innerComplete();
}
}
void innerComplete() {
active = false;
//drain会执行下一个source.subscribe
drain();
}
附录
Rxjava是一个链式数据处理的框架，且通过observable和observer两种链接组件，能够将其他observable和observer像搭积木的方式组合成复杂的功能，实现模块化和解耦合的效果。
Rxjava的常用操作
/**************************************************
* 本文来自CSDN博主"一点码客"，喜欢请顶部点击关注
* 转载请标明出处:http://blog.csdn.net/itchosen
***************************************************/
如需实时查看更多更新文章，请关注公众号"一点码客"，一起探索技术
