Reactor详解

代码

// 生成过程
Flux<List<String>> flux= Flux.just("您好(asd)","世界(sdf)","中国(axv)","香港(tyu)","台湾(hupa)","澳门(bnm)")
                .filter(s->s.contains("a"))
                .map(s-> s+"-aaa")
                .flatMap(s->Flux.just(s))
                .buffer(2);
// 订阅过程
flux.subscribe(s->System.out.println(s));

解析

共三个部分 ： 序列流创建过程、序列流操作过程、序列流订阅过程。

interface Publisher 的类图

• Publisher简单类图
  

• Publisher的内部类类图
  

从图中可以看出:
Publisher 有一个重要的实现类 Flux , Flux implements Publisher 。
Publisher 两外两个身份标识接口 ： SourceProducer ，OptimizableOperator。
序列流 资源(生产/创建)类 ： 继承了 Flux ，实现 SourceProducer 。
序列流 操作类 ： 间接 继承了 Flux ，实现 OptimizableOperator。
资源类的内部类 主要实现了 Subscription 接口。
操作类的内部类 主要实现了 InnerOperator 接口，而 InnerOperator extends Subscription, Subscriber 。

interface Subscriber 的类图

从图中可以看出:
Publisher 主要有一个子接口： CoreSubscriber。
LambdaSubscriber 主要实现了 ： CoreSubscriber ，Disposable 。

总结

创建过程会生成 序列流 资源类，
操作过程会生成 序列流 操作类，
订阅过程会生成 序列流 订阅类，
资源类 和 操作类 属于 Flux ，而 Flux 实现了 Publisher，
资源类 和 操作类 也有身份标识接口：资源类的身份标识接口是 SourceProducer ，操作类的身份标识接口是 OptimizableOperator。

主要接口 ： Publisher( 发布者接口 ) ， Subscriber( 订阅者接口 ) ，Subscription( 订阅关系接 )，Disposable(废弃者接口)
Publisher ： 一般 资源类，操作类 实现此接口，表明是 发布者身份。
Subscriber ：一般 订阅者 实现此接口，表明是 订阅者身份。
Subscription ： 一般 资源类内部类 ，操作类内部类 实现此接口，表明 此内部类 可以维护 发布订阅关系。
Disposable ： 一般 订阅者 实现此接口，表明是 可以取消订阅 。

资源类的内部类 主要实现了 Subscription 接口，
操作类的内部类 主要实现了 Subscription, Subscriber 接口，
订阅类没有内部类。

序列流创建过程

• 先了解 Flux 一个方法

// Flux 的方法: 这个方法主要是： 钩子函数的初始化，全局TRACE ( 可以忽略这些 )，最终返回参数本身。
protected static <T> Flux<T> onAssembly(Flux<T> source) {
    Function<Publisher, Publisher> hook = Hooks.onEachOperatorHook;
    if (hook != null) {
        source = (Flux)hook.apply(source);
    }
    
    if (Hooks.GLOBAL_TRACE) {
        AssemblySnapshot stacktrace = new AssemblySnapshot(
                (String)null, (Supplier)Traces.callSiteSupplierFactory.get()    );
        source = (Flux)Hooks.addAssemblyInfo(source, stacktrace);
    }
    return source;
}

just(“您好(asd)”,“世界(sdf)”,“中国(axv)”,“香港(tyu)”,“台湾(hupa)”,“澳门(bnm)”)

调用主体是 Flux 工具类， 此类是系统提供的。

// Flux 的方法
public static <T> Flux<T> just(T... data) {
    return fromArray(data);
}
// Flux 的方法
public static <T> Flux<T> fromArray(T[] array) {
    if (array.length == 0) {
        return empty();
    } else {
        // 
        return array.length == 1 ? 
            just(array[0]) : 
            onAssembly((Flux)(new FluxArray(array)));
    }
}
// FluxArray 构造
public FluxArray(T... array) {
    //  array 属性 起到一个 保存 Flux 资源引用（资源标识）的作用 
    this.array = (Object[])Objects.requireNonNull(array, "array");
}

可以看出 just() ：生成了 FluxArray 实例，并保存了 资源引用（资源标识），然后返回 此 FluxArray 实例 ，记作 fluxArray。

总结

序列流创建过程 ：
创建一个序列流的 资源(SourceProducer) 类,并且把 我们提供的资源 封装进 此资源类中。

序列流操作过程

filter(s->s.contains(“a”))

调用主体是 上一步生成的 FluxArray 实例 : fluxArray

