Question

我从反应式存储库中得到一个基于其值的Mono<FooBar>，我必须创建另外两个对象，使用反应式存储库保存它们，修改FooBar对象并保存它。

由于我是反应式编程的新手，所以我找到了下面的解决方案，它可以正常工作，但是我不确定我是否正确使用了反应式API：

@Test
void createAndSave() {
    Mono<FooBar> fooBarMono = findFooBar()  // returns Mono<FooBar>
            .map(fooBar -> {
        createAndSaveLoremBar(fooBar).subscribe();   // returns Mono<LoremBar>
        createAndSaveDoloremBar(fooBar).subscribe(); // returns Mono<DoloremBar>

        fooBar.setActive(true);

        return saveFooBar(fooBar);          // returns Mono<FooBar>
    }).flatMap(Function.identity());

    StepVerifier.create(fooBarMono)
            .expectNextMatches(Objects::nonNull)
            .expectComplete()
            .verify();

}

从控制台日志中：

   saved lorem bar
   saved dolorem bar
   saved foo bar

Answer 1

首先，在异步（反应性）世界中对对象进行更改不是一个好主意。

无论如何，在您的解决方案中，忽略关于lorem和dolorem保存的可能错误。您可以像这样改善它：

Mono<FooBar> fooBarMono = findFooBar()
        .flatMap(fooBar -> Flux.merge(
                createAndSaveLoremBar(fooBar),
                createAndSaveDoloremBar(fooBar)) // asynchronously saving lorem and dolorem
                .then(Mono.fromCallable(() -> {  // if there wasn't errors, mutate and save fooBar
                    fooBar.setActive(true);
                    return fooBar;
                }).flatMap(fooBar1 -> saveFooBar(fooBar1))));

如果您可以使用真实的fooBar标志创建active的副本，则代码可能会更简单。例如龙目岛。

@Builder(toBuilder = true)
public class FooBar {
...
}

Mono<FooBar> fooBarMono = findFooBar()
        .flatMap(fooBar -> Flux.merge(
                createAndSaveLoremBar(fooBar),
                createAndSaveDoloremBar(fooBar))
                .then(saveFooBar(fooBar.toBuilder().active(true).build())));

如果您对saveFooBar(...)的结果不感兴趣，而仅对完成信号感兴趣，则可以异步进行所有三个保存：

Flux<Object> flux = findFooBar()
        .flatMapMany(fooBar -> Flux.merge(
                createAndSaveLoremBar(fooBar),
                createAndSaveDoloremBar(fooBar),
                saveFooBar(fooBar.toBuilder().active(true).build())));

实际上，在最后一种方法中，您可以收集所有三个结果，并且您应该更喜欢这种方法，但是我没有足够的信息来了解您的班级和创建完整示例的要求。

Answer 2

我认为波纹管解决方案更具可读性。无论如何，亚历山大是对的，您永远不要修改输入。您会看到我们借用了很多概念表功能编程。例如，您呼叫Function.identity()，这称为 identity functor。 Flux和Mono都是单子。对于这些称为Referential transparency的人来说，有一个秘密的概念是强制更新。

    final Mono<FooBar> fooBarMono1 = findFooBar()
            .zipWhen((fooBar) -> createAndSaveLoremBar(fooBar))
            .map(tuple -> tuple.getT1())
            .zipWhen((fooBar) -> createAndSaveDoloremBar(fooBar))
            .map(tuple -> tuple.getT1())
            .map(fooBar -> new FooBar(true))
            .flatMap(fooBar -> saveFooBar(fooBar));

或更简洁：

    final Mono<FooBar> fooBarMono1 = findFooBar()
            .zipWhen((fooBar) -> createAndSaveLoremBar(fooBar)
                                    .then(createAndSaveDoloremBar(fooBar)))
            .map(tuple -> tuple.getT1())
            .map(fooBar -> new FooBar(true))
            .flatMap(fooBar -> saveFooBar(fooBar));

正确执行多种反应操作的方法

2 个答案: