reactor订阅消费顺序

@Test
public void test() {
    // 构造订阅嵌套关系
    Mono.just("a") //    
            .map(s->"map-" + s)
            .subscribe(System.out::println);

}


/**
 * 构建从上往下的订阅链路
 * 1. source从下往上遍历执行subscribeOrReturn, 并找到数据源头发布者,即MonoJust
 * 2. actual指向向下的Subscriber,以实现数据从上往下传递
 */
public final void subscribe(Subscriber<? super T> actual) {
   CorePublisher publisher = Operators.onLastAssembly(this);
   CoreSubscriber subscriber = Operators.toCoreSubscriber(actual);

   try {
      if (publisher instanceof OptimizableOperator) {
         OptimizableOperator operator = (OptimizableOperator) publisher;
         while (true) {
            // subscribeOrReturn(subscriber[往下的订阅者]), 末尾的订阅者: LambdaMonoSubscriber
            // MonoMapFuseable.subscribeOrReturn: return new FluxMapFuseable.MapFuseableSubscriber<>(actual, mapper)
            // MapFuseableSubscriber集成3种身份: 发布者、消费者、发布对象，其中集成发布者和消费的对象为操作者，以实现向上接收数据， 向下传送数据
            //      actual == LambdaMonoSubscriber, mapper == Function(System.out::println)
            subscriber = operator.subscribeOrReturn(subscriber); // 当发布者记录往下的订阅者
            if (subscriber == null) {
               // null means "I will subscribe myself", returning...
               return;
            }

            // 找到往上的发布者
            OptimizableOperator newSource = operator.nextOptimizableSource();
            if (newSource == null) {
               publisher = operator.source();
               break;
            }
            operator = newSource;
         }
      }

      publisher.subscribe(subscriber); // publisher == MonoJust, subscriber == MapFuseableSubscriber
   }
   catch (Throwable e) {
      Operators.reportThrowInSubscribe(subscriber, e);
      return;
   }
}

MonoJust.subscribe(subscriber)	
==> actual.onSubscribe(Operators.scalarSubscription(actual, value)); # 1 启动 onSubscribe
// MapFuseableSubscriber.onSubscribe, actual == MapFuseableSubscriber, value == a 

MapFuseableSubscriber.onSubscribe
==> actual.onSubscribe(this);
// LambdaMonoSubscriber.onSubscribe(MapFuseableSubscriber)

==> LambdaMonoSubscriber.onSubscribe
==> s.request(Long.MAX_VALUE); # 启动 request
// MapFuseableSubscriber.request(Long.MAX_VALUE);

==> MapFuseableSubscriber.request
==> s.request(n);
// Operators.scalarSubscription(actual, value).request(n); # 1

==> Operators.scalarSubscription(actual, value).request # 启动 next
==> a.onNext(value);
// MapFuseableSubscriber.onNext(value);

==> MapFuseableSubscriber.onNext(value); // value==a
==> mapper.apply(t)
// lambda.apply(value) // s -> "map-" + s
==> actual.onNext(v); // v==map-a
// LambdaMonoSubscriber.onNext(v)

==> LambdaMonoSubscriber.onNext(v)
==> consumer.accept(x);
// System.out::println

==> Operators.scalarSubscription(actual, value).request
==> a.onComplete(); # 启动 onComplete
==>MapFuseableSubscriber.onComplete()
==>LambdaMonoSubscriber.onComplete()


总结: 
1、onSubscribe从上往下执行，到正真订阅者后启动request
2、request从下往上执行，到数据源后启动onNext
3、onNext从上往下执行，途中经过数据转换
4、onComplete从上往下执行