// Flux 的方法，主要作用就是 生成内部类对象
// FluxFilterFuseable ，FluxFilter 都是 操作类
public final Flux<T> filter(Predicate<? super T> p) {
    // 由类图可知，FluxArray 实现了 Fuseable ，三目运算为 true 
    return this instanceof Fuseable ?
        // this : 调用者 fluxArray , p : Predicate 实例 ( 记作 predicate ) 
        onAssembly((Flux)(new FluxFilterFuseable(this, p))) : 
        onAssembly((Flux)(new FluxFilter(this, p)));
}

// FluxFilterFuseable 的构造
 FluxFilterFuseable(Flux<? extends T> source, Predicate<? super T> predicate) {
    super(source);// 调用父类构造
    //  predicate 属性 起到一个 保存 Flux 操作源引用（操作源标识、操作源函数）的作用
    this.predicate = (Predicate)Objects.requireNonNull(predicate, "predicate");
}
// FluxFilterFuseable 的 父类 InternalFluxOperator 的构造
protected InternalFluxOperator(Flux<? extends I> source) {
    super(source);
    if (source instanceof OptimizableOperator) {
        OptimizableOperator<?, I> optimSource = (OptimizableOperator)source;
        this.optimizableOperator = optimSource;
    } else {  // 执行这一步， 因为 调用者 FluxArray 是 资源类
        // optimizableOperator 属性 起到 一个标识的作用
        this.optimizableOperator = null;
    }
}
//  FluxFilterFuseable 的 超父类 FluxOperator 的构造
protected FluxOperator(Flux<? extends I> source) {
    // source 属性 起到一个 连接上一个 Flux 的作用
    this.source = (Flux)Objects.requireNonNull(source);
}

至此， FluxFilterFuseable 实例（记作 fluxFilterFuseable ）已经构建完成,而且初始化属性：
this.source = fluxArray ： 连接上一个 Flux 实例
this.predicate = predicate ： flux 源引用（资源引用 或 操作源引用）
this.optimizableOperator = null ：标识 上一个Flux实例类型，即标识 source 属性的类别（是资源者 还是操作者）。

optimizableOperator 是 如何 标识的？ 就是直接保存 上一个Flux实例类型

可以看出 filter() ： 生成了 FluxFilterFuseable 实例 ，
并 连接上一个Flux实例、保存了 flux 源引用（资源，操作源）、标识了 source 属性的类别（是资源者 还是操作者），然后 返回此 FluxFilterFuseable 实例 ，
记作 fluxFilterFuseable 。

map(s-> s+"-aaa")

调用主体是 上一步生成的 FluxFilterFuseable 实例 : fluxFilterFuseable

// Flux 的方法
public final <V> Flux<V> map(Function<? super T, ? extends V> mapper) {
    // 由类图可知，FluxFilterFuseable 实现了 Fuseable ，三目运算为 true 
    return this instanceof Fuseable ?
        // this : 调用者 fluxFilterFuseable , mapper : Function 实例 ( 记作 mapper1 ) 
        onAssembly((Flux)(new FluxMapFuseable(this, mapper))) : 
        onAssembly((Flux)(new FluxMap(this, mapper)));
}

// FluxMapFuseable 的构造
 FluxMapFuseable(Flux<? extends T> source, Function<? super T, ? extends R> mapper) {
    super(source);
    this.mapper = (Function)Objects.requireNonNull(mapper, "mapper");
}
// FluxMapFuseable 的 父类 InternalFluxOperator 的构造
protected InternalFluxOperator(Flux<? extends I> source) {
    super(source);
    if (source instanceof OptimizableOperator) {  // 执行这一步，因为调用者 fluxFilterFuseable 是 操作者
        OptimizableOperator<?, I> optimSource = (OptimizableOperator)source;
        this.optimizableOperator = optimSource;
    } else { 
        this.optimizableOperator = null;
    }
}
//  FluxMapFuseable 的 超父类 FluxOperator 的构造
protected FluxOperator(Flux<? extends I> source) {
    this.source = (Flux)Objects.requireNonNull(source);
}

至此， FluxMapFuseable 实例（记作 fluxMapFuseable ）已经构建完成,而且初始化属性：
this.source = fluxFilterFuseable ： 连接上一个 Flux 实例
this.mapper = mapper1 ： flux 源引用（资源引用 或 操作源引用）
this.optimizableOperator = fluxFilterFuseable ：标识 上一个Flux实例类型，即标识 source 属性的类别（是资源者 还是操作者）。

optimizableOperator 是 如何 标识的？ 就是直接保存 上一个Flux实例类型

可以看出 map() ： 生成了 FluxMapFuseable 实例 ，
并 连接上一个Flux实例、保存了 flux 源引用（资源，操作源）、标识了 source 属性的类别（是资源者 还是操作者，
然后 返回此 FluxFilterFuseable 实例 ，
记作 fluxMapFuseable 。

flatMap(s->Flux.just(s))

调用主体是 上一步生成的 FluxMapFuseable 实例 : fluxMapFuseable

// Flux 的方法
public final <R> Flux<R> flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper) {
    return this.flatMap(mapper, Queues.SMALL_BUFFER_SIZE, Queues.XS_BUFFER_SIZE);
}
// Flux 的方法
public final <V> Flux<V> flatMap(Function<? super T, ? extends Publisher<? extends V>> mapper, int concurrency, int prefetch) {
    return this.flatMap(mapper, false, concurrency, prefetch);
 }
// Flux 的方法
final <V> Flux<V> flatMap(Function<? super T, ? extends Publisher<? extends V>> mapper, 
        boolean delayError, int concurrency, int prefetch) {
    // 前两个参数 是程序传递过来的，其他参数是系统提供的
    return onAssembly(
            (Flux)(
                    // this : 调用者 fluxMapFuseable , mapper : Function 实例 ( 记作 mapper2 ) 
                    new FluxFlatMap(this, mapper, delayError, concurrency, Queues.get(concurrency), prefetch, Queues.get(prefetch))
            )
        );
}

// FluxFlatMap 的构造
FluxFlatMap(Flux<? extends T> source, Function<? super T, ? extends Publisher<? extends R>> mapper, 
        boolean delayError, int maxConcurrency, Supplier<? extends Queue<R>> mainQueueSupplier, 
        int prefetch, Supplier<? extends Queue<R>> innerQueueSupplier) {
    super(source);
    if (prefetch <= 0) {
        throw new IllegalArgumentException("prefetch > 0 required but it was " + prefetch);
    } else if (maxConcurrency <= 0) {
        throw new IllegalArgumentException("maxConcurrency > 0 required but it was " + maxConcurrency);
    } else {
        this.mapper = (Function)Objects.requireNonNull(mapper, "mapper");
        this.delayError = delayError;
        this.prefetch = prefetch;
        this.maxConcurrency = maxConcurrency;
        this.mainQueueSupplier = (Supplier)Objects.requireNonNull(mainQueueSupplier, "mainQueueSupplier");
        this.innerQueueSupplier = (Supplier)Objects.requireNonNull(innerQueueSupplier, "innerQueueSupplier");
    }
}
// FluxFlatMap 的 父类 InternalFluxOperator 的构造
protected InternalFluxOperator(Flux<? extends I> source) {
    super(source);
    if (source instanceof OptimizableOperator) {  // 执行这一步
        OptimizableOperator<?, I> optimSource = (OptimizableOperator)source;
        this.optimizableOperator = optimSource;
    } else { 
        this.optimizableOperator = null;
    }
}
//  FluxFlatMap 的 超父类 FluxOperator 的构造
protected FluxOperator(Flux<? extends I> source) {
    this.source = (Flux)Objects.requireNonNull(source);
}

至此， FluxFlatMap 实例（记作 fluxFlatMap ）已经构建完成,而且初始化属性：
this.source = fluxMapFuseable ： 连接上一个 Flux 实例
this.mapper = mapper2 ： flux 源引用（资源引用 或 操作源引用）
this.optimizableOperator = fluxMapFuseable ：标识 上一个Flux实例类型，即标识 source 属性的类别（是资源者 还是操作者）。

optimizableOperator 是 如何 标识的？ 就是直接保存 上一个Flux实例类型

可以看出 flatMap() ： 生成了 FluxFlatMap 实例 ，
并 连接上一个Flux实例、保存了 flux 源引用（资源，操作源）、标识了 source 属性的类别（是资源者 还是操作者），然后 返回此 FluxFlatMap 实例 ，
记作 fluxFlatMap 。

buffer(2)

调用主体是 上一步生成的 FluxFlatMap 实例 : fluxFlatMap

// Flux 方法
public final Flux<List<T>> buffer(int maxSize) {
    return this.buffer(maxSize, listSupplier());
}
// Flux 方法
public final <C extends Collection<? super T>> Flux<C> buffer(int maxSize, Supplier<C> bufferSupplier) {
    return onAssembly((Flux)(new FluxBuffer(this, maxSize, bufferSupplier)));
}
// FluxBuffer 构造
FluxBuffer(Flux<? extends T> source, int size, Supplier<C> bufferSupplier) {
    this(source, size, size, bufferSupplier);
}
// FluxBuffer 构造
FluxBuffer(Flux<? extends T> source, int size, int skip, Supplier<C> bufferSupplier) {
    super(source);
    if (size <= 0) {
        throw new IllegalArgumentException("size > 0 required but it was " + size);
    } else if (skip <= 0) {
        throw new IllegalArgumentException("skip > 0 required but it was " + skip);
    } else {
        this.size = size;
        this.skip = skip;
        this.bufferSupplier = (Supplier)Objects.requireNonNull(bufferSupplier, "bufferSupplier");
    }
}
// FluxBuffer 的 父类 InternalFluxOperator 的构造
protected InternalFluxOperator(Flux<? extends I> source) {
    super(source);
    // 由类图可知，FluxBuffer 继承 OptimizableOperator
    if (source instanceof OptimizableOperator) {  // 执行这一步
        OptimizableOperator<?, I> optimSource = (OptimizableOperator)source;
        this.optimizableOperator = optimSource;
    } else {
        this.optimizableOperator = null;
    }
}
//  FluxBuffer 的 超父类 FluxOperator 的构造
protected FluxOperator(Flux<? extends I> source) {
    this.source = (Flux)Objects.requireNonNull(source);
}

至此，构建了 FluxBuffer 实例（记作 fluxBuffer ）,而且初始化属性：
this.source = fluxFlatMap
this.size = size
this.optimizableOperator = fluxFlatMap

总结

序列流操作过程： 每调用一次方法，就会生成一个新的操作对象，
并且会把调用者的引用赋值给新对象的 source 属性（无条件的赋值）和 optimizableOperator 属性（有条件的赋值），
而且 不会操作函数或操作标识赋值给新对象其他属性(mapper/predicate/…)。

序列流操作过程： 操作链生成的每一个 flux 实例，
都会持有上一个 Flux 实例的引用(source 属性)、
持有 一个辨别 source 属性值 类别的标识、
持有一个当前 flux 实例的 flux 源引用（资源引用，操作引用 ）。

optimizableOperator 属性 : 只有 第一个 操作对象实例 的 optimizableOperator 属性为 null ，
因为 第一个操作方法的调用者是资源对象， 资源对象 不属于 操作对象（OptimizableOperator）

序列流 创建和操作 总结：

序列流的创建和操作过程连在一起，就形成了 一个 Flux反向单向链表 （从前往后赋值）。
Flux 就是这个链表的 node 节点类 ， 关联属性是 source （ 这个属性是 向前指向 ）,

最后一个操作类对象 source属性 指向 倒数第二个操作类对象，
倒数第二个操作类对象 source属性 指向 倒数第三个操作类对象，
…
第一个操作类对象 source属性 指向 资源类对象；
而且 用 optimizableOperator 属性 来表明 source 属性值的类别
并 记录着 每一个 Flux 实例的 Flux源引用

序列流订阅过程

• 先来 来了解下 接口 OptimizableOperator 的方法

//通用方法 ： 是由 OptimizableOperator 的抽象类 InternalFluxOperator 实现
public final OptimizableOperator<?, ? extends I> nextOptimizableSource() {
    return this.optimizableOperator;
}
//通用方法 ： 是由 OptimizableOperator 的抽象类 InternalFluxOperator 实现
public final CorePublisher<? extends I> source() {
    return this.source;
}
//具体方法 ： 此方法是由具体的操作类实现，操作类不同，实现不同
// 通过代码分析 ，此方法的主要作用 ： 创建 具体操作类的 内部类对象 并返回，而且这些内部类都实现了 CoreSubscriber 接口       
CoreSubscriber<? super OUT> subscribeOrReturn(CoreSubscriber<? super IN> var1) throws Throwable

• 再看看 接口 OptimizableOperator 具体实现类的 subscribeOrReturn()方法 以及 内部类

