RxJava2流程分析2-事件流

概述

RxJava是一个用于使用可观察的序列组合异步和基于事件的程序的库,其主要是用于异步的、可线程切换的、可观察序列事件,那么这个事件序列倒是是什么样的?(注:RxJava版本:2.2.7)

目的

1.事件序列是怎么形成的
2.事件的流向

分析

分析的代码

Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            Log.d("RxJava:", "subscribe:");
            emitter.onNext(1);
            emitter.onComplete();
        }
    }).map(new Function<Integer, String>() {
        @Override
        public String apply(Integer integer) throws Exception {
            Log.d("RxJava:", "map1:");
            return integer.toString();
        }
    }).map(new Function<String, String>() {
        @Override
        public String apply(String s) throws Exception {
            Log.d("RxJava:", "map2:");
            return s;
        }
    }).subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {

        }
        @Override
        public void onNext(String s) {
            Log.d("RxJava:", "onNext:");
        }
        @Override
        public void onError(Throwable e) {

        }
        @Override
        public void onComplete() {

        }
    });

运行结果：
2020-01-07 17:17:51.527 20237-20237/com.wkkun.litho D/RxJava:: subscribe:
2020-01-07 17:17:51.527 20237-20237/com.wkkun.litho D/RxJava:: map1:
2020-01-07 17:17:51.527 20237-20237/com.wkkun.litho D/RxJava:: map2:
2020-01-07 17:17:51.527 20237-20237/com.wkkun.litho D/RxJava:: onNext:

首先分析操作符map
Observable.class

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
	//判空
    ObjectHelper.requireNonNull(mapper, "mapper is null");
    return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}

RxJavaPlugins.onAssembly()前面已经分析过了是hook函数,默认不实现,可忽略,
所以此处返回 new ObservableMap<T, R>(this, mapper)

ObservableMap类

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {...}

ObservableMap继承AbstractObservableWithUpstream所以先看下类AbstractObservableWithUpstream

AbstractObservableWithUpstream类

abstract class AbstractObservableWithUpstream<T, U> extends Observable<U>
 implements HasUpstreamObservableSource<T> {

/** The source consumable Observable. */
protected final ObservableSource<T> source;

/**
 * Constructs the ObservableSource with the given consumable.
 * @param source the consumable Observable
 */
AbstractObservableWithUpstream(ObservableSource<T> source) {
	//构造函数 保存给定的ObservableSource
    this.source = source;
}

@Override
public final ObservableSource<T> source() {
    return source;
}
}

AbstractObservableWithUpstream代码很简单就是构造函数保存了给定的ObservableSource对象,
但是需要注意的是该类继承Observable,所以ObservableMap也是一个Observable实例
接着获取看ObservableMap类

ObservableMap类

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> function;

public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
	//1
    super(source);
    this.function = function;
}

@Override
public void subscribeActual(Observer<? super U> t) {
	//2
    source.subscribe(new MapObserver<T, U>(t, function));
}
...
}

上述1处,调用父类的构造函数,存储ObservableSource,而前面我们看到 map方法的实现是
Observable{
...
 public final <R> Observable<R> map(Function<? super T, ? extends R> mapper){
	return new ObservableMap<T, R>(this, mapper);
}
...
}

所以ObservableMap会存储调用map方法的Observable实例,

上述2处 我们知道ObservableMap是一个Observable实例,
所以实现Observable的抽象方法subscribeActual(详细的我们在第一篇中已经说过了)
subscribeActual方法中,使用存储的Observable实例进行订阅包装后的Observer
我们接着先看下MapObserver类,在回头总结

MapObserver类

//BasicFuseableObserver继承与Observer
 static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
    final Function<? super T, ? extends U> mapper;

    MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
		//将 actual存储为downstream(父类的构造函数)
        super(actual);
		//存储转换的函数
        this.mapper = mapper;
    }

    @Override
    public void onNext(T t) {
		//在onError 和onComplete方法中会设置 done = true
        if (done) {
            return;
        }
		//上述分析的代码中 sourceMode请求到的都是NONE
        if (sourceMode != NONE) {
            downstream.onNext(null);
            return;
        }

        U v;

        try {
			//调用存储的Function方法对传进来的参数t进行转换为v
            v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
        } catch (Throwable ex) {
            fail(ex);
            return;
        }
		//调用下游的onNext(v)
        downstream.onNext(v);
    }
	//先行忽略 分析的代码中requestFusion请求得到都是NONE
    @Override
    public int requestFusion(int mode) {
        return transitiveBoundaryFusion(mode);
    }
	//先行忽略 上述分析的代码不会调用
    @Nullable
    @Override
    public U poll() throws Exception {
        T t = qd.poll();
        return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
    }
}

我们现在先主要关注 事件流的 调用 先行忽略未用到的关于QueueFuseable方面的内容,后面的文章会详细的说明

**

现在我们得到了关于map操作符的大致流程

**

1.生成一个ObservableMap并存储调用map的Observable上流数据源
2.subscribe(Observer)订阅
3.包装Observer生成new MapObserver<T, U>(Observer, function),当调用onNext(T t)应用给定的转换函数
4.使用存储的Observable调用subscribe(Observer)方法,即是source.subscribe(new MapObserver<T, U>(t, function));

现在map的大概流程分析,接下来模拟最上面代码整个事件的流程

整个代码流程:
new ObservableMap<T, R>(new ObservableMap<T, R>(new ObservableCreate<T>(new ObservableOnSubscribe(){}), Function mapper), Function mapper).subscribe(new Observer(){})
回调订阅流程如下:
ObservableCreate.subscribe(new MapObserver<T, U>((new MapObserver<T, U>(new new Observer(){}, function),function));

一步步拆分

生成Observable过程,最终生成Observable C
Observable A = new ObservableCreate<T>(new ObservableOnSubscribe(){})
Observable B = new ObservableMap<T, R>(A, Function mapper)
Observable C = new ObservableMap<T, R>(B, Function mapper)

订阅过程
Observer D = new Observer(){}
C.subscribe(D)

拆分C.subscribe(D),最终生成一个经过两个包装的Observer,然后源发射源进行订阅该Observer
C.subscribe(D)
	->内部调用
	Observer E =new MapObserver<T, U>(D, function)
	B.subscribe(E)
		->内部调用
		A.subscribe(new MapObserver<T, U>(E, function))

整个代码流程:

通过上面的分析可以得到,每个操作符既是一个观察者,订阅上面的数据流,也是一个被观察者,发送经过其处理的数据源,
所以:RxJava形成的可观察事件序列,除了首尾,中间事件节点,都是既是观察者又是被观察者,其向上订阅,向下分发数据,
我们可以将RxJava形成的事件序列可称为数据流,数据从最初的Observable流向最后的Observer,
所以可以称最初的Observable为上游,最后的Observer为下游

总结:

1.RxJava形成的可观察事件序列是一个数据流,最初的Observable为上游,最后的Observer为下游
2.数据从上游流向下流,订阅从下游向上游订阅
3.数据流中间节点,每一个节点既是观察者也是被观察者