RxJava2 源码分析笔记(二)

下面来看一个复杂一点的调用是如何工作的

                 AStudent aStudent = new AStudent();//我自己建的类
                 aStudent.setName(" dog ");           
       
                Observable
                .just(aStudent)

                .map(new Function<AStudent, String>() {
                    @Override
                    public String apply(@NonNull AStudent student) throws Exception {
                        String name = student.getName();
                        return name;
                    }
                })

                .flatMap(new Function<String, Observable<String>>() {
                    @Override
                    public Observable<String> apply(@NonNull String s) throws Exception {
                        List<String> list = new ArrayList();
                        list.add(" i  add " + s);
                        return Observable.fromIterable(list);
                    }
                })

                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        System.out.println(" subscribe " + s);
                    }
                });

Observable .just 点进源码发现返回的是ObservableJust

.map 返回的是ObservableMap

.flatMap 返回的是ObservableFlatMap

ObservableJust,ObservableMap,ObservableFlatMap：都直接或间接继承了Observable；都自己实现了subscribeActual方法；

源码

.just

扫描二维码关注公众号，回复： 12396586 查看本文章

   @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> just(T item) {
        ObjectHelper.requireNonNull(item, "The item is null");
        return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));//ObservableJust
    }

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

.flatmap(多点几下最后点到这里)

 @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper,
            boolean delayErrors, int maxConcurrency, int bufferSize) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        ObjectHelper.verifyPositive(maxConcurrency, "maxConcurrency");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        if (this instanceof ScalarCallable) {
            @SuppressWarnings("unchecked")
            T v = ((ScalarCallable<T>)this).call();
            if (v == null) {
                return empty();
            }
            return ObservableScalarXMap.scalarXMap(v, mapper);
        }
        return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));//ObservableFlatMap
    }

然后就变成了这样

到最后一步subscribe的时候首先调用的是ObservableFlatMap中的subscribeActual

那就看一下ObservableFlatMap源码

public final class ObservableFlatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
    final boolean delayErrors;
    final int maxConcurrency;
    final int bufferSize;

    public ObservableFlatMap(ObservableSource<T> source,
            Function<? super T, ? extends ObservableSource<? extends U>> mapper,
            boolean delayErrors, int maxConcurrency, int bufferSize) {
        super(source);
        this.mapper = mapper;
        this.delayErrors = delayErrors;
        this.maxConcurrency = maxConcurrency;
        this.bufferSize = bufferSize;
    }

    @Override
    public void subscribeActual(Observer<? super U> t) {

        ...

          //核心代码
          // MergeObserver 实现了Observer，这个对象作用很大
          //他的构造函数传入了t, 也就是我们自己指定的Oberver
          //也就是说它利用我们自己创建的Oberver新建了一个自己的Observer对象      
        source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize));

    }

执行的是 source.subscribe( new MergeObserver<T, U>( ...) );

这个source是构造函数中传入的

public ObservableFlatMap(ObservableSource<T> source,
        Function<? super T, ? extends ObservableSource<? extends U>> mapper,
        boolean delayErrors, int maxConcurrency, int bufferSize) {
    super(source);
    this.mapper = mapper;
    this.delayErrors = delayErrors;
    this.maxConcurrency = maxConcurrency;
    this.bufferSize = bufferSize;
}

构造函数是在 .flatMap时候调用的

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper,
        boolean delayErrors, int maxConcurrency, int bufferSize) {
     ...省略其它代码...
    //这个this是什么呢，就是谁.flatMap;根据上面是ObservableMap.flatMap
    return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));
}

这样source就找到了是前面的ObservableMap，

source.subscribe 等于 ObservableMap.subscribe ，并将自己创建的MergeObserver传到ObservableMap中

这样就变成了下图

这样就是

ObservableMap.subscribe

真实调用的就是ObservableMap中的subscribeActual方法

接着就看ObservableMap的源码

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;

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

    @Override
    public void subscribeActual(Observer<? super U> t) {

        //他也是利用传进来的Observer创建了自己新的Observer对象MapObserver
        //并subcribe到上一层
        source.subscribe(new MapObserver<T, U>(t, function));

    }

看到ObservabelMap的源码感觉很熟悉，同样的 source.subscribe

是的这个source就是前面的 ObservableJust，这样就将自己创建的MapObserver传到ObservableJust中

现在到了 ObservableJust.subscribe 就是执行ObservableJust中的subscribeActual 方法

ObservableJust源码

public final class ObservableJust<T> extends Observable<T> implements ScalarCallable<T> {

    //这里的value就是 Observable.just(aStudent)中的aStudent对象
    //这里赋值并会传递下去
    private final T value;
    public ObservableJust(final T value) {
        this.value = value;
    }

