Rxjava 源码分析一

1、概述

rxjava官方给出来的定义是组成异步和事件通过观测序列的基础程序库。rxjava通过观测者模式实现观察者和被观察者之间数据改变，通过修饰者模式实现不通操作符转换。

2、源码分析

主要通过分析rxjava2.0代码了解rxjava如何使用观察者和被观察者之间订阅关系，首先分析Observable.create方法，我们可以通过Observable.create创建自定义对象，在调用create方法时传递ObservableOnSubscrible接口

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
            ObjectHelper.requireNonNull(source, "source is null");
            return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}

在调用create方法时会判断当前传递的ObservableOnSubscrible对象是否为空，为空抛出异常。

     public static <T> T requireNonNull(T object, String message) {
        if (object == null) {
            throw new NullPointerException(message);
        }
        return object;
    }

然后通过调用RxjavaPlugins.onAssembly方法创建一个Observable对象。先创建一个Observablecreate对象包裹ObservableOnSubscrible，ObservableOnSubscrible是继承Observable，然后传递给onAssembly方法。

     @SuppressWarnings({ "rawtypes", "unchecked" })
    @NonNull
    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;
    }

在onAssembly方法中先判断是否需要hook，当前不hook方法直接返回source方法，source就是ObservableCreate对象，然后我们通过调用subscribe方法订阅

     @SchedulerSupport(SchedulerSupport.NONE)
    public final Disposable subscribe() {
        return subscribe(Functions.emptyConsumer(), Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION, Functions.emptyConsumer());
    }
     @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
            Action onComplete, Consumer<? super Disposable> 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");

        LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);

        subscribe(ls);

        return ls;
    }

在subscrible方法中，如果用户没有传递onNex、onError、onComplete和onSubscrible rxjava帮忙创建相关方法，然后组装成LambdaObserver对象，然后调用subscribe方法

     @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);

            ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // can't call onError because no way to know if a Disposable has been set or not
            // can't call onSubscribe because the call might have set a Subscription already
            RxJavaPlugins.onError(e);

            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(e);
            throw npe;
        }
    }

在subscrible方法中检测Observer对象是否为空，然后调用subscribleActual方法，这个方法就是刚才创建的ObservbleCreate对象

 @Override
protected void subscribeActual(Observer<? super T> observer) {
    CreateEmitter<T> parent = new CreateEmitter<T>(observer);
    //observable中onSubscrible方法,保证onSubscrible在onNext和onError方法之前调用
    observer.onSubscribe(parent);

    try {
        //实际观察者调用的方法
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}

在subscribleActual方法中创建一个发射器，然后调用Observer的onSubscrible方法，把发射器传递给onSubscrible中，然后调用onSubscrible，这个Observable.onSubscrible就是我们通过Obserable.create创建时候实现ObservableOnSubscrible实现类，通过try catch把异常捕获，如果异常后调用createEmitter中onError方法，在CreateEmitter中的Error方法实际是调用rxjava封装的LambdaObserver中的onError方法。

3 类图分析

![这里写图片描述](https://img-blog.csdn.net/20180811224404531?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0YXJsaWdodF8yMDEy/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

我们在通过Observable.create方法创建自定义被观察者时，通过创建ObservableOnSubscrible实例对象，rxjava会创建一个修饰者对象ObservableCreate继承Observable存储ObservableOnSubscrible字段，然后我们通过subscribe订阅时通过组装一个LambdaObserver对象，lambdaObserver继承Observer，通过调用subsrcibe实现订阅，订阅后会调用ObservableCreate.subsrcibeActual方法，在ObservableCreate方法中组装一个CreateEmitter发射器对象，然后调用lambdaObserver中onSubscribe方法把发射器传递到lambdaObserver.onSubscribe中，然后调用ObservableOnSubscrible中subscribe方法传入发射器，可以通过发射器调用onNext、onError方法。

4 总结

rxjava是基于观察者模式实现事假订阅，但是有区别于现实中理解，rxjava是通过被观察者订阅观察者实现，在观察者中有被观察者实例，底层是创建lambdaObserver包裹onNext,onError方法，然后通过ObservableCreate中的subscribeActual创建一个CreateEmitter发射器，调用ObservableOnSubscrible中的subscribe方法传递CreateEmitter对象，实现对象引用。

1、概述

2、源码分析

3 类图分析

4 总结

猜你喜欢