Rxjava2 源码分析(一)

最新推荐文章于 2022-02-19 17:24:39 发布

飞哥传奇

最新推荐文章于 2022-02-19 17:24:39 发布

阅读量450

点赞数

分类专栏： android

本文链接：https://blog.csdn.net/u013286571/article/details/115716453

版权

android 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

分成两块源码来分析,第一块不带map关键字,第二块带map关键字

第一块代码:

Observable.create(

            // 自定义source
            new ObservableOnSubscribe<String>() {
                @Override
                public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                    // 发射器.onNext
                    emitter.onNext("A");
                }
    })




    // 3：subscribe订阅过程 源码分析
    // ObservableCreate. subscribe
    .subscribe(





            // 自定义观察者
            // 1：Observer
            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() {

                }
            });
}

分析代码之前先说一个hook方法可以这样使用(全局监听)

// Hook之前的监听
RxJavaPlugins.setOnObservableAssembly(new Function<Observable, Observable>() {
    @Override
    public Observable apply(Observable observable) throws Exception {
        Log.d(Flag.TAG, "apply: 整个项目 全局 监听 到底有多少地方使用 RxJava:" + observable);

        // 伪代码
        /*if (observable  === ObservableMap)
            return null;*/

        return null; // 破坏人家的功能
    }
});

下面把这一块代码分成3部分进行分析

1：Observer 创建过程源码分析

2：Observable创建过程源码分析

3：subscribe订阅过程源码分析

1：Observer 创建过程源码分析

public interface Observer<T> {

    /**
     * Provides the Observer with the means of cancelling (disposing) the
     * connection (channel) with the Observable in both
     * synchronous (from within {@link #onNext(Object)}) and asynchronous manner.
     * @param d the Disposable instance whose {@link Disposable#dispose()} can
     * be called anytime to cancel the connection
     * @since 2.0
     */
    void onSubscribe(@NonNull Disposable d);

    /**
     * Provides the Observer with a new item to observe.
     * <p>
     * The {@link Observable} may call this method 0 or more times.
     * <p>
     * The {@code Observable} will not call this method again after it calls either {@link #onComplete} or
     * {@link #onError}.
     *
     * @param t
     *          the item emitted by the Observable
     */
    void onNext(@NonNull T t);

    /**
     * Notifies the Observer that the {@link Observable} has experienced an error condition.
     * <p>
     * If the {@link Observable} calls this method, it will not thereafter call {@link #onNext} or
     * {@link #onComplete}.
     *
     * @param e
     *          the exception encountered by the Observable
     */
    void onError(@NonNull Throwable e);

    /**
     * Notifies the Observer that the {@link Observable} has finished sending push-based notifications.
     * <p>
     * The {@link Observable} will not call this method if it calls {@link #onError}.
     */
    void onComplete();

}

new Observer 实际上是一个接口,真正实现都交给用户了,这一块没什么好分析的,把new出来的实现这一块我们给个名字叫

// 自定义观察者 // 1：Observer 后面会用到

2：Observable创建过程源码分析

Observable.create(

        // 自定义source
        new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                // 发射器.onNext
                emitter.onNext("A");
            }
})

这里我们把new出来的这一块叫做自定义source 这里很重要

create进去

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

这里有一个RxJavaPlugins.onAssembly 再跟踪进去

/**
 * Calls the associated hook function.
 * @param <T> the value type
 * @param source the hook's input value
 * @return the value returned by the hook
 */
@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;
}

这个就是我们前面说的hook方法,不做处理的话这个f一定是null,所以这个方法相当于没什么作用,直接把sourse传过来又return回去了

继续跟踪new ObservableCreate<T>(source)

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

到这里主要做了什么

结论

1.new一了一个ObservableCreate实例

2.把我们传下来的自定义souere给到了 final ObservableOnSubscribe<T> source;

3：subscribe订阅过程源码分析

.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;
    }
}

前面都是一些健壮性,非null等判断,重要在 subscribeActual(observer);

继续跟踪

protected abstract void subscribeActual(Observer<? super T> observer);

谁继承并实现这个方法,很明显我们上面是Observable.create是new一了一个ObservableCreate实例

所以这里实际上是ObservableCreate.subscribe

去看ObservableCreate类

@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);
    }
}

(1)CreateEmitter<T> parent = new CreateEmitter<T>(observer); 这里,new了一个发射器,并把我们的自定义观察者放了进去,意思就是现在这个发射器是持有我们的观察者这个对象的

(2)observer.onSubscribe(parent);//这个就能看出为什么我们一点订阅@Override public void onSubscribe(Disposable d) { }这个方法就会执行了

(3)source.subscribe(parent);//看到这里就连续起来了,source就是我们前面的自定义soure,实际上这里就是调用了

