Java 组合多个单声道<；列表<；项目>&燃气轮机；合二为一_Java_Reactive Programming_Project Reactor

Java 组合多个单声道<；列表<；项目>&燃气轮机；合二为一

java

Java 组合多个单声道<；列表<；项目>&燃气轮机；合二为一,java,reactive-programming,project-reactor,Java,Reactive Programming,Project Reactor,我目前正在做一个项目，涉及一些反应式编程我有4个不同的反应性存储库，从中我分别得到4个不同的Mono。目标是将它们组合成单个Mono，以便将其合并到自定义响应中，以在ResponseEntity.ok（）中返回。我已经注意到创建了一个GeneralType，并且成功地转换了一个Mono，但是没有取得进一步的进展所有存储库都有类似的签名： public Mono<List<SomeType>> findAllByUserId(UUID userId) 但是有了它，I

我目前正在做一个项目，涉及一些反应式编程

我有4个不同的反应性存储库，从中我分别得到4个不同的

Mono

。目标是将它们组合成单个
Mono
，以便将其合并到自定义响应中，以在

ResponseEntity.ok（）中返回。我已经注意到创建了一个GeneralType
，并且成功地转换了一个Mono
，但是没有取得进一步的进展
所有存储库都有类似的签名：
public Mono<List<SomeType>> findAllByUserId(UUID userId)

但是有了它，IDE就迫切需要将返回类型更改为Flux。
另外，有些列表可能是空的，所以我不确定这里是否有zip（）
选项。我已经读到，如果至少有一个结果为空，它将返回所有内容
因此，问题是如何以有效的方式实现这一点而无需到处使用block（）？合并急切地连接到所有数据源。因此，当数据从任何来源发出时，它将被传递到下游管道。结果列表中的顺序基于项目发出的时间
Zip方法从源收集数据，并将它们放在对象（元组–类似于方框的东西）中，然后传递到下游。只要所有源都发出数据，Zip就可以工作。任何源完成/抛出错误，它将停止

我认为你的个人方法很有效。您的问题与将结果合并到单个列表有关
private Mono<List<String>> getList1(){
    return Mono.just(List.of("a", "b", "c"));
}

private Mono<List<String>> getList2(){
    return Mono.just(Collections.emptyList());
}

private Mono<List<String>> getList3(){
    return Mono.just(List.of("A", "B", "C"));
}


    Flux.merge(getList1(), getList2(), getList3())
            .flatMapIterable(Function.identity())
            .collectList()
            .subscribe(System.out::println);  // [a, b, c, A, B, C]

private Mono getList1（）{
返回Mono.just（列表中的“a”、“b”、“c”）；
}
私有Mono getList2（）{
返回Mono.just（Collections.emptyList（））；
}
私有Mono getList3（）{
返回Mono.just（列表中的“A”、“B”、“C”）；
}
Flux.merge（getList1（），getList2（），getList3（））
.flatMapIterable（函数.identity（））
.LIST（）
.subscribe（System.out:：println）；//[a，b，c，a，b，c]


参考：
合并急切地连接到所有数据源。因此，当数据从任何来源发出时，它将被传递到下游管道。结果列表中的顺序基于项目发出的时间
Zip方法从源收集数据，并将它们放在对象（元组–类似于方框的东西）中，然后传递到下游。只要所有源都发出数据，Zip就可以工作。任何源完成/抛出错误，它将停止

我认为你的个人方法很有效。您的问题与将结果合并到单个列表有关
private Mono<List<String>> getList1(){
    return Mono.just(List.of("a", "b", "c"));
}

private Mono<List<String>> getList2(){
    return Mono.just(Collections.emptyList());
}

private Mono<List<String>> getList3(){
    return Mono.just(List.of("A", "B", "C"));
}


    Flux.merge(getList1(), getList2(), getList3())
            .flatMapIterable(Function.identity())
            .collectList()
            .subscribe(System.out::println);  // [a, b, c, A, B, C]

private Mono getList1（）{
返回Mono.just（列表中的“a”、“b”、“c”）；
}
私有Mono getList2（）{
返回Mono.just（Collections.emptyList（））；
}
私有Mono getList3（）{
返回Mono.just（列表中的“A”、“B”、“C”）；
}
Flux.merge（getList1（），getList2（），getList3（））
.flatMapIterable（函数.identity（））
.LIST（）
.subscribe（System.out:：println）；//[a，b，c，a，b，c]


参考：
AMono:：zip
将异步地将三家出版商组合在一起，我认为这是最好的解决方案
否则，这是一个非常简单的问题：
Mono<List<String>> m1 = Mono.just(Arrays.asList(new String[]{"A", "B", "C"}));
Mono<List<Character>> m2 = Mono.just(Arrays.asList(new Character[]{'a', 'b', 'c'}));
Mono<List<Integer>> m3 = Mono.just(Arrays.asList(new Integer[]{1, 2, 3}));
Mono.zip(m1, m2, m3)
        .map(tuple3->{
                List<Combined> c = new ArrayList<>();
                int size = tuple3.getT1().size();
                for ( int i=0; i < size; ++i ) {
                    c.add(new Combined(tuple3.getT1().get(i), tuple3.getT2().get(i), tuple3.getT3().get(i)));
                }
                return c;
        })
        .subscribe(System.out::println);
// [Combined(s=A, c=a, i=1), Combined(s=B, c=b, i=2), Combined(s=C, c=c, i=3)]

一个Mono:：zip
将异步地将三个发布服务器组合在一起，我认为这是最好的解决方案
否则，这是一个非常简单的问题：
Mono<List<String>> m1 = Mono.just(Arrays.asList(new String[]{"A", "B", "C"}));
Mono<List<Character>> m2 = Mono.just(Arrays.asList(new Character[]{'a', 'b', 'c'}));
Mono<List<Integer>> m3 = Mono.just(Arrays.asList(new Integer[]{1, 2, 3}));
Mono.zip(m1, m2, m3)
        .map(tuple3->{
                List<Combined> c = new ArrayList<>();
                int size = tuple3.getT1().size();
                for ( int i=0; i < size; ++i ) {
                    c.add(new Combined(tuple3.getT1().get(i), tuple3.getT2().get(i), tuple3.getT3().get(i)));
                }
                return c;
        })
        .subscribe(System.out::println);
// [Combined(s=A, c=a, i=1), Combined(s=B, c=b, i=2), Combined(s=C, c=c, i=3)]

空单声道与空列表单声道不同。如果mono的值为空list，它可以继续zip
。但是如果mono的值为空，它就不能继续zip
。您可以尝试使用zip（）！我有一种感觉，我在某个地方误解了什么……空单声道和空单声道是不同的。如果mono的值为空list，它可以继续zip
。但是如果mono的值为空，它就不能继续zip
。您可以尝试使用zip（）！我有一种感觉，我在某个地方误解了什么…谢谢你的解释和一个例子！我现在明白了Mono:：zip
将合并它们，但示例没有明确说明如何将现有的Mono
合并为一个。感谢您的解释和示例！我现在知道Mono:：zip
会将它们组合在一起，但是这个例子并没有明确告诉我如何将现有的Mono
组合成一个。非常感谢！真的很感激！不幸的是，我只能在明天测试它，然而，我有一种强烈的感觉，这会起作用：）顺便说一句，我在发布问题之前已经打开了你的网站。谢谢你的信息也有-真的很有帮助@塞弗曼，我想我误解了你的问题。合并并压缩两个完全不同的用例。合并是将两个列表合并为一个列表。Zip生成一对对象。我以为你想合并这些回复。同时检查另一个答案。如果你认为你需要zip，请接受这个答案。我确实需要合并回复。问题是我有4种不同的Mono
，我需要将它们组合成一个Mono来返回。非常感谢！真的很感激！不幸的是，我只能在明天测试它，然而，我有一种强烈的感觉，这会起作用：）顺便说一句，我在发布问题之前已经打开了你的网站。谢谢你的信息也有-真的很有帮助@塞弗曼，我想我误解了你的问题。合并并压缩两个完全不同的用例。合并是将两个列表合并为一个列表。Zip产生一对obje
Mono<List<String>> m1 = Mono.just(Arrays.asList(new String[]{"A", "B", "C"}));
Mono<List<Character>> m2 = Mono.just(Arrays.asList(new Character[]{'a', 'b', 'c'}));
Mono<List<Integer>> m3 = Mono.just(Arrays.asList(new Integer[]{1, 2, 3}));
Mono.zip(m1, m2, m3)
        .map(tuple3->{
                List<Combined> c = new ArrayList<>();
                int size = tuple3.getT1().size();
                for ( int i=0; i < size; ++i ) {
                    c.add(new Combined(tuple3.getT1().get(i), tuple3.getT2().get(i), tuple3.getT3().get(i)));
                }
                return c;
        })
        .subscribe(System.out::println);
// [Combined(s=A, c=a, i=1), Combined(s=B, c=b, i=2), Combined(s=C, c=c, i=3)]

@Data
@AllArgsConstructor
class Combined {
    String s;
    Character c;
    Integer i;
}