骆驼消息转发行为不如预期

Question

我在Camel中有一个路由，当异常发生时，我想重试，但是我想设置一个属性，以便该路由在第二次尝试时可以做一些稍微不同的事情，以阻止重试中再次发生错误。这里有一个路线说明了我目前正在尝试的想法。

from("direct:onExceptionTest")
    .onException(Exception.class)
        .maximumRedeliveries(1)
        .log("Retrying")
        .setProperty("retrying", constant(true))
    .end()
    .log("Start")   
    .choice()
        .when(property("retrying").isNull())
            .log("Throwing")
            .throwException(new Exception("Hello world"))
        .end()
    .end()
    .log("Done")

显然这不是真正的路线；整个选项主体只是在某些情况下模拟我的组件错误。我希望看到以下消息被记录：

Start
Throwing
Retrying
Start
Done

但我真正看到的是：

Start
Throwing
Retrying
Failed delivery for (MessageId: ... on ExchangeId: ...). Exhausted after delivery attempt: 2 caught: java.lang.Exception: Hello world. Processed by failure processor: FatalFallbackErrorHandler[Pipeline[[Channel[Log(onExceptionTest)[Retrying]], Channel[setProperty(retrying, true)]]]]

我尝试将handled（true）添加到异常处理程序中，但这只会抑制错误消息。我没有看到第二条开始或完成日志消息。

为什么我的路线没有按照我的预期运行，我需要做什么才能让它按照我想要的方式运行？

@程序员Dan指出，问题是重新传递不是为了我想要实现的目标，这可以解释为什么我的路由不起作用！所以我需要在我的处理程序中完成这项工作，但是我的路由调用了一个网络服务，还有一些其他步骤，我不想在处理程序中重复所有这些。我想出了这个方法，它和预期的一样起作用，但是它涉及到路由从一开始就再次调用自己。这是个坏主意吗？我会不会用这种方法让自己陷入困境？

from("direct:onExceptionTest")
    .onException(Exception.class)
        .onWhen(property("retrying").isNull()) // don't retry forever
        .log("Retrying")
        .setProperty("retrying", constant(true))
        .handled(true)
        .to("direct:onExceptionTest") // is recursion bad?
    .end()
    .log("Start")   
    .choice()
        .when(property("retrying").isNull())
            .log("Throwing")
            .throwException(new Exception("Hello world"))
        .end()
    .end()
    .log("Done")

Answer 1

关于Camel的返还机制，有几点需要考虑。首先，查看关于这个主题的文档，这些文档可能会挑战你对Camel如何处理返还的假设。我提到的一点是，Camel尝试在失败点进行返还，它不会从路由的开始重新开始（就像你似乎假设的那样）。如果我正确理解文档（我有一段时间没有尝试过这种模式了），你基本上是告诉它重试几次抛出异常，我怀疑这是你想测试的。

第二，我建议直接在onException（）处理器链中执行替代处理，正如在同一文档中进一步演示的那样。基本上，您可以指定希望通过自定义处理器处理消息的方式，并使用handled（true）和stop（）指示无需进一步处理。

总而言之，重新交付通常意味着处理典型的endpoint交付故障，如间歇性连接中断、接收服务器暂时不可用等。在这些情况下，最合理的做法是“再试一次”，并有一个合理的成功预期。如果需要更复杂的逻辑来处理重试，请在onException（）处理器链中使用自定义处理器或一系列处理器。

Answer 2

使用onRe递送和处理器来设置属性：

String KEY = "retrying";

from("direct:onExceptionTest")
     .onException(RuntimeException.class)
         .onRedelivery(new Processor() { // Sets a processor that should be processed before a redelivery attempt.
             @Override
             public void process(final Exchange exchange) throws Exception {
                 LOG.info("Retrying");
                 exchange.setProperty(KEY, true);
             }
        })
        .maximumRedeliveries(1)
        .handled(true)
    .end()
    .log("Start")
    .process(new Processor() {
        @Override
        public void process(final Exchange exchange) throws Exception {
            LOG.info("No problem");
        }
    })
    .process(new Processor() {
        @Override
        public void process(final Exchange exchange) throws Exception {
            if (exchange.getProperty(KEY) == null) {
                LOG.info("Throwing");
                throw new RuntimeException("Hello World");
            }
            else {
                LOG.info("No throwing");
            }
        }
    })
    .log("Done");

这张照片

[                          main] route1                         INFO  Start
[                          main] OnExceptionHandler             INFO  No problem
[                          main] OnExceptionHandler             INFO  Throwing
[                          main] OnExceptionHandler             INFO  Retrying
[                          main] OnExceptionHandler             INFO  No throwing
[                          main] route1                         INFO  Done

正如@程序员丹所指出的，只有失败的处理器会被重新执行，而不是第一个没有任何问题就通过的处理器。

编辑：

如果所有的处理都必须重新完成，那么您可以使用带有dotry和doCatch的子路由，如下所示：

from("direct:onExceptionTest")
    .doTry()
        .to("direct:subroute")
    .doCatch(RuntimeException.class)
        .setProperty(KEY, constant(true))
        .to("direct:subroute")
    .end()
    .log("Done");

from("direct:subroute")
    .log("Start")
    .process(new Processor() {
        @Override
        public void process(final Exchange exchange) throws Exception {
            LOG.info("No problem");
        }
    })
    .process(new Processor() {
        @Override
        public void process(final Exchange exchange) throws Exception {
            if (exchange.getProperty(KEY) == null) {
                LOG.info("Throwing");
                throw new RuntimeException("Hello World");
            }
            else {
                LOG.info("No throwing");
            }
        }
    });

从骆驼文档：

使用doTry时<代码>文件处理doFinally则常规的驼峰错误处理程序不适用。这意味着任何onException或类似事件都不会触发。原因是，doTry<代码>文件处理doFinally实际上是它自己的错误处理程序，它的目标是模仿并像Java中的try/catch/finally那样工作。