    @Override
    protected void subscribeActual(Observer<? super T> s) {
         
        ScalarDisposable<T> sd = new ScalarDisposable<T>(s, value);
        s.onSubscribe(sd);
        sd.run();
    }

终于不一样了，我们来到了数据源这里，接下来就是把数据怎么传回去了

核心代码是 sd.run();

注意：

这样一些列subscribe都会传递一个Observer到上一层

我们自己自创建的 observer ——> MergeObserver ——> MapObserver

他们都实现了Observer,并利用前一个Observer创建自己的对象。

我们接着来看 sd.run();

ScalarDisposable源码

public static final class ScalarDisposable<T>
    extends AtomicInteger
    implements QueueDisposable<T>, Runnable {

      // 这个Observer就是 MapObserver
      final Observer<? super T> observer;

       ...省略其他代码.......

        public ScalarDisposable(Observer<? super T> observer, T value) {
            this.observer = observer;
            this.value = value;
        }

        @Override
        public void run() {
            if (get() == START && compareAndSet(START, ON_NEXT)) {
                //即 MapObserver.onNext
                //value就是aStudent
                observer.onNext(value);
                if (get() == ON_NEXT) {
                    lazySet(ON_COMPLETE);
                    observer.onComplete();
                }
            }
        }

在run中核心是调用了MapObserver.onNext

接着就看下MapObserver的源码

  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) {           
          
            //这个actual就是上一个传进来的MergeObserver
            // actual变量位置在其父类BasicFuseableObserver
            //本质就是使用传进来的MergeObserver
            super(actual);
            this.mapper = mapper;
        }

