Rxjava在Android界很火，不过博主工作并不接触网络开发，没有大批量多层次的使用异步任务的机会。一直听说但是并没有使用，更不会深入分析它的机制。不过出于好奇本文会研究下源码中个人关注的点，注意本文并不介绍rxjava如何使用。
源码版本是RxJava-2.x，2018.1.5下载。
rxjava的起点就是Observable.java
1. create
先看下create的demo代码：
Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1)；
emitter.onComplete();
}
});
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
} public static <T> T requireNonNull(T object, String message) {
if (object == null) {
throw new NullPointerException(message);
}
return object;
}
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
if (f != null) {
return apply(f, source);
}
return source;
}requireNonNull是判断参数是否为null，null的话会抛出空指针异常；OnAssembly是hook机制，如果onObservableAssembly方法不为空的话，使用该方法做些额外操作，默认onObservableAssembly是null。那么create方法实际上可以等同于下：
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
return new ObservableCreate<T>(source);
}public interface ObservableOnSubscribe<T> {
/**
* Called for each Observer that subscribes.
* @param emitter the safe emitter instance, never null
* @throws Exception on error
*/
void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
}1.1 ObservableEmitter
接口subscribe的参数是ObservableEmitter，该类主要的作用是可以让Observable的操作有取消的功能。
public interface ObservableEmitter<T> extends Emitter<T> {
/**
* Sets a Disposable on this emitter; any previous Disposable
* or Cancellation will be unsubscribed/cancelled.
* @param d the disposable, null is allowed
*/
void setDisposable(@Nullable Disposable d);
/**
* Sets a Cancellable on this emitter; any previous Disposable
* or Cancellation will be unsubscribed/cancelled.
* @param c the cancellable resource, null is allowed
*/
void setCancellable(@Nullable Cancellable c);
...
}public interface Emitter<T> {
/**
* Signal a normal value.
* @param value the value to signal, not null
*/
void onNext(@NonNull T value);
/**
* Signal a Throwable exception.
* @param error the Throwable to signal, not null
*/
void onError(@NonNull Throwable error);
/**
* Signal a completion.
*/
void onComplete();
}1.2 ObservableCreate
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source; //这里就是用户实现的接口，作为参数传入
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
...
}2. subscribe
承接上个demo，建立连接的demo代码如下
Observer<Integer> observer = new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "subscribe");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "" + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "error");
}
@Override
public void onComplete() {
Log.d(TAG, "complete");
}
};
//建立连接
observable.subscribe(observer); public final void subscribe(Observer<? super T> observer) {
...
subscribeActual(observer);
...
}
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
private static final long serialVersionUID = -3434801548987643227L;
final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
...
if (!isDisposed()) {
observer.onNext(t);
}
}
...
}这个就是rxjava的基本流程，建立连接就是Observable回调Observer接口的过程。当然demo是没什么卵用的，不使用Observable提供的大量Operator是看不出Rxjava的过人之处的。
3. 线程控制
先看段线程控制的demo代码
Observable.create(...)
.subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
.observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
.subscribe(...);3.1 subscribeOn
public final Observable<T> subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;
public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
@Override
public void subscribeActual(final Observer<? super T> s) {
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
s.onSubscribe(parent);
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
private static final long serialVersionUID = 8094547886072529208L;
final Observer<? super T> actual;
final AtomicReference<Disposable> s;
SubscribeOnObserver(Observer<? super T> actual) {
this.actual = actual;
this.s = new AtomicReference<Disposable>();
}
@Override
public void onSubscribe(Disposable s) {
DisposableHelper.setOnce(this.s, s);
}
@Override
public void onNext(T t) {
actual.onNext(t);
}
...
}
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver<T> parent;
SubscribeTask(SubscribeOnObserver<T> parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
//注意这里的source实际类型在demo中是ObservableCreate，然后最终会走到ObservableCreate的subscribeActual中。当然这个source可以是其他的任意Observer对象
}
}
}
abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T>要理解线程还是要看下核心的scheduleDirect方法
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
final Worker w = createWorker();
final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
DisposeTask task = new DisposeTask(decoratedRun, w);
w.schedule(task, delay, unit);
return task;
}source.subscribe(parent);3.2 observeOn
public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
ObjectHelper.verifyPositive(bufferSize, "bufferSize");
return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
}public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T>
protected void subscribeActual(Observer<? super T> observer) {
if (scheduler instanceof TrampolineScheduler) {
source.subscribe(observer);
} else {
Scheduler.Worker w = scheduler.createWorker();
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}
}
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
...
final Scheduler.Worker worker;
...
SimpleQueue<T> queue; //使用队列存储参数
...
ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
this.actual = actual;
this.worker = worker;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
...
@Override
public void onNext(T t) {
...
schedule(); //并没有直接调用actual的onNext方法
}
...
void schedule() {
if (getAndIncrement() == 0) {
worker.schedule(this); //调度后续代码到线程中
}
}
void drainNormal() {
int missed = 1;
final SimpleQueue<T> q = queue;
final Observer<? super T> a = actual;
for (;;) {
if (checkTerminated(done, q.isEmpty(), a)) {
return;
}
for (;;) {
boolean d = done;
T v;
try {
v = q.poll(); //队列中取出参数
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
s.dispose();
q.clear();
a.onError(ex);
worker.dispose();
return;
}
boolean empty = v == null;
if (checkTerminated(d, empty, a)) {
return;
}
if (empty) {
break;
}
a.onNext(v); //真正onNext的代码
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
...
@Override
public void run() { //为了线程调度
if (outputFused) {
drainFused();
} else {
drainNormal();
}
}
...
}4.其余重要的操作符
4.1 map
map起到类型转换的作用
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));
}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) {
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}
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) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
...
U v;
try {
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
actual.onNext(v);
}
...
}
}4.2 flatmap
也是转换参数，不过转换成了Observable对象
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
...
return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));
}public final class ObservableFlatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
...
@Override
public void subscribeActual(Observer<? super U> t) {
...
source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize));
}
static final class MergeObserver<T, U> extends AtomicInteger implements Disposable, Observer<T> {
final Observer<? super U> actual;
final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
...
final AtomicReference<InnerObserver<?, ?>[]> observers;
static final InnerObserver<?, ?>[] EMPTY = new InnerObserver<?, ?>[0];
static final InnerObserver<?, ?>[] CANCELLED = new InnerObserver<?, ?>[0];
...
}
static final class InnerObserver<T, U> extends AtomicReference<Disposable>
implements Observer<U>
...
}4.3 just
just可以合并同类的多个对象
public static <T> Observable<T> just(T item1, T item2) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
return fromArray(item1, item2);
} public static <T> Observable<T> fromArray(T... items) {
ObjectHelper.requireNonNull(items, "items is null");
if (items.length == 0) {
return empty();
} else
if (items.length == 1) {
return just(items[0]);
}
return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
}public final class ObservableFromArray<T> extends Observable<T> {
final T[] array;
public ObservableFromArray(T[] array) {
this.array = array;
}
@Override
public void subscribeActual(Observer<? super T> s) {
FromArrayDisposable<T> d = new FromArrayDisposable<T>(s, array);
s.onSubscribe(d);
...
d.run();
}
static final class FromArrayDisposable<T> extends BasicQueueDisposable<T> {
final Observer<? super T> actual;
final T[] array;
...
void run() {
T[] a = array;
int n = a.length;
for (int i = 0; i < n && !isDisposed(); i++) {
T value = a[i];
if (value == null) {
actual.onError(new NullPointerException("The " + i + "th element is null"));
return;
}
actual.onNext(value);
}
if (!isDisposed()) {
actual.onComplete();
}
}
}
}
4.4 connatMap
connatMap和flatMap的不同之处在于可以保证代码执行的顺序性
public final <R> Observable<R> concatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper, int prefetch) {
...
return RxJavaPlugins.onAssembly(new ObservableConcatMap<T, R>(this, mapper, prefetch, ErrorMode.IMMEDIATE));
}
public final class ObservableConcatMap<T, U> extends AbstractObservableWithUpstream<T, U>
@Override
public void onNext(T t) {
if (done) {
return;
}
if (fusionMode == QueueDisposable.NONE) {
queue.offer(t);
}
drain();
}
...
}4.5 zip
zip可以等待多个Observable全部完成
public static <T1, T2, T3, T4, R> Observable<R> zip(
ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> zipper) {
...
return zipArray(Functions.toFunction(zipper), false, bufferSize(), source1, source2, source3, source4);
} public static <T, R> Observable<R> zipArray(Function<? super Object[], ? extends R> zipper,
boolean delayError, int bufferSize, ObservableSource<? extends T>... sources) {
...
return RxJavaPlugins.onAssembly(new ObservableZip<T, R>(sources, null, zipper, bufferSize, delayError));
}public final class ObservableZip<T, R> extends Observable<R>
public void subscribeActual(Observer<? super R> s) {
...
ZipCoordinator<T, R> zc = new ZipCoordinator<T, R>(s, zipper, count, delayError);
zc.subscribe(sources, bufferSize);
}
static final class ZipCoordinator<T, R> extends AtomicInteger implements Disposable {
...
public void subscribe(ObservableSource<? extends T>[] sources, int bufferSize) {
ZipObserver<T, R>[] s = observers;
int len = s.length;
for (int i = 0; i < len; i++) {
s[i] = new ZipObserver<T, R>(this, bufferSize);
}
// this makes sure the contents of the observers array is visible
this.lazySet(0);
actual.onSubscribe(this);
for (int i = 0; i < len; i++) {
if (cancelled) {
return;
}
sources[i].subscribe(s[i]);
}
}
...
public void drain() {
if (getAndIncrement() != 0) {
return;
}
int missing = 1;
final ZipObserver<T, R>[] zs = observers;
final Observer<? super R> a = actual;
final T[] os = row;
final boolean delayError = this.delayError;
for (;;) {
for (;;) {
...
R v;
try {
v = ObjectHelper.requireNonNull(zipper.apply(os.clone()), "The zipper returned a null value");
//依据所有数据做转换
} catch (Throwable ex) {
...
}
a.onNext(v);
Arrays.fill(os, null);
}
missing = addAndGet(-missing);
if (missing == 0) {
return;
}
}
}
...
}
static final class ZipObserver<T, R> implements Observer<T> {
final ZipCoordinator<T, R> parent;
final SpscLinkedArrayQueue<T> queue;
...
ZipObserver(ZipCoordinator<T, R> parent, int bufferSize) {
this.parent = parent;
this.queue = new SpscLinkedArrayQueue<T>(bufferSize);
}
@Override
public void onSubscribe(Disposable s) {
DisposableHelper.setOnce(this.s, s);
}
@Override
public void onNext(T t) {
queue.offer(t);
parent.drain();
}
...
}
...
}5. Rxjava链式调用的原理
链式调用，Android中最常见的可能就是AlertDialog
new AlertDialog.Builder(self)
.setTitle("确认")
.setMessage("确定吗？")
.setPositiveButton("是", null)
.setNegativeButton("否", null)
.show(); public Builder setTitle(CharSequence title) {
P.mTitle = title;
return this;
}当然rxjava的架构复杂的多：
1.对Rxjava中的Observable operator来说就是return Observable的子类，上面所分析的所有Observable operator都是返回Observable对象的，具体来说是Observable的某个子类。
2.每个Observable都会实现
protected void subscribeActual(Observer<? super T> observer) public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}subscribeActual调用顺序是从上到下，但是对用户来说代码的执行流程应该是从下往上呀，接下来就展现rxjava最巧妙的地方。
3.各层Observable内部类对象Observer必然有个内部成员（后续的Observer指的是内部类对象，不是指用户实现的Observer）
final Observer<? super T> actual; @Override
public void onNext(T t) {
...
actual.onNext(v);
}实质上就是通过参数传递的方式，依次入栈，然后在出栈，逆转了代码执行的顺序。注意subscribe()实际上还是逆序的，但是观察者回调的顺序是和代码书写顺序一致的。例如ObservableMap等的功能都实现在onNext中，而不是subscribeActual中，这样顺序才会对。由于subscribe()实际上还是逆序的，所以书写代码还是要注意点的，例如之前提及的线程控制方法:
.subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
.observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程observeOn只对书写在下面的代码的OnNext等回调有效;
subscribeOn比较复杂，对书写在上面的代码的subscribe方法（从代码看subscribeOn方法附近的的onNext等回调也会跑在和subscribe同样的线程，这个和subscribeOn的本意还是稍微有区别的）有效。
针对subscribeOn举个例子，当然只是为了说明代码线程控制，日常不大可能两次改变subscribe的线程。
1.create
...
...
...
2.subscribeOn（thread 1）
...
...
...
...
3.subscribeOn（thread 2）onNext等回调，从1->2的线程是thread 1，2->3的线程是thread 1。
理解了subscribeActual（从上到下）和内部类Observer（从下到上）的调用流程后理解上面例子应该是很容易的。
6. Lift
理解了Rxjava的原理后，看出架构太nb了。计算机的一切问题可以加个中间层来解决，在Rxjava的世界中变成变换个Observable就能解决。Observable类中已经有n多的operator了，日常开发是足够了，但是还是不满足怎么办，Rxjava还是有终级的解决方案的，就是lift：
public final <R> Observable<R> lift(ObservableOperator<? extends R, ? super T> lifter) {
ObjectHelper.requireNonNull(lifter, "onLift is null");
return RxJavaPlugins.onAssembly(new ObservableLift<R, T>(this, lifter));
}public final class ObservableLift<R, T> extends AbstractObservableWithUpstream<T, R> {
/** The actual operator. */
final ObservableOperator<? extends R, ? super T> operator;
public ObservableLift(ObservableSource<T> source, ObservableOperator<? extends R, ? super T> operator) {
super(source);
this.operator = operator;
}
@Override
public void subscribeActual(Observer<? super R> s) {
Observer<? super T> observer;
try {
observer = ObjectHelper.requireNonNull(operator.apply(s), "Operator " + operator + " returned a null Observer");
} catch (NullPointerException e) { // NOPMD
...
}
source.subscribe(observer);
}
}public interface ObservableOperator<Downstream, Upstream> {
/**
* Applies a function to the child Observer and returns a new parent Observer.
* @param observer the child Observer instance
* @return the parent Observer instance
* @throws Exception on failure
*/
@NonNull
Observer<? super Upstream> apply(@NonNull Observer<? super Downstream> observer) throws Exception;
}
203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
