concatMap VS flatMap

今天看WebFlux源码时看到DispatcherHandler了，发现处理请求时寻找匹配的handler使用的时concatMap，于是好奇的开始研究起它于flatMap的区别。

@Override
public Mono<Void> handle(ServerWebExchange exchange) {
   if (this.handlerMappings == null) {
      return createNotFoundError();
   }
   return Flux.fromIterable(this.handlerMappings)
         .concatMap(mapping -> mapping.getHandler(exchange))
         .next()
         .switchIfEmpty(createNotFoundError())
         .flatMap(handler -> invokeHandler(exchange, handler))
         .flatMap(result -> handleResult(exchange, result));
}

concatMap类似for循环一样遍历处理元素，一个元素处理慢了，后面元素就得等着前面处理完，而flatMap则是并行处理，返回的元素是无序的，谁先处理完谁排放出去。

package com.akulaku.asetloan.cashloan;

import org.junit.Test;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.time.Duration;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;

public class ConcatMapVsFlatMap {

    @Test
    public void testConcatMap() throws InterruptedException {
        List<Integer> data = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Long start1 = System.currentTimeMillis();
        Flux.fromIterable(data).flatMap(i -> {
            int delay = 0;
            if (i == 5) {
                delay = 2000;
            }
            return Mono.just(i * 10).delayElement(Duration.ofMillis(delay));
        }).doOnSubscribe(subscription -> {
            System.out.println("开始flatMap");
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.print(integer + "  ");
                System.out.println((System.currentTimeMillis() - start1) + "ms");
            }
        });
        TimeUnit.SECONDS.sleep(5);
        System.out.println("======================");
        Long start2 = System.currentTimeMillis();
        Flux.fromIterable(data).concatMap(i -> {
            int delay = 0;
            if (i == 5) {
                delay = 2000;
            }
            return Mono.just(i * 10).delayElement(Duration.ofMillis(delay));
        }).doOnSubscribe(subscription -> {
            System.out.println("开始concatMap");
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.print(integer + "  ");
                System.out.println((System.currentTimeMillis() - start2) + "ms");
            }
        });
        TimeUnit.SECONDS.sleep(5);
    }
}

 运行后的输出：

开始flatMap
10  1032ms
20  1032ms
30  1032ms
40  1032ms
60  1032ms
70  1032ms
80  1033ms
90  1033ms
100  1033ms
50  3035ms
======================
开始concatMap
10  6ms
20  6ms
30  6ms
40  7ms
50  2007ms
60  2007ms
70  2007ms
80  2007ms
90  2007ms
100  2007ms