一图理解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<? 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
***************************************************/

如需实时查看更多更新文章，请关注公众号"一点码客"，一起探索技术