//------------------- FluxFlatMap ----------------------------------------
final class FluxFlatMap<T, R> extends InternalFluxOperator<T, R> {
    // .....
    public CoreSubscriber<? super T> subscribeOrReturn(CoreSubscriber<? super R> actual) {
        return trySubscribeScalarMap(this.source, actual, this.mapper, false, true) ? 
                null : 
                // actual ：subscribe实例 ；this.mapper ： 操作函数或操作标识符
                new FluxFlatMap.FlatMapMain(actual, this.mapper, this.delayError, 
                        this.maxConcurrency, this.mainQueueSupplier, this.prefetch, 
                        this.innerQueueSupplier);
    }
    //内部类
    static final class FlatMapMain<T, R> 
            extends FlatMapTracker<FluxFlatMap.FlatMapInner<R>> implements InnerOperator<T, R> {
        // 内部类构造
        FlatMapMain(CoreSubscriber<? super R> actual, 
                    Function<? super T, ? extends Publisher<? extends R>> mapper, 
                    boolean delayError, int maxConcurrency, 
                    Supplier<? extends Queue<R>> mainQueueSupplier, 
                    int prefetch, Supplier<? extends Queue<R>> innerQueueSupplier) {
            this.actual = actual;
            this.mapper = mapper;
            this.delayError = delayError;
            this.maxConcurrency = maxConcurrency;
            this.mainQueueSupplier = mainQueueSupplier;
            this.prefetch = prefetch;
            this.innerQueueSupplier = innerQueueSupplier;
            this.limit = Operators.unboundedOrLimit(maxConcurrency);
        }
    }
}
//------------------- FluxFilter ----------------------------------------
final class FluxFilter<T> extends InternalFluxOperator<T, T> {
    public CoreSubscriber<? super T> subscribeOrReturn(CoreSubscriber<? super T> actual) {
        return (CoreSubscriber)(actual instanceof ConditionalSubscriber ? 
                new FluxFilter.FilterConditionalSubscriber((ConditionalSubscriber)actual, this.predicate) : 
                new FluxFilter.FilterSubscriber(actual, this.predicate));
    }
    //内部类
    static final class FilterConditionalSubscriber<T>
            implements InnerOperator<T, T>,Fuseable.ConditionalSubscriber<T> {

        FilterConditionalSubscriber(Fuseable.ConditionalSubscriber<? super T> actual,
                                    Predicate<? super T> predicate) {
            this.actual = actual;
            this.ctx = actual.currentContext();
            this.predicate = predicate;
        }
    }
    //内部类
    static final class FilterSubscriber<T>
            implements InnerOperator<T, T>,Fuseable.ConditionalSubscriber<T> {
        FilterSubscriber(CoreSubscriber<? super T> actual, Predicate<? super T> predicate) {
            this.actual = actual;
            this.ctx = actual.currentContext();
            this.predicate = predicate;
        }
    }
}
//------------------- FluxMapFuseable ----------------------------------------
final class FluxMapFuseable<T, R> extends InternalFluxOperator<T, R> implements Fuseable {

    public CoreSubscriber<? super T> subscribeOrReturn(CoreSubscriber<? super R> actual) {
        if (actual instanceof ConditionalSubscriber) {
            ConditionalSubscriber<? super R> cs = (ConditionalSubscriber)actual;
            return new FluxMapFuseable.MapFuseableConditionalSubscriber(cs, this.mapper);
        } else {
            return new FluxMapFuseable.MapFuseableSubscriber(actual, this.mapper);
        }
    }
    static final class MapFuseableConditionalSubscriber<T, R>
            implements ConditionalSubscriber<T>, InnerOperator<T, R>,QueueSubscription<R> {

        MapFuseableConditionalSubscriber(ConditionalSubscriber<? super R> actual,
                                         Function<? super T, ? extends R> mapper) {
            this.actual = actual;
            this.mapper = mapper;
        }
    }
    static final class MapFuseableSubscriber<T, R>
            implements InnerOperator<T, R>,QueueSubscription<R> {

        MapFuseableSubscriber(CoreSubscriber<? super R> actual,
                              Function<? super T, ? extends R> mapper) {
            this.actual = actual;
            this.mapper = mapper;
        }
        
    }
    
}

从上面的代码可以看出 ：
1.操作类的内部类 实现了 Subscription, Subscriber 接口，

表明 内部类 可以是一个 Subscriber，也可以是一个 Subscription 。

2.操作类 subscribeOrReturn() 主要作用

创建 内部类对象，初始化属性（actual，mapper/predicate） ，然后返回 。

这些内部类的构造 有三个 重要的属性 ：

actual ： 一个 Subscriber 引用
mapper/predicate ：当前 Flux 类的 flux源引用
s : 一个 Subscriber 引用 (这里没有用到)

前两个可以在构造里初始化了

• 再来 看一下 LambdaSubscriber 构造

// LambdaSubscriber 构造
LambdaSubscriber(@Nullable Consumer<? super T> consumer,
        @Nullable Consumer<? super Throwable> errorConsumer,
        @Nullable Runnable completeConsumer,
        @Nullable Consumer<? super Subscription> subscriptionConsumer,
        @Nullable Context initialContext) {
    this.consumer = consumer;
    this.errorConsumer = errorConsumer;
    this.completeConsumer = completeConsumer;
    this.subscriptionConsumer = subscriptionConsumer;
    this.initialContext = initialContext == null ? Context.empty() : initialContext;
}

分析订阅过程

调用主体是 最后一个操作对象实例 : 本例中就是 FluxBuffer 实例 记作 fluxBuffer

