RxJava可以看成是一个观察者模式的具体实现。既然是观察者模式的实现，那么他就有观察者（Observer）、被观察者（Observable）以及被观察者订阅（subscribe）观察者。下面我们看看这几种的实现 这里引用的RxJava的版本如下
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
implementation "io.reactivex.rxjava2:rxjava:2.2.9"
首先是创建Observer，它会处理事件产生后的具体逻辑，主要有两种方式Observer和Subscriber Observer:通过直接new一个Observer来创建观察者
/**
* 通过observer的方式创建观察者
*/
private Observer<String> createObserverByObserver() {
return new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
//这个方法可以算的是上一个init方法，在这里可以做一些初始化工作
//我们可以通过d.dispose();来取消对事件的观察
Log.e("TAG", "onSubscribe ByObserver");
}
@Override
public void onNext(String o) {
Log.e("TAG", "onNext ByObserver：" + o);
}
@Override
public void onError(Throwable e) {
Log.e("TAG", "onError ByObserver");
}
@Override
public void onComplete() {
Log.e("TAG", "onComplete ByObserver");
}
};
}
这里的onSubscribe相当于RxJava1中的start，而且通过d可以取消本次的订阅，创建观察者还可以通过Subscriber的方式
/**
* 通过subscriber的方式创建观察者
*/
private Subscriber<String> createObserverBySubscriber() {
return new Subscriber<String>() {
@Override
public void onSubscribe(Subscription s) {
//如果不调用request方法的话后面的onNext等方法不会调用
//这里的数值一般传入Integer.MAX，因为如果被观察是一个array的话，
// 其大小如果大于我们设定的这个n，那么超过n的那些事件是不会被处理的，
// 而且onComplete方法也不会被触发
s.request(4);
Log.e("TAG", "onSubscribe BySubscriber");
}
@Override
public void onNext(String string) {
Log.e("TAG", "onNext BySubscriber：" + string);
}
@Override
public void onError(Throwable t) {
Log.e("TAG", "onError BySubscriber");
}
@Override
public void onComplete() {
Log.e("TAG", "onComplete BySubscriber");
}
};
}
这个与Observer方式的不同之处在于，他需要手动调用request方法，传入需要执行的次数。而且还可以通过s.cancel()来取消本本次订阅。但是(被观察者).subscribe(观察者)这种方式将观察者与被观察者建立联系的时候，采用这两种方式创建的Observer他们所对应的被观察者也不同 通过Observer方式创建的观察者，它的被观察者通过Observer.create/Observer.just/Observer.fromArray等方式创建
/**
* 通过create创建被观察者
*/
private Observable<String> createObservableByCreate() {
return Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("测试1ByCreate");
emitter.onNext("测试2ByCreate");
emitter.onComplete();
}
});
}
/**
* 通过just方式创建被观察者
*/
private Observable<String> createObservableByJust() {
return Observable.just("测试1ByJust", "测试2ByJust");
}
/**
* 通过fromArray方式创建被观察者
*/
private Observable<String> createObservableByFromArray() {
String[] tests = {"测试1FromArray", "测试2FromArray"};
return Observable.fromArray(tests);
}
而通过Subscriber方式创建的观察者，它的被观察者只能是通过Flowable等继承或实现了Publisher的方式 下面我们重点看一下Subscriber方式
Flowable.fromArray(1, 2, 3, 4, 5, 6).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return String.valueOf(integer);
}
}).subscribe(createObserverBySubscriber());
结果如下
可以看到我们在request方法中设定了处理次数为4，但是我们的Observable数是6个，所以只是执行了onNext，并没有onComplete，如果将上述改成（1，2，3）则结果为
简单的订阅已经介绍完了，在RxJava中其实好用的还是那些操作符，可以大大的简化代码的处理逻辑。 比如上面介绍的创建操作符create/just/fromArray，当然创建操作符还有interval（创建一个按固定时间间隔发射整数序列的Observable）相当于定时器，range（发送一个范围内的数据）用来替代for循环，timer（创建一个延时启动的被观察者）。除此之外还有变换操作符。比如常用的map（将原有对象转换成一个新的对象），flatmap（将原有对象转换成一个Observable）、groupBy（分组）、buffer（将原来的Observable转换成新的Observable，这个新的Observable每次发射一个数组）等。过滤操作符，filter（按某一条件过滤）、distinct（去重）、skip（跳过前几个）、take(只取前几个)等。组合操作符，startWith（在源Observable发射前发射一些数据，这些数据则是with中指定的）、merge（将多个Observable合并到一个Observable中发射，他可能会让合并的Observable发射的数据交错）、concat（也是合并多个Observable，但是他会严格按照顺序反射数据，如果前一个Observable没发射完成，后一个Observable肯定不会发射数据），zip（合并两个或多个Observable，并根据指定的函数变换他们，最终发射一个新值）。辅助操作符，subscribeOn（Observable所在的线程）、observeOn（observer所在的线程）。
创建及订阅源码分析：这里选用create方式创建Observable以及new Observer的方式
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("测试1ByCreate");
emitter.onNext("测试2ByCreate");
emitter.onComplete();
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
首先我们看create方法
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
其实就是创建了一个ObservableCreate对象，并且把传入的对象传递给这个类
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
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 (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
if (!isDisposed()) {
observer.onNext(t);
}
}
@Override
public void onError(Throwable t) {
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public boolean tryOnError(Throwable t) {
if (t == null) {
t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
}
if (!isDisposed()) {
try {
observer.onError(t);
} finally {
dispose();
}
return true;
}
return false;
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
@Override
public void setDisposable(Disposable d) {
DisposableHelper.set(this, d);
}
@Override
public void setCancellable(Cancellable c) {
setDisposable(new CancellableDisposable(c));
}
@Override
public ObservableEmitter<T> serialize() {
return new SerializedEmitter<T>(this);
}
@Override
public void dispose() {
DisposableHelper.dispose(this);
}
@Override
public boolean isDisposed() {
return DisposableHelper.isDisposed(get());
}
@Override
public String toString() {
return String.format("%s{%s}", getClass().getSimpleName(), super.toString());
}
}...
}
可以看到，目前为止只是对类中的source进行赋值，我们接着看subscribe
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");
subscribeActual(observer);
...}
}
其中最重要的就是这个subscribeActual方法，点进去之后发现他是抽象类Observable的抽象方法，所以它的具体实现应该是在其实现类中，细心的可以发现，我们在调用Observable.create时，其实内部调用了ObservableCreate这个类，而这个类也正是继承了Observable，所以我们通过create方式创建的Observable，它的subscribe方法内部调用的必然是这个类中的subscribeActual方法，我们在回过头来看看上面这个类中的这个方法。它首先是根据这个observer创建了一个CreateEmitter对象，这个对象是一个静态内部类而且他实现了ObservableEmitter，以及Disposable。然后调用了observer的onSubscribe方法，这里的参数强转为其父类Disposable，紧接着调用了source的subscribe方法，上面已经提到了，这个source就是创建是create中传入的方法，并且传入的参数为其子类CreateEmitter。在真正使用的时候我们需要在subscribe方法中手动调用onNext，onComplete，当然这里调用的是CreateEmitter中的onNext，onComplete等。所以我们接着看这个类中的这个方法，可以看到，在这里分别调用了observer的onNext、onComplete或者是onError，并且完成后调用了dispose方法来解除对这个Observable的观察
RxJava2的转换过程：比如map，还是上面的订阅，只不过在subscribe之前加了一个map
map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
return "prefix:"+s;
}
})
首先我们看一下这个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));
}
可以看到其实就是创建了一个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) {
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) {
if (done) {
return;
}
if (sourceMode != NONE) {
downstream.onNext(null);
return;
}
U v;
try {
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
downstream.onNext(v);
}
@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;
}
}
}
通过之前的分析可以看出来，在调用subscribe方法时，其实是调用新生成这个类中的subscribeActual方法也就是ObservableMap中的这个方法，可以看到他同样是调用了被观察者的subscribe方法，同理在被观察者在subscribe方法中调用onNext以及onComplete时候则调用的是这个mapper中的相应方法，可以看到这里的onNext在调用observer的onNext的时候先对原始值利用mapper的apply方法进行了处理。这里可以看到的是重新创建了一个observer，然后利用这个创建好的observer做相关助理，最后在调用原始observer中的相关方法。
在我们平时使用时往往会用到线程切换，比如
(Observable).subscribeOn(Schedulers.computation()).observeOn(AndroidSchedulers.mainThread()).subscribe(observer)
这里可以看到被观察者（Observable）的线程为Schedulers.computation，而观察者的线程为Android主线程，我们先来看看被观察者线程的实现
public final class Schedulers {
@NonNull
static final Scheduler COMPUTATION;
static {
...
COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());
...
}
...
static final class ComputationTask implements Callable<Scheduler> {
@Override
public Scheduler call() throws Exception {
return ComputationHolder.DEFAULT;
}
}
...
static final class ComputationHolder {
static final Scheduler DEFAULT = new ComputationScheduler();
}...
}
可以看到它的线程切换具体是由ComputationScheduler来完成的，这个类我们稍后再说，接下来便是subscribeOn
public final Observable<T> subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}
其实跟之前的创建Observable很像，只不过这里创建了一个ObservableSubscribeOn，参数为Observable和传入的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> observer) {
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
observer.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> downstream;
final AtomicReference<Disposable> upstream;
SubscribeOnObserver(Observer<? super T> downstream) {
this.downstream = downstream;
this.upstream = new AtomicReference<Disposable>();
}
@Override
public void onSubscribe(Disposable d) {
DisposableHelper.setOnce(this.upstream, d);
}
@Override
public void onNext(T t) {
downstream.onNext(t);
}
@Override
public void onError(Throwable t) {
downstream.onError(t);
}
@Override
public void onComplete() {
downstream.onComplete();
}
@Override
public void dispose() {
DisposableHelper.dispose(upstream);
DisposableHelper.dispose(this);
}
@Override
public boolean isDisposed() {
return DisposableHelper.isDisposed(get());
}
void setDisposable(Disposable d) {
DisposableHelper.setOnce(this, d);
}
}
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver<T> parent;
SubscribeTask(SubscribeOnObserver<T> parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
}
}
}
此时Observable的分发则是由这个类负责，可以看到这里有subscribeActual以及其子类中的onNext等，这个逻辑同之前的都一样，只不过这里需要注意的是在subscribeActual中调用了scheduler.scheduleDirect方法，这个方法的参数可以从上面看出来其实就是一个runnable，在它的run方法中执行被观察者的subscribe方法，而这个scheduleDirect方法就应该在上面我们所说的负责Observable线程处理的类ComputationScheduler中
public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) {
PoolWorker w = pool.get().getEventLoop();
return w.scheduleDirect(run, delay, unit);
}
其实就是取出一个线程池，执行线程池的scheduleDirect方法，具体实现为
public Disposable scheduleDirect(final Runnable run, long delayTime, TimeUnit unit) {
ScheduledDirectTask task = new ScheduledDirectTask(RxJavaPlugins.onSchedule(run));
try {
Future<?> f;
if (delayTime <= 0L) {
f = executor.submit(task);
} else {
f = executor.schedule(task, delayTime, unit);
}
task.setFuture(f);
return task;
} catch (RejectedExecutionException ex) {
RxJavaPlugins.onError(ex);
return EmptyDisposable.INSTANCE;
}
}
其实就是线程池的submit或者是schedule，这里就完成了将Observable切换到后台线程。这里同变换是一个道理，我们在进行分发的时候中间创建了一个新的observer，在这个新的observer中处理逻辑，然后调用原来observer的相关方法。下面我们继续分析observeOn，同理我们看看上面定义的AndroidSchedulers.mianThread
public final class AndroidSchedulers {
/** A {@link Scheduler} which executes actions on the Android main thread. */
public static Scheduler mainThread() {
return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
}
private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
new Callable<Scheduler>() {
@Override public Scheduler call() throws Exception {
return MainHolder.DEFAULT;
}
});
private static final class MainHolder {
static final Scheduler DEFAULT
= new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
}
...
}
可以看出来真正负责切换线程的事HandlerScheduler这个类，而且他的参数为主线程的handler，所以在此就可以大胆的猜测，线程切换应该是handler.sendMessage方法，到底是不是我们继续看onserveOn，它调用如下
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> {
final Scheduler scheduler;
final boolean delayError;
final int bufferSize;
public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
super(source);
this.scheduler = scheduler;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
@Override
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));
}
}...
}
是不是很熟悉，依旧看这里的subscribeActual方法，我们这里的Scheduler是AndroidScheduler所以它会调用它的createWorker方法
@Override
public Worker createWorker() {
return new HandlerWorker(handler, async);
}
private static final class HandlerWorker extends Worker {
private final Handler handler;
private final boolean async;
private volatile boolean disposed;
HandlerWorker(Handler handler, boolean async) {
this.handler = handler;
this.async = async;
}...
}
而上面真正分发事件的是OnbserverOnOnserver这个类，比如它的onNext方法
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != QueueDisposable.ASYNC) {
queue.offer(t);
}
schedule();
}
会调用schedule方法
void schedule() {
if (getAndIncrement() == 0) {
worker.schedule(this);
}
}
其实就是HandlerScheduler中的这个方法
public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
if (run == null) throw new NullPointerException("run == null");
if (unit == null) throw new NullPointerException("unit == null");
if (disposed) {
return Disposables.disposed();
}
run = RxJavaPlugins.onSchedule(run);
ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
Message message = Message.obtain(handler, scheduled);
message.obj = this; // Used as token for batch disposal of this worker's runnables.
if (async) {
message.setAsynchronous(true);
}
handler.sendMessageDelayed(message, unit.toMillis(delay));
// Re-check disposed state for removing in case we were racing a call to dispose().
if (disposed) {
handler.removeCallbacks(scheduled);
return Disposables.disposed();
}
return scheduled;
}
其实就是利用handler向主线程中发送消息，至此Observer的线程切换也已经分析完了。
