rxjava3 源码解析

Rxjava

RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.

RxJava

– JVM的反应式扩展

– 一个用于使用Java虚拟机的可观察序列编写异步和基于事件的程序的库。

 
使用的主要设计模式包括：
观察者模式，装饰器模式，适配器模式（函数传参不同有不同实现）

 
RxJava源码分析最主要的点在于

• RxJava是如何从事件流的发送方发送到事件流的接收方的
• RxJava是如何对操作符进行封装和操作的
• RxJava是如何随意切换线程的

 
RxJava的分析三步骤

• 创建：被观察者创建的过程
• 订阅：被观察者订阅观察者的过程
• 发射：发射器发射的过程

 

1 简单使用

在 IO 线程中执行业务逻辑，在主线程中对执行的结果进行后续的处理。

Disposable disposable = Observable.create(new ObservableOnSubscribe<Object>() {
   
    @Override
    public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
   
        // 在订阅线程执行业务逻辑
        emitter.onNext(new Object());
        emitter.onComplete();
    }
})
 .subscribeOn(Schedulers.io())//订阅线程
 .observeOn(AndroidSchedulers.mainThread())//观察线程
 .subscribe(new Observer<String>() {
   
     // 在观察线程中进行后续的处理
			@Override
			public void onSubscribe(Disposable d) {
   
				Log.d(TAG, "onSubscribe: " + d);
			}
			@Override
			public void onNext(String value) {
   
				Log.d(TAG, "onNext: " + value);
			}
			@Override
			public void onError(Throwable e) {
   
				Log.d(TAG, "onError: " + e);
			}
			@Override
			public void onComplete() {
   
				Log.d(TAG, "onComplete: ");
			}
		});
disposable.dispose();

1. create()
2. 线程调度
   • subscribeOn(Schedulers.io())
   • observeOn(AndroidSchedulers.mainThread())
3. subscribe 订阅
4. dispose 取消订阅

 

2 主要原理

2.1 主要类

• Observable（被观察者）：被观察的对象

• Observer（观察者）：观察的对象

• ObservableOnSubscribe（被观察者被订阅时）：被订阅时的回调，同时创建出发射器

• Emitter（发射器）：发射数据的对象

• Disposable（释放者）：释放RxJava的对象

1. Observable（被观察者）

最外层的调用接口，可以通过Observable.xxx(create、subscribe) 使用Rxjava

public abstract class Observable<@NonNull T> implements ObservableSource<T> {
   
    
    public static <@NonNull T> Observable<T> create(@NonNull ObservableOnSubscribe<T> source) {
   
        return RxJavaPlugins.onAssembly(new ObservableCreate<>(source));
    }
    
    public final void subscribe(@NonNull Observer<? super T> observer) {
   
            observer = RxJavaPlugins.onSubscribe(this, observer);
        
            subscribeActual(observer);
  			//...
    }
    
    protected abstract void subscribeActual(@NonNull Observer<? super T> observer);
}

2. Observer（观察者）

public interface Observer<@NonNull T> {
   
    void onSubscribe(@NonNull Disposable d);
    void onNext(@NonNull T t);
    void onError(@NonNull Throwable e);
    void onComplete();
}

Observer是一个接口，定义的这个四个方法就是我们在订阅时，观察者需要重写的四个方法，注意与上面的Emitter接口及其三个方法进行区分。 看这行observer.onSubscribe(parent);，由上面我们知道observer.onSubscribe()是接受Disposable类型，而这里的parent是CreateEmitter类型，这里的CreateEmitter也是一个适配器，前面的ObservableCreate对被观察者进行了适配，CreateEmitter则对观察者进行了适配，将observer类型转化为Disposable类型

3. ObservableOnSubscribe（被观察者被订阅时）

ObservableOnSubscribe是一个接口，是create方法传入的参数，需要重写subscribe方法

Observable.create(new ObservableOnSubscribe() { })

@FunctionalInterface
public interface ObservableOnSubscribe<@NonNull T> {
   
    void subscribe(@NonNull ObservableEmitter<T> emitter) throws Throwable;
}

4. Emitter（发射器）

Emitter接口定义了三个方法，onNext、onError、onComplete

所以实例化的ObservableEmitter对象（继承Emitter接口）可以调用onNext()、onError()、onComplete()这三个方法了

public interface Emitter<@NonNull T> {
   
    void onNext(@NonNull T value);
    void onError(@NonNull Throwable error);
    void onComplete();
}

2.2 RxJava原理图解

• 第一排表示各个对象的创建关系，A->B->C->D
• 第二排表示各个对象的订阅关系，D->C->B->A
• 第三排表示各个对象的发射关系，A->B->C->D

 

3 源码解析

3.1 create

//Observable.java
	public static <@NonNull T> Observable<T> create(@NonNull ObservableOnSubscribe<T> source) {
   
        Objects.requireNonNull(source, "source is null");
        //直接返回了 ObservableCreate 
        return RxJavaPlugins.onAssembly(new ObservableCreate<>(source));
    }

ObservableOnSubscribe是一个接口，是create方法传入的参数，需要重写subscribe方法

Observable.create(new ObservableOnSubscribe() { })

@FunctionalInterface
public interface ObservableOnSubscribe<@NonNull T> {
   
    void subscribe(@NonNull ObservableEmitter<T> emitter) throws Throwable;
}

RxJavaPlugins.onAssembly(ObservableCreate)

//RxJavaPlugins.java
    @SuppressWarnings({
    "rawtypes", "unchecked" })
    @NonNull
    public static <@NonNull T> Observable<T> onAssembly(@NonNull Observable<T> source) {
   
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        if (f != null) {
   
            return apply(f, source);
        }
        return source;
    }

传入的ObservableCreate是Observable的子类，适配到上方法。只是直接返回传入的ObservableCreate对象。

3.2 subscribe()

//Observable.java
	public final Disposable subscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError,
            @NonNull Action onComplete) {
   
		//将三种类型的观察者回调统一包装到 LambdaObserver 方法中
        LambdaObserver