// Flux 方法
public final Disposable subscribe(Consumer<? super T> consumer) { //调用者是 FluxBuffer
    Objects.requireNonNull(consumer, "consumer");
    return this.subscribe(consumer, (Consumer)null, (Runnable)null);
}
// Flux 方法
public final Disposable subscribe(@Nullable Consumer<? super T> consumer, @Nullable Consumer<? super Throwable> errorConsumer, @Nullable Runnable completeConsumer) {
    return this.subscribe(consumer, errorConsumer, completeConsumer, (Context)null);
}
// Flux 方法
public final Disposable subscribe(@Nullable Consumer<? super T> consumer, 
        @Nullable Consumer<? super Throwable> errorConsumer, 
        @Nullable Runnable completeConsumer, 
        @Nullable Context initialContext) {
    return (Disposable)this.subscribeWith(
            new LambdaSubscriber(consumer, errorConsumer, completeConsumer, (Consumer)null, initialContext)
        );
}
// Flux 方法 
// 方法参数 subscriber ： 上一步中创建的 LambdaSubscriber 实例 
public final <E extends Subscriber<? super T>> E subscribeWith(E subscriber) {
    // 这里是重点
    // 这里是重点
    // 这里是重点
    this.subscribe(subscriber); // 下面分析
    return subscriber; // 返回了 Disposable 接口实例( LambdaSubscriber )，可用于取消订阅
}
// Flux 方法
// 方法参数 actual ： 就是我们 创建的 LambdaSubscriber 实例 
public final void subscribe(Subscriber<? super T> actual) {
    // onLastAssembly():  对钩子函数的处理 , 把 调用者 包装成 CorePublisher 并返回，本质上返回的还是 调用者
    // this : 调用者 ，就是最后一个 Flux类对象 fluxBuffer
    CorePublisher publisher = Operators.onLastAssembly(this);
    // toCoreSubscriber(): 把 actual 包装成 CoreSubscriber 并返回，本质上返回的还是 actual
    CoreSubscriber subscriber = Operators.toCoreSubscriber(actual);

    try {
        // 进入循环体的前提条件 ：必须是操作类（就是 创建资源类后，必须有操作符出现 ），否者无法进入循环体
        if (publisher instanceof OptimizableOperator) {
            OptimizableOperator operator = (OptimizableOperator)publisher;
            // 一个循环体
            while(true) {
                /*                                  
                    subscribeOrReturn(subscriber): 生成 调用者的 内部类对象 并 返回， 同时把 Subscriber 和 调用者的 Flux 源引用 传递给该内部类实例。
                    
                    这个循环体，每发生一次循环，subscriber 就变化一次。              
                    第一次经过此步骤后 : subscriber 变成了 最后一个操作类的 内部类对象，而且包含了原始的 Subscriber实例（就是LambdaSubscriber 实例 ）
                    第二次经过此步骤后 : subscriber 变成了 倒数第二个操作类的 内部类对象，而且包含了上一步返回的 Subscriber实例（就是 最后一个操作类的 内部类对象 ）
                    ..... ，直到第一个操作类为止。
                 */
                subscriber = operator.subscribeOrReturn(subscriber); // 
                if (subscriber == null) {
                    return;
                }
                /*  获取 optimizableOperator 属性值 ：                
                    先来回想下 OptimizableOperator 的 optimizableOperator 属性是如何初始化的？    
                    optimizableOperator 属性是在 OptimizableOperator 构造中初始化的，
                    且 optimizableOperator 属性值是 上一个 操作者实例引用( 可以理解为 Flux实例引用 )                       
                 */
                OptimizableOperator newSource = operator.nextOptimizableSource();
                /*
                    newSource == null 即 optimizableOperator = null
                    optimizableOperator = null 的条件 ：是第一个操作对象，因为 资源类 不属于 OptimizableOperator。   
                 */
                if (newSource == null) { // 跳出循环的条件
                    // 能执行到这里说明 ： operator 是第一个操作对象，那它的 source 属性值 就是 序列流资源类对象。
                    // 即 publisher 就是 序列流资源类。
                    publisher = operator.source();
                    break;
                }
                /* 这里是循环能够继续执行原因
                    每一次都从当前操作对象里取出 optimizableOperator 属性值，并赋值给 operator
                 */
                operator = newSource; 
            }
        }
        // 这里的 publisher 已经是 序列流的资源类了，subscriber 已经变成 第一个操作类 的 内部类对象 
        publisher.subscribe(subscriber);
    
    } catch (Throwable var6) {
        Operators.reportThrowInSubscribe(subscriber, var6);
    }
}

从上面可知，订阅过程就是：
创建了一个 Subscriber 实例（这里就是 LambdaSubscriber 实例）；
然后，用最后一个操作对象 去订阅 Subscriber 实例；
最后，把 Subscriber 实例（这里就是 LambdaSubscriber 实例）返回，可用于取消订阅。

不过在返回 Subscriber 实例 之前，执行了 Flux 的 final void subscribe(Subscriber<? super T> actual) 方法：
此方法主要功能 就是形成 Subscribe 正向单向链表，（不过是从后往前 赋值的）
Subscribe 实现类 就是这个链表的 node 节点类 ， 关联属性是 actual （ 这个属性是 向后指向 ）,

