Notas de análisis del código fuente de RxJava2 (2)

Artículo anterior: Notas de análisis del código fuente de RxJava2 (1)

Artículo siguiente: notas de análisis de código fuente de RxJava2 (3) cambio de hilo

Veamos cómo funciona una llamada más complicada

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

1   

Observable. Simplemente haga clic en el código fuente y descubra que la devolución es Observable.

                   .map devuelve ObservableMap

                  .flatMap devuelve ObservableFlatMap

   

ObservableJust, ObservableMap, ObservableFlatMap: todos heredan directa o indirectamente Observable; todos implementan el método subscribeActual ellos mismos;

Código fuente

.sólo

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

.mapa

   @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 (algunos clics más y finalmente haga clic aquí)

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

Entonces se volvió así

En el último paso de subscribe, la primera llamada es subscribeActual en ObservableFlatMap

Entonces eche un vistazo al código fuente de 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));

    }

La implementación es source.subscribe (new MergeObserver <T, U> (...));

Esta fuente se pasa en el constructor

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

Se llama al constructor cuando .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));
}

De esta manera, la fuente encuentra el ObservableMap al frente,

source.subscribe es igual a ObservableMap.subscribe y pasa el MergeObserver creado por usted mismo a ObservableMap

Esto se convierte en la siguiente imagen

Esto es

ObservableMap.subscribe

La llamada real es el método subscribeActual en ObservableMap

Entonces mira el código fuente de 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));

    }

Ver el código fuente de ObservabelMap se siente muy familiar, la misma fuente.

Sí, esta fuente es el ObservableJust anterior, por lo que puede pasar el MapObserver que creó a ObservableJust

 Ahora para ObservableJust.subscribe es ejecutar el método subscribeActual en ObservableJust

ObservableJust código fuente

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

Finalmente es diferente, llegamos a la fuente de datos, el siguiente paso es cómo transferir los datos de regreso

El código central es sd.run (); 

Nota:

De esta forma, algunas columnas de suscripción pasarán un Observador a la capa superior

Nuestro observador creado por nosotros mismos ——> MergeObserver ——> MapObserver

Todos implementan Observer y utilizan el Observer anterior para crear sus propios objetos.

Veamos  sd.run ();

Código fuente 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();
                }
            }
        }

El núcleo de la ejecución es llamar a MapObserver.onNext

Luego mire el código fuente de 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 

A continuación, eche un vistazo al código fuente de 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;
                }
            }
        }

Ahora esta aqui 

p.subscribe (interior); 

p: Al principio, devolvimos uno en flatMap

   Observable.fromIterable(list)

inner: InnerObserver

y entonces

p.subscribe (interior) = Observable.fromIterable (lista) .subscribe (interior);

¿Te sientes familiar? ¿No es este otro Observable ... hasta el final suscríbete?

Observable.fromIterable (lista) es en realidad un objeto ObservableFromIterable

ObservableFromIterable.subscribe (inner) esencialmente llama al subscribeActual de ObservableFromIterable

Luego mire el código fuente 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();
        }
    }

Ahora es d.run (); d es FromIterableDisposable, y el interior y los datos en los que se pasa

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

Finalmente llegó inner.onNext con el valor

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

    

Hace clic y encuentra que real se encuentra en MergeObserver, porque InnerObserver es una clase interna de MergeObserver;

Y actual es el Observador que creamos nosotros mismos

Observer.onNext (valor) es

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

            }
        });

 

Esto completa el flujo de llamadas.

El proceso general es que Observable.create / just / from comienza a crear varias subclases de Obserable all para implementar subclassActual, hasta que finalmente suscribe un Observer, y luego comienza a llamar al subscribeActual del Obserable anterior, y habrá uno en el subscribeActual método source.subscribe (...); Esto siempre volverá a llamar al subscribeActual del Obserable anterior, y al mismo tiempo pasará el Observador que creaste (el constructor usará el Observador anterior como parámetro) al Obserable anterior hasta create / just / From comenzó a usar el Observer que se ha pasado para pasar el valor, y finalmente pasó a nuestro propio Observer, obtuvimos el valor.

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

Al principio del artículo, aprobé Consumidor en suscribirse

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

¿Cómo devuelve la llamada al consumidor? A continuación, no tiene este método

Al hacer clic en el código fuente hasta el final, el consumidor que pasamos se convertirá en 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;
    }

Luego mire el código fuente de 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);
            }
        }
    }

Llamar a Consumer.accept en onNext es la devolución de llamada del objeto que pasamos.