new ObservableOnSubscribe<String>() {

@Override

public void subscribe(ObservableEmitter<String> emitter) throws Exception {

// 发射器.onNext emitter.onNext("A");

}

我们看下ObservableEmitter这个是什么

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);

    /**
     * Returns true if the downstream disposed the sequence.
     * @return true if the downstream disposed the sequence
     */
    boolean isDisposed();

    /**
     * Ensures that calls to onNext, onError and onComplete are properly serialized.
     * @return the serialized ObservableEmitter
     */
    @NonNull
    ObservableEmitter<T> serialize();

    /**
     * Attempts to emit the specified {@code Throwable} error if the downstream
     * hasn't cancelled the sequence or is otherwise terminated, returning false
     * if the emission is not allowed to happen due to lifecycle restrictions.
     * <p>
     * Unlike {@link #onError(Throwable)}, the {@code RxJavaPlugins.onError} is not called
     * if the error could not be delivered.
     * @param t the throwable error to signal if possible
     * @return true if successful, false if the downstream is not able to accept further
     * events
     * @since 2.1.1 - experimental
     */
    @Experimental
    boolean tryOnError(@NonNull Throwable t);
}

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();
}

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;
    }

CreateEmitter 实现了ObservableEmitter接口，同时ObservableEmitter接口又继承了Emitter接口。
CreateEmitter 还实现了Disposable接口，这个disposable接口是用来判断是否中断事件发射的。
从名称上就能看出，这个是发射器，故名思议是用来发射事件的，正是它将上游产生的事件发射到下游的。
Emitter是事件源与下游的桥梁。

看下onNext载CreateEmitter中的具体实现(CreateEmitter是在ObservableCreate中的内部类)

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);
    }
}

这里直接就通过自定义观察者observer调用onNext

就到这里来了

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() { } });

到这里基本整个流程就通了,图如下

时序图如下

===================================================================================================================================================

下面分析带map关键字的源码

还是一样先上一段代码

 // ObseravbleCreate  自定义source传递进去了 == source
    Observable.create(

            // 自定义source
            new ObservableOnSubscribe<String>() {
                @Override
                public void subscribe(ObservableEmitter<String> e) throws Exception {

                }
    })

     //  ObseravbleCreate.map
    .map(new Function<String, Bitmap>() {
        @Override
        public Bitmap apply(String s) throws Exception {
            return null;
        }
    })

    // ObservableMap.subscribe
    .subscribe(

            // 自定义观察者（终点）
            new Observer<Bitmap>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(Bitmap bitmap) {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            });
}

new观察者跟new被观察的流程都跟上面分析的一致,这里就不再去分析了,不同的就是订阅变了

先看map方法,

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
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

final Function<? super T, ? extends U> function;

public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
    super(source);
    this.function = function;
}

这里主要是

(1)把上层给的数据做了个转化由T-R并把R给Return回去了

(2)new了一个ObservableMap对象把function保存下来

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; } }

跟上面的不一样的是上面是

ObservableCreate.subscribe现在变成 ObservableMap.subscribe  实际ObservableMap.subscribeActual

@Override
public void subscribeActual(Observer<? super U> t) {
    source.subscribe(new MapObserver<T, U>(t, function));
}

这里的t是我们的自定义观察者的,这里作了个打包操作称作(包裹1)

这里的source是我们的上一层,上一层是ObservableCreate,如果前面还有map操作符会继续对数据进行打包

subscribe方面进去

public interface ObservableSource<T> {

    /**
     * Subscribes the given Observer to this ObservableSource instance.
     * @param observer the Observer, not null
     * @throws NullPointerException if {@code observer} is null
     */
    void subscribe(@NonNull Observer<? super T> observer);
}

这个实现在Observable.java

@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;
    }
}

protected abstract void subscribeActual(Observer<? super T> observer);

所以还是调用了ObservableCreate.subscribeActual

@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);
    }
}

这里的observer是我们上面的包裹1,这里有个发射器,相当于又进行了一次打包，称作包裹2

这里的source就是自定义的source.

public void subscribe(ObservableEmitter<String> emitter) throws Exception { // 发射器.onNext emitter.onNext("A"); }

又调用到这里了这里的onNext调用到注意这里的emitter是包裹2

ObservableMap中的onNext这里的onNext主要就是做变换Function是用户自己实现的返回R

@Override
public void onNext(T t) {
    if (done) {
        return;
    }

    if (sourceMode != NONE) {
        actual.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;
    }
    actual.onNext(v);
}

public interface Function<T, R> {
    /**
     * Apply some calculation to the input value and return some other value.
     * @param t the input value
     * @return the output value
     * @throws Exception on error
     */
    R apply(@NonNull T t) throws Exception;
}

这里的t就是我们的一级包裹了

这里的mapper是我们的终点，自定义观察者

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;
    }

最后调用到自定义观察的OnNext

图如下