Vertx 中的错误处理程序和失败处理程序

vert.x 是一个用于在 jvm 上开发反应式应用程序的工具包。我之前写过一篇简短的介绍性文章，当时我将它用于商业项目。几周前，我不得不重新审视一个基于 vert.x 的业余爱好项目，我了解到我对 vert.x 如何处理故障和错误的知识存在一些差距。为了填补这些空白，我做了一些实验，编写了一些测试，然后写了这篇博文。

大多数基于 vert.x 的 web 应用程序的核心是路由器。路由器根据请求的路径将请求路由到零个或多个请求处理程序。如果一切顺利，处理给定请求的处理程序将发出响应。当出现问题时，vert.x 提供故障处理程序和错误处理程序来处理这种情况。

如何发出请求处理程序中出现问题的信号？

请求处理程序中的错误有两种类型：要么抛出异常（有意或无意），要么通过在路由上下文上调用fail方法来显式发出错误信号。如果您想通过调用此方法来表明出现问题，您有以下三种选择：

• 您可以提供状态代码，
• 您可以提供状态代码和异常，或者
• 您可以提供例外。

抛出异常与以异常作为参数调用fail方法具有相同的效果。如果调用失败时没有提供状态码，则使用状态码500。如果调用失败时提供了异常，则该异常将可供所有失败和错误处理程序使用。

如果没有任何错误或失败处理程序，vert.x 将响应失败的请求，状态代码为 500，正文包含“内部服务器错误”。如果该响应不适合您的需求，您需要注册一个错误处理程序和/或一个或多个失败处理程序。

错误处理程序

您可以向路由器的每个状态代码注册一个错误处理程序。如果在处理请求时发生某些故障并且没有故障处理程序（更多信息见下文），则为与该故障对应的状态代码注册的错误处理程序将处理该请求：

@test
void errorhandlercanhandleexception(vertxtestcontext vertxtestcontext) {
    var handlerexecuted = vertxtestcontext.checkpoint();
    var errorhandlerexecuted = vertxtestcontext.checkpoint();

    router.route("/")
            .handler(rc -> {
                handlerexecuted.flag();
                throw new runtimeexception(request_handler_error_message);
            });
    router.errorhandler(500, rc -> {
        errorhandlerexecuted.flag();
        rc.response()
                .setstatuscode(500)
                .end(message_from_error_handler + ": " + rc.failure().getmessage());
    });

    var response = performgetrequest("/");

    assertthat(response.statuscode()).isequalto(500);
    assertthat(response.body()).startswith(message_from_error_handler);
    assertthat(response.body()).endswith(request_handler_error_message);
    vertxtestcontext.succeedingthencomplete();
}

如上所述，错误处理程序可以访问导致调用错误处理程序的异常。在此示例中，状态代码 500 的错误处理程序处理该错误，因为这是未提供其他状态代码时的默认状态代码。

vert.x 支持使用子路由器将单个（大型）路由器拆分为多个较小的路由器。虽然可以为每个子路由器注册错误处理程序，但它们将被简单地忽略：

@test
void errorhandlerforsubrouterisignored(vertx vertx, vertxtestcontext vertxtestcontext) {
    var handlerexecuted = vertxtestcontext.checkpoint();
    var rooterrorhandlerexecuted = vertxtestcontext.checkpoint();

    var subrouter = router.router(vertx);
    subrouter.errorhandler(500, rc ->
            vertxtestcontext.failnow("error handler for sub router should not be reached"));
    subrouter.route("/route")
            .handler(rc -> {
                handlerexecuted.flag();
                throw new runtimeexception(request_handler_error_message);
            });

    router.route("/sub/*")
            .subrouter(subrouter);

    router.errorhandler(500, rc -> {
        rooterrorhandlerexecuted.flag();
        rc.response()
                .setstatuscode(500)
                .end(message_from_error_handler + ": " + rc.failure().getmessage());
    });

    var response = performgetrequest("/sub/route");

    assertthat(response.statuscode()).isequalto(500);
    assertthat(response.body()).startswith(message_from_error_handler);
    assertthat(response.body()).endswith(request_handler_error_message);
    vertxtestcontext.succeedingthencomplete();
}

故障处理程序

在某些情况下，您可能需要对错误的处理方式进行更细粒度的控制。这就是故障处理程序的用武之地。每个路由可以注册一个或多个故障处理程序。它们将按照注册的顺序处理错误，直到处理程序成功处理错误或引发异常。

与错误处理程序一样，失败处理程序可以访问导致其调用的异常。他们还可以访问状态代码：

@test
void failurehandlercanhandlefailwithstatuscodeandexception(vertxtestcontext vertxtestcontext) {
    var handlerexecuted = vertxtestcontext.checkpoint();
    var failurehandlerexecuted = vertxtestcontext.checkpoint();

    router.route("/")
            .handler(rc -> {
                handlerexecuted.flag();
                rc.fail(418, new runtimeexception(request_handler_error_message));
            })
            .failurehandler(rc -> {
                failurehandlerexecuted.flag();
                rc.response()
                        .setstatuscode(rc.statuscode())
                        .end(message_from_failure_handler + ": " + rc.failure().getmessage());
            });

    var response = performgetrequest("/");

    assertthat(response.statuscode()).isequalto(418);
    assertthat(response.body()).startswith(message_from_failure_handler);
    assertthat(response.body()).endswith(request_handler_error_message);
    vertxtestcontext.succeedingthencomplete();
}

一旦失败处理程序成功处理失败，就不会调用任何错误处理程序：

@test
void errorhandlerisignoredwhenfailurehandlerhandledfailure(vertxtestcontext vertxtestcontext) {
    var handlerexecuted = vertxtestcontext.checkpoint();
    var failurehandlerexecuted = vertxtestcontext.checkpoint();

    router.route("/")
            .handler(rc -> {
                handlerexecuted.flag();
                throw new runtimeexception(request_handler_error_message);
            })
            .failurehandler(rc -> {
                failurehandlerexecuted.flag();
                rc.response()
                        .setstatuscode(rc.statuscode())
                        .end(message_from_failure_handler + ": " + rc.failure().getmessage());
            });
    router.errorhandler(500, rc -> vertxtestcontext.failnow("error should not reach error handler"));

    var response = performgetrequest("/");

    assertthat(response.statuscode()).isequalto(500);
    assertthat(response.body()).startswith(message_from_failure_handler);
    assertthat(response.body()).endswith(request_handler_error_message);
    vertxtestcontext.succeedingthencomplete();
}

如果一个故障处理程序无法处理某个故障，它可以让它由下一个故障处理程序处理：

@test
void failurehandlercandefertonextfailurehandler(vertxtestcontext vertxtestcontext) {
    var handlerexecuted = vertxtestcontext.checkpoint();
    var firstfailurehandlerexecuted = vertxtestcontext.checkpoint();
    var secondfailurehandlerexecuted = vertxtestcontext.checkpoint();

    router.route("/")
            .handler(rc -> {
                handlerexecuted.flag();
                throw new runtimeexception(request_handler_error_message);
            })
            .failurehandler(rc -> {
                firstfailurehandlerexecuted.flag();
                rc.next();
            })
            .failurehandler(rc -> {
                secondfailurehandlerexecuted.flag();
                rc.response()
                        .setstatuscode(rc.statuscode())
                        .end(message_from_failure_handler + ": " + rc.failure().getmessage());
            });

    var response = performgetrequest("/");

    assertthat(response.statuscode()).isequalto(500);
    assertthat(response.body()).startswith(message_from_failure_handler);
    assertthat(response.body()).endswith(request_handler_error_message);
    vertxtestcontext.succeedingthencomplete();
}

如果处理失败导致异常，则原始失败的处理将由错误处理程序接管：

@test
void exceptioninfailurehandlerisignoredbyerrorhandler(vertxtestcontext vertxtestcontext) {
    var handlerexecuted = vertxtestcontext.checkpoint();
    var failurehandlerexecuted = vertxtestcontext.checkpoint();
    var errorhandlerexecuted = vertxtestcontext.checkpoint();

    router.route("/")
            .handler(rc -> {
                handlerexecuted.flag();
                throw new runtimeexception(request_handler_error_message);
            })
            .failurehandler(rc -> {
                failurehandlerexecuted.flag();
                throw new runtimeexception(failure_handler_error_message);
            });

    router.errorhandler(500, rc -> {
        errorhandlerexecuted.flag();
        rc.response()
                .setstatuscode(500)
                .end(message_from_error_handler + ": " + rc.failure().getmessage());
    });

    var response = performgetrequest("/");

    assertthat(response.statuscode()).isequalto(500);
    assertthat(response.body()).startswith(message_from_error_handler);
    assertthat(response.body()).endswith(request_handler_error_message);
    vertxtestcontext.succeedingthencomplete();
}

如果没有为状态代码 500 注册错误处理程序，则故障处理程序中抛出的异常将导致内部服务器错误。

我们在上面看到在子路由器上注册的错误处理程序被忽略。然而，为子路由器上的路由注册的故障处理程序按预期运行。为子路由器的其中一个路由注册的失败处理程序可以返回响应本身，也可以回退到另一个匹配路由的失败处理程序：

@Test
void failureHandlerForSubRouterCanFallBackToFailureHandlerForRoot(Vertx vertx, VertxTestContext vertxTestContext) {
    var handlerExecuted = vertxTestContext.checkpoint();
    var rootFailureHandlerExecuted = vertxTestContext.checkpoint();
    var subFailureHandlerExecuted = vertxTestContext.checkpoint();

    var subRouter = Router.router(vertx);
    subRouter.route("/route")
            .handler(rc -> {
                handlerExecuted.flag();
                throw new RuntimeException(REQUEST_HANDLER_ERROR_MESSAGE);
            })
            .failureHandler(rc -> {
                subFailureHandlerExecuted.flag();
                rc.next();
            });

    router.route("/sub/*")
            .subRouter(subRouter);

    router.route()
            .failureHandler(rc -> {
                rootFailureHandlerExecuted.flag();
                rc.response()
                        .setStatusCode(500)
                        .end(MESSAGE_FROM_FAILURE_HANDLER + ": " + rc.failure().getMessage());
            });

    var response = performGetRequest("/sub/route");

    assertThat(response.statusCode()).isEqualTo(500);
    assertThat(response.body()).startsWith(MESSAGE_FROM_FAILURE_HANDLER);
    assertThat(response.body()).endsWith(REQUEST_HANDLER_ERROR_MESSAGE);
    vertxTestContext.succeedingThenComplete();
}

结论

正如我们所见，错误处理程序非常简单。实际上，每个状态代码只能有一个错误处理程序，并且如果该错误尚未以其他方式处理，则该处理程序将处理给定状态代码的每个错误。

关于失败处理程序还有更多要说的。每个路由可以有多个错误处理程序，它将按照处理程序注册的顺序处理错误。如果路由重叠（与给定请求的路径匹配的多个路由），则按照注册路由的顺序调用每个路由的故障处理程序。每个故障处理程序都可以决定让下一个故障处理程序处理错误。

我希望这篇文章能为 vert.x 的官方文档提供有用的补充。如果您想自己尝试一下，请克隆并浏览 https://github.com/ljpengelen/vertx-error-and-failure-handlers 以获得一些灵感和一个不错的起点。

以上就是Vertx 中的错误处理程序和失败处理程序的详细内容，更多请关注硕下网其它相关文章！