Android之Rxjava2-源码解析

}

}

这个类超级简单，就是把上游的事件发送到下游SingleObserver，比如我们在实例中，Single.just(1)就相当于new SingleJust(1)，所以在这儿，value=1，然后调用subscribeActual方法，SingleObserver是一个接口，有三个方法，也是我们回调里的三个方法

public interface SingleObserver {
void onSubscribe(@NonNull Disposable d);

void onSuccess(@NonNull T t);

void onError(@NonNull Throwable e);
}

在subscribeActual方法中，先observer.onSubscribe(Disposables.disposed());，需要注意的是，这也是just方法独有的，它直接在onSubscribe方法里就Disposables.disposed了，这个方法在后面讲，这是取消了事件订阅，因为它只会发一次，到了这就意味着已经不用订阅了。然后再调用observer.onSuccess方法，直接把value传递了过去。

Map操作符的源码

再来看增加一个操作符的源码，就用最常用的map，其实操作符一通百通

Single.just(1)
.map(new Function<Integer, Integer>() {
@Override
public Integer apply(Integer integer) throws Exception {
return integer+2;
}
})
.subscribe(…);

直接看map的源码

public final Single map(Function<? super T, ? extends R> mapper) {
//判空
ObjectHelper.requireNonNull(mapper, “mapper is null”);
//hook，就相当于new SingleMap
return RxJavaPlugins.onAssembly(new SingleMap<T, R>(this, mapper));
}

可以看到，这就相当于new SingleMap(this,mapper)；返回值依然是Single

我们看SingleMap的源码

public final class SingleMap<T, R> extends Single {
final SingleSource<? extends T> source;

final Function<? super T, ? extends R> mapper;

public SingleMap(SingleSource<? extends T> source, Function<? super T, ? extends R> mapper) {
//这就是刚刚传进来的this，也就是上游的被观察者
this.source = source;
//这是我们自己在map中写的new function方法
this.mapper = mapper;
}

//由上文subscribe方法分析可知，当调用subscribe时，这个回调是会被调用的
@Override
protected void subscribeActual(final SingleObserver<? super R> t) {
//可以看到，就是相当于是把上游的被观察者source，直接调用了它的subscribe方法
//我们主要的精力只要集中看new MapSingleObserver方法就行
source.subscribe(new MapSingleObserver<T, R>(t, mapper));
}

//此observer观察者中，把处理后的数据都传递给了下游，但是，只提供了事件的流向，因为事件是在上游产生的
static final class MapSingleObserver<T, R> implements SingleObserver {

final SingleObserver<? super R> t;

final Function<? super T, ? extends R> mapper;

MapSingleObserver(SingleObserver<? super R> t, Function<? super T, ? extends R> mapper) {
this.t = t;
this.mapper = mapper;
}

@Override
public void onSubscribe(Disposable d) {
t.onSubscribe(d);
}

@Override
public void onSuccess(T value) {
R v;
try {
//外面是判空，相当于就是mapper.apply(value)，这个方法其实就是我们自己的map方法
v = ObjectHelper.requireNonNull(mapper.apply(value), “The mapper function returned a null value.”);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
onError(e);
return;
}
//将map方法处理后的事件，传递给下游
t.onSuccess(v);
}

@Override
public void onError(Throwable e) {
t.onError(e);
}
}
}

看到这儿我们可以发现，事件流向是上游的被观察者流向观察者，在操作符中，因为操作符自身是继承了被观察者（在此处为Single），而在其自身中，有一个内部类是观察者（在此处为实现了SingleObserver的MapSingleObserver），事件由上游的被观察者，流向下游的观察者，而所有的操作符的结构都是一样的，每个操作符都只需要给上游操作符提供Observer，并给下游提供一个Observable，内部结构就是，从上游流向下游内部的observer被观察者，然后此下游的观察者observable会调用它自己下游的内部observer，这样，整条链就能运行了。

由此可知，Rxjava中，每个操作符内部都实现了一整套PUSH模型的接口体系

由特殊到普通
现在回到最普通的Rxjava写法

Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
emitter.onNext(1);
emitter.onComplete();
}
}).map(new Function<Integer, Integer>() {
@Override
public Integer apply(Integer integer) throws Exception {
return integer+1;
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}

@Override
public void onNext(Integer integer) {
}

@Override
public void onError(Throwable e) {
}

@Override
public void onComplete() {
}
});

先看create方法的源码

public static Observable create(ObservableOnSubscribe source) {
ObjectHelper.requireNonNull(source, “source is null”);
return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}

通过上面的分析，我们一眼可以看出，就相当于new ObservableCreate(source)

public final class ObservableCreate extends Observable {
final ObservableOnSubscribe source;

public ObservableCreate(ObservableOnSubscribe source) {
this