第一个操作类的 内部类对象 包含 第二个操作类的 内部类对象，
第二个操作类的 内部类对象 包含 第三个操作类的 内部类对象，
…
最后一个操作类的 内部类对象 包含 我们创建的 订阅者 （就是 LambdaSubscriber ）。
并且 Subscribe 实例 保存了 当前操作类( 就是外部类 )的 Flux源引用（相关属性 ：mapper/predicate ）

// FluxArray 的方法 ，参数是 第一个操作类的 内部类对象
public void subscribe(CoreSubscriber<? super T> actual) {
    // array : flux 源引用
    subscribe(actual, array);
}
// FluxArray 的方法 ，1.生产 FluxArray 内部类对象;2.执行 第一个操作类的 内部类对象的 onSubscribe() 方法
public static <T> void subscribe(CoreSubscriber<? super T> s, T[] array) {
    if (array.length == 0) {
        Operators.complete(s);
        return;
    }
    if (s instanceof ConditionalSubscriber) {
        // onSubscribe() :是 CoreSubscriber 接口的方法
        s.onSubscribe(new ArrayConditionalSubscription<>((ConditionalSubscriber<? super T>) s, array));
    } else {
        s.onSubscribe(new ArraySubscription<>(s, array));
    }
}
// FluxArray 内部类
static final class ArrayConditionalSubscription<T>
        implements InnerProducer<T>, SynchronousSubscription<T> {
    ArrayConditionalSubscription(ConditionalSubscriber<? super T> actual, T[] array) {
        this.actual = actual;
        this.array = array;
    }
    
}
// FluxArray 内部类
static final class ArraySubscription<T>
        implements InnerProducer<T>, SynchronousSubscription<T> {
    ArraySubscription(CoreSubscriber<? super T> actual, T[] array) {
        this.actual = actual;
        this.array = array;
    }
    
}

从上面的代码可以看出 ：
1.资源类的内部类 主要实现了 Subscription 接口

表明 内部类 可以维护发布订阅关系 。

2.资源类 subscribe()方法 主要作用

创建 内部类对象，初始化属性（actual，array[资源引用]） ，然后返回 。

3.资源类的内部类 与 操作类的内部类 极为相似

都包含了一个 Subscriber actual 属性 ；
都包含了 一个 flux 源引用字段（ 资源类是array，操作类是 mapper/predicate）

最终形成一个完整的 Subscriber 正向单向链表（除资源类的内部类不是 Subscriber 类型以外，其他全是）
资源类的 内部类对象的 actual属性 指向 第一个操作类的 内部类对象，
第一个操作类的 actual属性 指向 第二个操作类的 内部类对象，
第二个操作类的 actual属性 指向 第三个操作类的 内部类对象，
…
最后一个操作类的 actual属性 指向 我们创建的 订阅者 （就是 LambdaSubscriber ）。

发现关于几个 Flux 实现类通用点 ：

资源类的内部类 实现了 Subscription 接口 ，操作类的内部类 实现了 Subscription，Subscriber 接口；

操作类 创建内部类的方法是 操作类的 subscribeOrReturn(),而资源类 创建内部类的方法是 资源类的 subscribe()

到此 Subscriber 正向单向链表完成 ，
接下来将执行 FluxArray.subscribe()方法的最后一步 ： s.onSubscribe( ArraySubscription )
从上面的代码可以看出，s 就是 第一个操作类的 内部类对象 ，而参数是 Subscriber 正向单向链表 的头部对象( 就是资源类的内部类 )。

//Operators 的 validate() 方法
public static boolean validate(@Nullable Subscription current, Subscription next) {
    Objects.requireNonNull(next, "Subscription cannot be null");
    if (current != null) {
        next.cancel();
        return false;
    } else {
        return true;
    }
}

// FluxFilter 内部类的 onSubscribe() 方法
public void onSubscribe(Subscription s) {
    if (Operators.validate(this.s, s)) {
        this.s = s;
        this.actual.onSubscribe(this);
    }
}
// FluxMapFuseable 内部类的 onSubscribe() 方法
public void onSubscribe(Subscription s) {
    if (Operators.validate(this.s, s)) {
        this.s = (QueueSubscription)s;
        this.actual.onSubscribe(this);
    }
}
// FluxFlatMap 内部类的 onSubscribe() 方法
public void onSubscribe(Subscription s) {
    if (Operators.validate(this.s, s)) {
        this.s = s;
        this.actual.onSubscribe(this);
        s.request(Operators.unboundedOrPrefetch(this.maxConcurrency));
    }
}

