RxJava github地址：https://github.com/ReactiveX/RxJava/tree/2.x
RxJava相关概念和一些用法这里不再赘述，可以查看官方文档 官方文档 以及其他的一些博客，闲话少说，这里直接从 Rx 的 github 中简单用法去深入源码解读。
直接上代码，这里用 Flowable 的 just 操作符将 String 对象 “Hello world” 打印出来。
val subscribe = Flowable.just("Hello world").subscribe(System.out::println)直接跟进 Flowable.just()
@CheckReturnValue
@NonNull
@BackpressureSupport(BackpressureKind.FULL)
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Flowable<T> just(T item) {
ObjectHelper.requireNonNull(item, "item is null");
return RxJavaPlugins.onAssembly(new FlowableJust<T>(item));
}ObjectHelper 的 requireNonNull 方法简单的做了 null 判断。
public static <T> Flowable<T> onAssembly(@NonNull Flowable<T> source) {
Function<? super Flowable, ? extends Flowable> f = onFlowableAssembly;
if (f != null) {
return apply(f, source);
}
return source;
}紧接着创建了一个 FlowableJust 对象，将我们的 item 传入 FlowableJust 对象中。
public final class FlowableJust<T> extends Flowable<T>
private final T value;
public FlowableJust(final T value) {
this.value = value;
}
}FlowableJust 继承了 Flowable，构造函数也很简单，简单赋值给成员变量 value。
进入 onAssembly 方法中，第一行的 onFlowableAssembly 是什么呢？我们先来暂停下。
static volatile Function<? super Flowable, ? extends Flowable> onFlowableAssembly;
//onFlowableAssembly是Function接口的实例对象
public interface Function<T, R> {
R apply(@NonNull T t) throws Exception;
}先来介绍它的用法
try {
RxJavaPlugins.setOnFlowableAssembly(object : Function<Flowable<*>?, Flowable<*>?> {
override fun apply(t: Flowable<*>): Flowable<*>? {
return FlowableJust("Hello world 01")
}
})
Flowable.just("Hello world 02").subscribe(System.out::println)
} finally {
RxJavaPlugins.reset()
}这段代码首先调用 RxJavaPlugins 的静态方法 setOnFlowableAssembly，设置 onFlowableAssembly 为我们创建出来的 FlowableJust("Hello world 01")，之后创建新的 Flowable 数据流。这段代码会输出什么呢？两个hello world会同时输出吗？
答案是只会输出 Hello world 01。跟进代码查看下为什么。
static volatile Function<? super Flowable, ? extends Flowable> onFlowableAssembly;
public static void setOnFlowableAssembly(@Nullable Function<? super Flowable, ? extends Flowable> onFlowableAssembly) {
if (lockdown) {
throw new IllegalStateException("Plugins can't be changed anymore");
}
RxJavaPlugins.onFlowableAssembly = onFlowableAssembly;
}将传入来的 Function 对象赋给 onFlowableAssembly 对象。
好了，接下来回到 onAssembly 方法中，这边有个 apply，上文提到了这个接口了。这边将FlowableJust("Hello world 01") 赋值给 onFlowableAssembly。
static <T, R> R apply(@NonNull Function<T, R> f, @NonNull T t) {
try {
return f.apply(t);
} catch (Throwable ex) {
throw ExceptionHelper.wrapOrThrow(ex);
}
}好吧，以后在走到这个方法都会被替换掉的，输出 Hello world 01。所以用完此方法必须 reset，不过这种方法也不常用。源码中有很多这种钩子，以后就不再分析了。
由此得出 just 方法返回的是 RxJava 内部创建的 FlowableJust 对象，其中 value 对象就是 Hello world。
这边数据源准备完成了，那么数据在什么时候发射的呢？接下来看下 subscribe 源码
@CheckReturnValue
@BackpressureSupport(BackpressureKind.UNBOUNDED_IN)
@SchedulerSupport(SchedulerSupport.NONE)
public final Disposable subscribe(Consumer<? super T> onNext) {
return subscribe(onNext, Functions.ON_ERROR_MISSING,
Functions.EMPTY_ACTION, FlowableInternalHelper.RequestMax.INSTANCE);
}subscribe 需要传入一个回调接口 Consumer，调用 accept 方法传值。
public interface Consumer<T> {
void accept(T t) throws Exception;
}这边创建了三个默认的值以便后续传参。onError 和 onComplete 不多解释了，大家应该都知道。onSubscribe 之后用到时会详细解释。
//onError
public static final Consumer<Throwable> ON_ERROR_MISSING = new OnErrorMissingConsumer();
//onComplete
public static final Action EMPTY_ACTION = new EmptyAction();
//onSubscribe
public enum RequestMax implements Consumer<Subscription> {
INSTANCE;
@Override
public void accept(Subscription t) throws Exception {
t.request(Long.MAX_VALUE);
}
}进入 subscribe 方法中
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Subscription> onSubscribe) {
ObjectHelper.requireNonNull(onNext, "onNext is null");
ObjectHelper.requireNonNull(onError, "onError is null");
ObjectHelper.requireNonNull(onComplete, "onComplete is null");
ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
LambdaSubscriber<T> ls = new LambdaSubscriber<T>(onNext, onError, onComplete, onSubscribe);
subscribe(ls);
return ls;
}将四个参数封装成 LambdaSubscriber 对象，其中也是简单赋值，这里不贴代码了。重点看下 LambdaSubscriber 实现了哪些接口
public final class LambdaSubscriber<T> extends AtomicReference<Subscription>
implements FlowableSubscriber<T>, Subscription, Disposable, LambdaConsumerIntrospection LambdaSubscriber 继承 AtomicReference，AtomicReference 类提供了一个可以原子读写的对象引用变量。 原子意味着尝试更改相同。get() 方法可获取引用，后续 ScalarSubscription 会与之关联。
FlowableSubscriber 继承自 Subscriber，是订阅者需要实现的接口。
-
public void onSubscribe(Subscription s); Publisher.subscriber（Subscriber）之后调用。
-
public void onNext(T t); 媒体发出来的数据通知。会继续
-
public void onError(Throwable t); 媒体发出来的错误通知。不会继续
-
public void onComplete(); 媒体发出来的完成通知。不会继续。
Subscription 管理 Publisher 和 Subscriber 一对一生命周期的接口。
- public void request(long n); 通过此方法发出请求信号，媒体不会发出任何事件。
- public void cancel();请求媒体停止发送数据，并清理资源。
Disposable 对事件流的处理
- void dispose();用来中断事件流
- boolean isDisposed();判断事件流是否中断。
因此 LambdaSubscriber 可以理解为 Subscriber。
@BackpressureSupport(BackpressureKind.SPECIAL)
@SchedulerSupport(SchedulerSupport.NONE)
public final void subscribe(FlowableSubscriber<? super T> s) {
ObjectHelper.requireNonNull(s, "s is null");
try {
Subscriber<? super T> z = RxJavaPlugins.onSubscribe(this, s);
ObjectHelper.requireNonNull(z, "The RxJavaPlugins.onSubscribe hook returned a null FlowableSubscriber. Please check the handler provided to RxJavaPlugins.setOnFlowableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");
subscribeActual(z);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}首先 RxJavaPlugins.onSubscribe(this, s);
public static <T> Subscriber<? super T> onSubscribe(@NonNull Flowable<T> source, @NonNull Subscriber<? super T> subscriber) {
BiFunction<? super Flowable, ? super Subscriber, ? extends Subscriber> f = onFlowableSubscribe;
if (f != null) {
return apply(f, source, subscriber);
}
return subscriber;
}与 onFlowableAssembly 类似呀，onFlowableSubscribe 是个 BiFunction 接口实例，这边比用管了，它的返回值 z 也就是传入的 s。（默认不设置 onFlowableSubscribe）
public interface BiFunction<T1, T2, R> {
@NonNull
R apply(@NonNull T1 t1, @NonNull T2 t2) throws Exception;
}下一步到 subscribeActual 方法
protected abstract void subscribeActual(Subscriber<? super T> s);它是个抽象方法 ，自然去子类查找，子类当然是 FlowableJust 了。FlowableJust 的 subscribeActual。
@Override
protected void subscribeActual(Subscriber<? super T> s) {
s.onSubscribe(new ScalarSubscription<T>(s, value));
}这里 new 了一个 ScalarSubscription 对象，重点注意此对象实现了 QueueSubscription 接口，QueueSubscription 的父类是 Subscription。将我们的 "Hello world" 的 value 和实现多个接口的 LambdaSubscriber 传入 ScalarSubscription 对象。
@Override
public void onSubscribe(Subscription s) {
if (SubscriptionHelper.setOnce(this, s)) {
try {
onSubscribe.accept(this);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
s.cancel();
onError(ex);
}
}
}
setOnce 方法
public static boolean setOnce(AtomicReference<Subscription> field, Subscription s) {
ObjectHelper.requireNonNull(s, "s is null");
if (!field.compareAndSet(null, s)) {
s.cancel();
if (field.get() != CANCELLED) {
reportSubscriptionSet();
}
return false;
}
return true;
}其中 compareAndSet 方法是，ScalarSubscription 与 null 进行比较，比较后 LambdaSubscriber 的 value 设置为 ScalarSubscription，所以 LambdaSubscriber 含有 ScalarSubscription 的引用。
onSubscribe 即创建的 RequestMax.INSTANCE 对象，构造函数中赋给 onSubscribe。调用 accept 方法，将 LambdaSubscriber 再传出去。
查看上文中初始化 RequestMax.INSTANCE 时贴出的代码，再次调用 LambdaSubscriber 的 request 方法，进入下面方法中。
@Override
public void request(long n) {
get().request(n);
}
public final V get() {
return value;
}get() 获取 ScalarSubscription 进入它的方法中
@Override
public void request(long n) {
if (!SubscriptionHelper.validate(n)) {
return;
}
if (compareAndSet(NO_REQUEST, REQUESTED)) {
Subscriber<? super T> s = subscriber;
s.onNext(value);
if (get() != CANCELLED) {
s.onComplete();
}
}
}此处 subscriber 和 s 即 LambdaSubscriber，又回到 LambdaSubscriber 中了
@Override
public void onNext(T t) {
if (!isDisposed()) {
try {
onNext.accept(t);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
get().cancel();
onError(e);
}
}
}此处的t即为 "hello world"，onNext 即为我们创建出来的 Consumer，这边再调用 System.out::println 处理。
流程详细的分析完成，其他的创建操作符也是相通的。
扫一扫
573
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