        @Override
        public void onNext(T t) {
            ...代码省略...
            
            U v;

            try {
                //还记得我们在.map中return student.getName();
                // .map(new Function<AStudent, String>() {
                //    @Override
                //    public String apply(@NonNull AStudent student) throws Exception {
                //       String name = student.getName();
                //       return name;
                //    }
                // })    
                // mapper.apply(t) 就是调用了 apply(@NonNull AStudent student)
                // t就是ObservableJust传过来的astudent对象
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            
            //真实调用就是MergeObserver.onNext
            actual.onNext(v);

        }

 核心就是 MergeObserver.onNext

接下来就看一下MergeObserver的源码

 static final class MergeObserver<T, U> extends AtomicInteger implements Disposable, Observer<T> {

        
        // actual 就是我们自己创建的Observer
        final Observer<? super U> actual;
       
        MergeObserver(Observer<? super U> actual, Function<? super T, ? extends ObservableSource<? extends U>> mapper,
                boolean delayErrors, int maxConcurrency, int bufferSize) {
            
           this.actual = actual;
            
           ...其他代码省略...
        }

        @Override
        public void onSubscribe(Disposable s) {
            if (DisposableHelper.validate(this.s, s)) {
                this.s = s;
                actual.onSubscribe(this);
            }
        }

        @Override
        public void onNext(T t) {
             
            try {
                //因为这是FlatMap,通过apply， return的值
                //t就是前面传过来的aStudent的name的值
                // .flatMap(new Function<String, Observable<String>>() {
                //    @Override
                //  public Observable<String> apply(@NonNull String s) throws Exception {
                //        List<String> list = new ArrayList();
                //        list.add(" i  add " + s);
                //        return Observable.fromIterable(list);
                //    }
                //   })
                // mapper.apply(t)就是apply(@NonNull String s)
                p = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
            } catch (Throwable e) {
                
                return;
            }

             
            // step1
            subscribeInner(p);

        }

        @SuppressWarnings("unchecked")
        void subscribeInner(ObservableSource<? extends U> p) {
            for (;;) {
                if (p instanceof Callable) {
                    //这里p不是Callable
                } else {
                    InnerObserver<T, U> inner = new InnerObserver<T, U>(this, uniqueId++);
                    if (addInner(inner)) {
                        // step2
                        p.subscribe(inner);
                    }
                    break;
                }
            }
        }

现在走到了

p.subscribe(inner);

p: 在最开始的地方我们在flatMap中return了一个

   Observable.fromIterable(list)

inner: InnerObserver

所以

p.subscribe(inner) = Observable.fromIterable(list).subscribe(inner);

有没有感觉很熟悉，这不就是另外一个Observable .......到最后subscribe.

Observable.fromIterable(list)其实就是一个ObservableFromIterable对象

ObservableFromIterable.subscribe(inner)本质就是调用ObservableFromIterable的subscribeActual

那就看ObservableFromIterable源码

public final class ObservableFromIterable<T> extends Observable<T> {
    
    //source就是fromIterable(list)传进来的list
    final Iterable<? extends T> source;

    public ObservableFromIterable(Iterable<? extends T> source) {
        
        this.source = source;
    }

    @Override
    public void subscribeActual(Observer<? super T> s) {
        Iterator<? extends T> it;
        
        //用source生成数据
        it = source.iterator();
         
        //s就是传进来的inner
        FromIterableDisposable<T> d = new FromIterableDisposable<T>(s, it);
        s.onSubscribe(d);

        if (!d.fusionMode) {
           //核心代码
            d.run();
        }
    }

现在到了d.run(); d就是FromIterableDisposable，并将inner和数据it传了进去

 static final class FromIterableDisposable<T> extends BasicQueueDisposable<T> {

        final Observer<? super T> actual;

        final Iterator<? extends T> it;

       
        // actual就是inner; it 就是那个list数据
        FromIterableDisposable(Observer<? super T> actual, Iterator<? extends T> it) {
            this.actual = actual;
            this.it = it;
        }

        void run() {
            boolean hasNext;

            do {
                ...


                try {
                    //这里就是循环取list中的数据
                    v = ObjectHelper.requireNonNull(it.next(), "The iterator returned a null value");
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    actual.onError(e);
                    return;
                }
                
                //核心代码
                //即 inner.onNext(数值)
                actual.onNext(v);

                ....
            } while (hasNext);

            if (!isDisposed()) {
                actual.onComplete();
            }
        }

终于到了 inner.onNext 并带着数值

static final class InnerObserver<T, U> extends AtomicReference<Disposable>
    implements Observer<U> {

        
        final long id;
        final MergeObserver<T, U> parent;

        

        InnerObserver(MergeObserver<T, U> parent, long id) {
            this.id = id;
            this.parent = parent;
        }
        
     
        @Override
        public void onNext(U t) {
            if (fusionMode == QueueDisposable.NONE) {
                //核心代码
                // t 上一步传过来的数值，再传到tryEmit中
                parent.tryEmit(t, this);
            } else {
                parent.drain();
            }
        }

        void tryEmit(U value, InnerObserver<T, U> inner) {
            if (get() == 0 && compareAndSet(0, 1)) {
                .....
                //核心代码
                actual.onNext(value);
                 
            } else {
               .....
            }
            drainLoop();
        }

你点一下发现 actual 是位于 MergeObserver 中，因为InnerObserver就是MergeObserver的一个内部类；

而actual就是我们自己创建的Observer

Observer.onNext(value)就是

Observable
        .just(aStudent)
        .map(...)
        .flatMap(...)
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull String s) {
              数值终于回调到这里了
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

这样整个调用流程就走完了。

大体流程就是Observable.create/just/from开始不停地创建Obserable的各种子类都实现了 subscribeActual ，直到最后subcribe了一个Observer,然后开始回调前一个Obserable的subscribeActual，而在subscribeActual方法中会有一个source.subscribe(...);这样就会一直回调上一个Obserable的subscribeActual，并同时将自己创建的Observer(构造函数都会用前一个Observer作为参数)传到前一个Obserable中，直到 create/just/from 开始利用一直传过来的Observer进行传值，最后传到我们自己的Observer中，我们就拿到了值。

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

文章开始的时候我在subscribe中传入的是Consumer

 Observable
                .just(aStudent)
                .map(new Function<AStudent, String>() {
                    @Override
                    public String apply(@NonNull AStudent student) throws Exception {
                        String name = student.getName();
                        return name;
                    }
                })
                .flatMap(new Function<String, Observable<String>>() {
                    @Override
                    public Observable<String> apply(@NonNull String s) throws Exception {
                        List<String> list = new ArrayList();
                        list.add(" i  add " + s);
                        return Observable.fromIterable(list);
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        System.out.println(" subscribe " + s);
                    }
                });

Consumer是怎么回调的oNext,它并没有这个方法

点进源码一直点到最后，原来我们传入的Consumer会被转化成LambdaObserver

 @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
            Action onComplete, Consumer<? super Disposable> onSubscribe) {
       
         ........
    
        // onNext 就是我们传进来的Consumer，其他参数是源码中自动帮我们添加的值
        LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);

        subscribe(ls);

        return ls;
    }

那就再看LambdaObserver源码

public final class LambdaObserver<T> extends AtomicReference<Disposable>
        implements Observer<T>, Disposable, LambdaConsumerIntrospection {

     
    final Consumer<? super T> onNext;
   
    public LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
            Action onComplete,
            Consumer<? super Disposable> onSubscribe) {
        super();
        this.onNext = onNext;
        this.onError = onError;
        this.onComplete = onComplete;
        this.onSubscribe = onSubscribe;
    }

    @Override
    public void onNext(T t) {
        if (!isDisposed()) {
            try {
                //核心代码
                onNext.accept(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                get().dispose();
                onError(e);
            }
        }
    }

在onNext中调用了 Consumer.accept 就是我们传入的对象的回调。

RxJava2 源码分析笔记(二)

猜你喜欢