Question

我有两种方法。
主要方法：

@PostMapping("/login")
public Mono<ResponseEntity<ApiResponseLogin>> loginUser(@RequestBody final LoginUser loginUser) {
    return socialService.verifyAccount(loginUser)
            .flatMap(socialAccountIsValid -> {
                if (socialAccountIsValid) {
                    return this.userService.getUserByEmail(loginUser.getEmail())
                            .switchIfEmpty(insertUser(loginUser))
                            .flatMap(foundUser -> updateUser(loginUser, foundUser))
                            .map(savedUser -> {
                                String jwts = jwt.createJwts(savedUser.get_id(), savedUser.getFirstName(), "user");
                                return new ResponseEntity<>(HttpStatus.OK);
                            });
                } else {
                    return Mono.just(new ResponseEntity<>(HttpStatus.UNAUTHORIZED));
                }
            });

}

此调用的方法（服务调用外部api）：

public Mono<User> getUserByEmail(String email) {
    UriComponentsBuilder builder = UriComponentsBuilder
            .fromHttpUrl(USER_API_BASE_URI)
            .queryParam("email", email);
    return this.webClient.get()
            .uri(builder.toUriString())
            .exchange()
            .flatMap(resp -> {
                if (Integer.valueOf(404).equals(resp.statusCode().value())) {
                    return Mono.empty();
                } else {
                    return resp.bodyToMono(User.class);
                }
            });
}

在上面的示例中，即使返回了switchIfEmpty()的结果，也总是从main方法中调用Mono.empty()。

我找不到解决这个简单问题的方法。
以下内容也不起作用：

Mono.just(null)

因为该方法将抛出nullpointerexception。

我也不能使用的是flatMap方法来检查foundUser是否为空。
可悲的是，万一我返回Mono.empty()时，flatMap根本不会被调用，所以我也不能在此处添加任何条件。

感谢您的帮助。

@ SimY4

   @PostMapping("/login")
    public Mono<ResponseEntity<ApiResponseLogin>> loginUser(@RequestBody final LoginUser loginUser) {
        userExists = false;
        return socialService.verifyAccount(loginUser)
                .flatMap(socialAccountIsValid -> {
                    if (socialAccountIsValid) {
                        return this.userService.getUserByEmail(loginUser.getEmail())
                                .flatMap(foundUser -> {
                                    return updateUser(loginUser, foundUser);
                                })
                                .switchIfEmpty(Mono.defer(() -> insertUser(loginUser)))
                                .map(savedUser -> {
                                    String jwts = jwt.createJwts(savedUser.get_id(), savedUser.getFirstName(), "user");
                                    return new ResponseEntity<>(HttpStatus.OK);
                                });
                    } else {
                        return Mono.just(new ResponseEntity<>(HttpStatus.UNAUTHORIZED));
                    }
                });

    }

Answer 1

这是因为switchIfEmpty接受Mono“按值”。这意味着，即使在您订阅单声道之前，此替代单声道的评估也已触发。

想象一下这样的方法：

Mono<String> asyncAlternative() {
    return Mono.fromFuture(CompletableFuture.supplyAsync(() -> {
        System.out.println("Hi there");
        return "Alternative";
    }));
}

如果您这样定义代码：

Mono<String> result = Mono.just("Some payload").switchIfEmpty(asyncAlternative());

无论在流构建期间是什么，它将始终触发替代项。为了解决这个问题，您可以使用Mono.defer

推迟对第二个单声道的评估

Mono<String> result = Mono.just("Some payload")
        .switchIfEmpty(Mono.defer(() -> asyncAlternative()));

这样，只有在请求替代选项时，它才会打印“嗨”。

UPD：

详细说明我的答案。您面临的问题与Reactor无关，而与Java语言本身以及它如何解析方法参数有关。让我们检查一下我提供的第一个示例中的代码。

Mono<String> result = Mono.just("Some payload").switchIfEmpty(asyncAlternative());

我们可以将其重写为：

Mono<String> firstMono = Mono.just("Some payload");
Mono<String> alternativeMono = asyncAlternative();
Mono<String> result = firstMono.switchIfEmpty(alternativeMono);

这两个代码段在语义上是等效的。我们可以继续将它们展开，以查看问题所在：

Mono<String> firstMono = Mono.just("Some payload");
CompletableFuture<String> alternativePromise = CompletableFuture.supplyAsync(() -> {
        System.out.println("Hi there");
        return "Alternative";
    }); // future computation already tiggered
Mono<String> alternativeMono = Mono.fromFuture(alternativePromise);
Mono<String> result = firstMono.switchIfEmpty(alternativeMono);

如您所见，当我们开始编写Mono类型时，将来的计算已经触发。为了防止不必要的计算，我们可以将我们的未来纳入延迟评估中：

Mono<String> result = Mono.just("Some payload")
        .switchIfEmpty(Mono.defer(() -> asyncAlternative()));

将解开的

Mono<String> firstMono = Mono.just("Some payload");
Mono<String> alternativeMono = Mono.defer(() -> Mono.fromFuture(CompletableFuture.supplyAsync(() -> {
        System.out.println("Hi there");
        return "Alternative";
    }))); // future computation defered
Mono<String> result = firstMono.switchIfEmpty(alternativeMono);

在第二个示例中，未来被困在一个懒惰的供应商中，并且仅在需要时才安排执行。

Answer 2

对于那些尽管投票结果很好但仍然不明白为什么会有这种行为的人：

反应堆源（Mono.xxx 和 Flux.xxx）是：

懒惰评估：仅当订阅者订阅时才评估/触发源的内容；
或急切评估：即使在订阅者订阅之前，也会立即评估来源的内容。

像 Mono.just(xxx)、Flux.just(xxx)、Flux.fromIterable(x,y,z) 这样的表达式是急切的。

通过使用 defer()，您可以强制延迟评估源。这就是接受的答案有效的原因。

这样做：

 someMethodReturningAMono()
  .switchIfEmpty(buildError());

buildError() 依赖于急切的来源来创建替代 Mono 将始终在订阅之前进行评估：

Mono<String> buildError(){
       return Mono.just("An error occured!"); //<-- evaluated as soon as read
}

要防止这种情况，请执行以下操作：

 someMethodReturningAMono()
  .switchIfEmpty(Mono.defer(() -> buildError()));

阅读此answer了解更多信息。

单声道switchIfEmpty（）总是被调用

2 个答案: