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<? super T> onNext)
2.public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)
3.public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Disposable> onSubscribe)
4.public final void subscribe(Observer<? super T> observer);
上面1~3的接口会被封装为Observer的LambdaObserver，然后调用4.subscribe(Observer<? super T> observer)，
Rxjava链式调用
由于RXjava支持链式调用，从而让observable形成一个observable双向链表，Observable的source引用上一个Observable,并创建一个observer给上一个Observable引用，从而使得上一个obserable能够回调回来，形成向上的链条，进而形成一个双向链表。
具体到一个案例：
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).map(new Function<Integer, Student>() {
@Override
public Student apply(Integer id) throws Exception {
return new Student(id);
}
}).flatMap(new Function<Student, ObservableSource<Course>>() {
@Override
public ObservableSource<Course> apply(Student student) throws Exception {
return Observable.just(new Course("math", student), new Course("eng", student));
}
}).lift(new ObservableOperator<String, Course>(){
@Override
public Observer<? super Course> apply(final Observer<? super String> actual) {
return new Observer<Course>() {
@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<String>() {
@Override
public void accept(String score) throws Exception {
}
});
我们来分段分析：
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).map(new Function<Integer, Student>() {
@Override
public Student apply(Integer id) throws Exception {
return new Student(id);
}
}).flatMap(new Function<Student, ObservableSource<Course>>() {
@Override
public ObservableSource<Course> apply(Student student) throws Exception {
return Observable.just(new Course("math", student), new Course("eng", student));
}
}).lift(new ObservableOperator<String, Course>(){
@Override
public Observer<? super Course> apply(final Observer<? super String> actual) {
return new Observer<Course>() {
@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<String>() {
@Override
public void accept(String score) throws Exception {
}
});
会从下到上一直调用subscrible直到最顶层的ObservableOnSubscribe的subscrible
new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
//这个函数是最后一个subscribe
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}
subscrible这个向上调用的过程就是构造Observer的过程，会构造每一层的ObserverWrap,比如最先构造OperatorObserver，最后构造CreateEmitter。
然后下面的代码会从上往下一路调用前面构造的Observer.
public void subscribe(ObservableEmitter<Integer> 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<? extends U> 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
***************************************************/
如需实时查看更多更新文章，请关注公众号"一点码客"，一起探索技术