// FluxBuffer 内部类的 onSubscribe() 方法
public void onSubscribe(Subscription s) {
    if (Operators.validate(this.s, s)) {
        this.s = s;
        this.actual.onSubscribe(this);
    }
}

// LambdaSubscriber 的 onSubscribe() 方法 
public final void onSubscribe(Subscription s) {
    // 属性 subscription 可以看成是 操作类的内部类中的 属性 s
    if (Operators.validate(this.subscription, s)) {
        this.subscription = s;
        if (this.subscriptionConsumer != null) { // 到目前为止 没有给属性 subscriptionConsumer 赋值
            try {
                this.subscriptionConsumer.accept(s);
            } catch (Throwable var3) {
                Exceptions.throwIfFatal(var3);
                s.cancel();
            this.onError(var3);
            }
        } else {
            // 最终执行这一步，s 是最后一个操作类的内部类
            s.request(9223372036854775807L);
        }
    }
}

onSubscribe() 方法的 调用者 与 参数 的关系 ：

它们同属 Subscriber 正向单向链表 ， 参数 是 调用者 的前置节点。

onSubscribe()方法的主要操作是 : 1> 给调用者 s 属性赋值 ，2> 然后调用 actual属性的 onSubscribe()

回想下，从头到现在，我们并没有给 s 属性赋值，所以 s ==null ， 接下来给 s 赋值( 第一次赋值 )，执行 this.actual.onSubscribe(this)

再回想下，actual 属性 有没有赋值，或者说 已经赋了什么值。
actual 属性 已经在创建时通过构造赋值了，而且赋的值是： 下一个 操作类的内部类对象。

onSubscribe() 执行流程：

第一个操作类的 内部类 执行 onSubscribe( Subscription s ) ,而传递的参数是 资源类的 内部类，
第二个操作类的 内部类 执行 onSubscribe( Subscription s ) ,而传递的参数是 第一个操作类的的 内部类，
…
最后一个操作类的 内部类 执行 onSubscribe( Subscription s ), 而传递的参数是 倒数第二个操作类的的 内部类，
我们创建的订阅者(LambdaSubscriber 实例) 执行 onSubscribe( Subscription s ), 而传递的参数是 最后一个操作类的的 内部类。

并且 依次给每一个对象的 属性 s 赋值了。

到现在为止，操作类的内部类的三个重要属性都有值了：

actual ： 指向 调用链 下一个对象的内部类引用
mapper/predicate ：当前 Flux 类的 flux源引用
s : 指向 调用链 上一个对象的内部类引用

综上看出 ： 操作类的内部类 实现了一个 双向链表结构，
属性 s 指向 前一个节点 ，属性 actual 指向 下一个节点，
头节点 是 资源类，尾节点 是 我们创建的订阅者（ LambdaSubscriber 实例 ）

接下来 就是执行 LambdaSubscriber 的 onSubscribe() 方法中的 s.request(9223372036854775807L)
s 就是 最后一个操作类的 内部类对象

// Operators 的 validate() 方法
public static boolean validate(long n) {
    if (n <= 0L) {
        reportBadRequest(n);
        return false;
    } else {
        return true;
    }
}
// FluxBuffer 内部类 的 request() 方法
public void request(long n) {
    if (Operators.validate(n)) {
        this.s.request(Operators.multiplyCap(n, (long)this.size));
    }
}

// FluxBuffer 内部类 的 request() 方法



// FluxBuffer 内部类 的 request() 方法


// FluxBuffer 内部类 的 request() 方法


// FluxBuffer 内部类 的 request() 方法

内部类的 request() 方法 基本一致，依次调用this.s.request(), 最终会到达 资源类的 request() 方法 中，

然后资源类内部类 再调用 第一个操作类内部类的 onNext(),
然后 第一个操作类的内部类 再调用 第二个操作类的onNext() 方法
…
直到我们创建的订阅者的 onNext() 方法 截至 ，整个流程就结束了。

这个过程的大致流程

Flux 反向单向链表的作用 ： 原始保存信息 ，从前往后
Subscriber 双向链表的作用 ： 就是形成完整链路 。

流程

Flux 反向单向链表，依次保存上一个Flux对象，形成一个链表（source 属性），从前往后
通过 subscribeOrReturn()方法 完成 Subscriber双向链表 的后置节点的连接，（ 后置节点的引用 actual ） ，从后往前
通过 Subscriber 的 onSubscribe()方法 完成 Subscriber双向链表的 前置节点的连接，（ 前置节点的引用 s ） ，从前往后
通过 依次调用 Subscriber 的 request()方法 ，完成背压 ，从后往前
通过 依次调用 onNext()方法 ，完成操作 ，从前往后