Rxjava总结

1、创建类操作符返回一个具体的Observable,如just返回ObservableFromArray 它里面重写了subscribeActual
2、Observable调用subscribe的时候会根据重写的回调方法Consumer，构建一个新的Observer(LambdaObserver),如果对应的方法没有，则使用默认的Consumer，如没有onError,则使用Functions.ON_ERROR_MISSING
3、步骤二中如果调用的是safeSubscribe,则新建的Observer是SafeObserver
4、对步骤一返回的具体的Observable调用subscribe参数为步骤2或者3中的Observer
5、subscribe函数调用subscribeActual(由Observable进行重写),subscribeActual中进行具体的数据发送

6、变换类操作符会有当前Observable和变换函数为参数创建一个新的Observable，如map

以just为例

Observable.just("1", "2").subscribe(System.out::println);

步骤1 

 public static <T> Observable<T> just(T item1, T item2) {
        ObjectHelper.requireNonNull(item1, "The first item is null");
        ObjectHelper.requireNonNull(item2, "The second item is null");

        return fromArray(item1, item2);
    }
  public static <T> Observable<T> fromArray(T... items) {
        ObjectHelper.requireNonNull(items, "items is null");
        if (items.length == 0) {
            return empty();
        } else
        if (items.length == 1) {
            return just(items[0]);
        }
        return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
    }

返回的是ObservableFromArray

步骤2

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

创建了一个LambdaObserver，并调用subscrible,这里对应上面步骤4，没有步骤3

步骤5

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

调用ObservableFromArray的subscribeActual

 public void subscribeActual(Observer<? super T> observer) {
        FromArrayDisposable<T> d = new FromArrayDisposable<T>(observer, array);

        observer.onSubscribe(d);

        if (d.fusionMode) {
            return;
        }

        d.run();
    }

 void run() {
            T[] a = array;
            int n = a.length;

            for (int i = 0; i < n && !isDisposed(); i++) {
                T value = a[i];
                if (value == null) {
                    downstream.onError(new NullPointerException("The " + i + "th element is null"));
                    return;
                }
                downstream.onNext(value);
            }
            if (!isDisposed()) {
                downstream.onComplete();
            }
        }

进行数据的发送。

 

对于第6点

我们以下面demo

        Observable.just("1", "2").map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) throws Exception {
                return Integer.parseInt(s);
            }
        }).subscribe(System.out::println);

在进行map的时候

  @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，ObservableMap继承AbstractObservableWithUpstream，AbstractObservableWithUpstream里面有一个source代表的是原来的Observable

ObservableMap中有一个function代表变换函数

由前面分析可知这里最终会调用ObservableMap的subscribeActual

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

这里new 了一个MapObserver并把原来的Observer和变换函数作为参数传给他

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最终调用ObservableFromArray的subscribeActual，只是传递的参数由原来的LambdaObserver变成了MapObserver(MapObserver里面包含了原来的LambdaObserver)

同样最后在调用

FromArrayDisposable中的run

 void run() {
            T[] a = array;
            int n = a.length;

            for (int i = 0; i < n && !isDisposed(); i++) {
                T value = a[i];
                if (value == null) {
                    downstream.onError(new NullPointerException("The " + i + "th element is null"));
                    return;
                }
                downstream.onNext(value);
            }
            if (!isDisposed()) {
                downstream.onComplete();
            }
        }

这里downstream是MapObserver，所以调用到MapObserver的onNext

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

这是MapObserver的onNext，可以看到他先对传进来的值调用mapper进行变换，然后调用原来的Observer的onNext并把新值传递过去。

 

由上面的分析可知，Rxjava创建类操作符是生成一个子类Observable,主要是在重写subscribeActual进行数据的发送

                               Rxjava变换类操作符是会对应生成一个子类型的Observable，但是原始的Observable也保存在其source变量中，然后在后面调用subscribeActual对原来的观察者Observer进行包装，对数据进行处理在交给原来的observer。他也是通过重写subscribeActual，不过主要是在subscribeActual进行数据的变换。