Question

我有三个与Project Reactor有关的问题，我将在下面问他们。从我拥有的代码开始（它将被简化以更容易理解问题）。

Mono<Integer> doWithSession(Function<String, Mono<Integer>> callback, long timeout) {
  return Mono.just("hello")
        .compose(monostr -> monostr
            .doOnSuccess(str -> System.out.println("Suppose I want to release session here after all")) //(1)
            .doOnCancel(() -> System.out.println("cancelled")) //(2)
            .then(callback::apply)
            .timeoutMillis(timeout, Mono.error(new TimeoutException("Timeout after " + timeout)))
        );
}

并测试：

@Test
public void testDoWithSession2() throws Exception {
  Function<String, Mono<Integer>> fun1 = str -> Mono.fromCallable(() -> {
    System.out.println("do some long timed work");
    try {
      Thread.sleep(5000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("work has completed");
    return str.length();
  });

  StepVerifier.create(doWithSession(fun1,1000))
    .verifyError(TimeoutException.class);
}

所以和问题：

如何中断fun1的调用并立即返回错误？（也许我做错了什么但看起来错误不是在超时后返回，而是在所有回调调用之后）
为什么doOnSuccess和doOnCancel同时被调用？（我希望（1）OR（2）将被调用，但不会被调用）
以及如何处理以下案例：
- 想象代码Mono.just("hello")正在获取连接;
- 在最后（成功或失败时）我想发布会话（我尝试在（1）中这样做）。

Answer 1

1）如您所知，请使用.publishOn(Schedulers.single())。这将确保在另一个线程上调用callable并且只阻止所述线程。此外，它将允许取消可调用。

2）您的连锁店的订单很重要。您将.doOnSuccess放在compose的开头（顺便说一下，您根本不需要该特定示例，除非您想要提取该compose函数以便稍后重用）。所以这意味着它基本上从Mono.just收到通知，并在查询源之后立即运行，甚至在您的处理发生之前就开始运行...... doOnCancel相同。取消来自timeout触发......

3）有一个工厂要从资源中创建一个序列，并确保清理资源：Mono.using。所以它看起来像那样：

public <T> Mono<T> doWithConnection(Function<String, Mono<T>> callback, long timeout) {
    return Mono.using(
            //the resource supplier:
            () -> {
                System.out.println("connection acquired");
                return "hello";
            },
            //create a Mono out of the resource. On any termination, the resource is cleaned up
            connection -> Mono.just(connection)
                              //the blocking callable needs own thread:
                              .publishOn(Schedulers.single())
                              //execute the callable and get result...
                              .then(callback::apply)
                              //...but cancel if it takes too long
                              .timeoutMillis(timeout)
                              //for demonstration we'll log when timeout triggers:
                              .doOnError(TimeoutException.class, e -> System.out.println("timed out")),
            //the resource cleanup:
            connection -> System.out.println("cleaned up " + connection));
}

返回可调用的T值的Mono<T>。在生产代码中，您订阅它以处理该值。在测试中，StepVerifier.create()会为您订阅。

让我们通过长期运行的任务来证明它输出的内容：

@Test
public void testDoWithSession2() throws Exception {
    Function<String, Mono<Integer>> fun1 = str -> Mono.fromCallable(() -> {
        System.out.println("start some long timed work");
        //for demonstration we'll print some clock ticks
        for (int i = 1; i <= 5; i++) {
            try {
                Thread.sleep(1000);
                System.out.println(i + "s...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("work has completed");
        return str.length();
    });

    //let two ticks show up
    StepVerifier.create(doWithConnection(fun1,2100))
                .verifyError(TimeoutException.class);
}

输出：

connection acquired
start some long timed work
1s...
2s...
timed out
cleaned up hello

如果我们将超时超过5000，我们会得到以下结果。（由于StepVerifier需要超时，因此存在断言错误）：

connection acquired
start some long timed work
1s...
2s...
3s...
4s...
5s...
work has completed
cleaned up hello

java.lang.AssertionError: expectation "expectError(Class)" failed (expected: onError(TimeoutException); actual: onNext(5)

Answer 2

对于第一个问题，答案是使用调度程序：

Mono<Integer> doWithSession(Function<String, Mono<Integer>> callback, long timeout) {
    Scheduler single = Schedulers.single();
    return Mono.just("hello")
            .compose(monostr -> monostr
                    .publishOn(single) // use scheduler
                    .then(callback::apply)
                    .timeoutMillis(timeout, Mono.error(new TimeoutException("Timeout after " + timeout)))
            );
}

第三个问题可以通过这种方式解决：

private Mono<Integer> doWithSession3(Function<String, Mono<Integer>> callback, long timeout) {
    Scheduler single = Schedulers.single();
    return Mono.just("hello")
            .then(str -> Mono.just(str) // here wrapping our string to new Mono
                    .publishOn(single)
                    .then(callback::apply)
                    .timeoutMillis(timeout, Mono.error(new TimeoutException("Timeout after " + timeout)))
                    .doAfterTerminate((res, throwable) -> System.out.println("Do anything with your string" + str))
            );
}

Project Reactor超时处理

2 个答案: