Reactive stream Programming 踩坑记录（zip）

前提介绍吧：
用的全是异步非阻塞的操作符，框架选用的是Akka和R2DBC
最外层流是Akka stream，内部和DB交互用的是Project Reactor
先看代码：

    @Test
    void name() throws ExecutionException, InterruptedException {
        final List<Integer> lists = Source.single(1)
                                          .map(any -> Arrays.asList(1, 2, 3))
                                          .flatMapConcat(Source::from)
                                          .grouped(2)
                                          .zip(Source.single(4))
                                          .map(pair -> {
                                                    log.info("map-pair.first:{}", pair.first());
                                                    log.info("map-pair.second:{}", pair.second());
                                                    return pair.first();
                                                })
                                          .withAttributes(ActorAttributes.withSupervisionStrategy(e -> {
                                                    log.info("withAttributes:{}", e.getMessage());
                                                    return Supervision.resume();
                                                })).runWith(Sink.head(), actorSystem)
                                          .toCompletableFuture().get();
        Assertions.assertEquals(2, lists.size());

    }

从测试结果看只有两个数据，然后从log我们也发现map只被执行了一次。

解释一下流吧：

然后就是zip。
干掉zip

    @Test
    void name() throws ExecutionException, InterruptedException {
        final List<List<Integer>> lists = Source.single(1)
                                                .map(any -> Arrays.asList(1, 2, 3))
                                                .flatMapConcat(Source::from)
                                                .grouped(2)
//                                                .zip(Source.single(4))
                                                .map(item -> {
                                                    log.info("map：{}", item);
//                                                    log.info("map-pair.second:{}", pair.second());
                                                    return item;
//                                                    return pair.first();
                                                })
                                                .withAttributes(ActorAttributes.withSupervisionStrategy(e -> {
                                                    log.info("withAttributes:{}", e.getMessage());
                                                    return Supervision.resume();
                                                })).runWith(Sink.seq(), actorSystem)
                                                .toCompletableFuture().get();
        assertThat(lists).containsExactly(Arrays.asList(1, 2), Arrays.asList(3));
    }

看下效果

是不是很神奇。
有两种解决方案

在zip之前将流中数据全都收集起来，也就是将group 换成普通函数式编程的reduce， akka中叫 Fold

   @Test
    void name() throws ExecutionException, InterruptedException {
        final List<List<Integer>> lists = Source.single(1)
                                                .map(any -> Arrays.asList(1, 2, 3))
                                                .flatMapConcat(Source::from)
                                                .fold(Collections.<Integer>emptyList(), (array, item) ->{
                                                    List<Integer> list = new ArrayList<>(array);
                                                    list.add(item);
                                                    return Collections.unmodifiableList(list);
                                                })
                                                .zip(Source.single(4))
                                                .map(pair -> {
                                                    log.info("map-pair.first：{}", pair.first());
                                                    log.info("map-pair.second:{}", pair.second());
                                                    return pair.first();
                                                })
                                                .withAttributes(ActorAttributes.withSupervisionStrategy(e -> {
                                                    log.info("withAttributes:{}", e.getMessage());
                                                    return Supervision.resume();
                                                })).runWith(Sink.seq(), actorSystem)
                                                .toCompletableFuture().get();
        assertThat(lists).containsExactly(Arrays.asList(1,2,3));
    }

方法二：不用zip 换成mapAsync

   @Test
    void name() throws ExecutionException, InterruptedException {
        final List<List<Integer>> lists = Source.single(1)
                                                .map(any -> Arrays.asList(1, 2, 3))
                                                .flatMapConcat(Source::from)
                                                .grouped(2)
                                                .mapAsyncUnordered(1, list -> Mono.just(4).map(s -> Pair.create(list,s)).toFuture())
                                                .map(pair -> {
                                                    log.info("map-pair.first：{}", pair.first());
                                                    log.info("map-pair.second:{}", pair.second());
                                                    return pair.first();
                                                })
                                                .withAttributes(ActorAttributes.withSupervisionStrategy(e -> {
                                                    log.info("withAttributes:{}", e.getMessage());
                                                    return Supervision.resume();
                                                })).runWith(Sink.seq(), actorSystem)
                                                .toCompletableFuture().get();
        assertThat(lists).containsExactly(Arrays.asList(1,2), Arrays.asList(3));
    }
}

运行结果

为什么会这样：
看下官网怎么说

Combines elements from each of multiple sources into Pair and passes the pairs downstream.
官网demo

import akka.stream.javadsl.Source;
import akka.stream.javadsl.Sink;
import java.util.Arrays;

Source<String, NotUsed> sourceFruits = Source.from(Arrays.asList("apple", "orange", "banana"));
Source<String, NotUsed> sourceFirstLetters = Source.from(Arrays.asList("A", "O", "B"));
sourceFruits.zip(sourceFirstLetters).runWith(Sink.foreach(System.out::print), system);
// this will print ('apple', 'A'), ('orange', 'O'), ('banana', 'B')

是不是很鸡贼：两个流中的元素数量是一致的，不一致会导致流会丢东西，以少的元素的流为基准，去生成pair。
当流中数据元素不匹配的时候非要用zip 请使用zipAll方法，他会有个default参数，当流中数据元素不匹配的时候，会以多的为准，然后用default的值去构建pair

个人建议：zip能不用就不用，如果非要用请用zipAll

Reactive stream Programming 踩坑记录（zip）

猜你喜欢