<camel:errorHandler id="deadLetterErrorHandler" type="DeadLetterChannel" deadLetterUri="log:dead">

<camel:camelContext errorHandlerRef="deadLetterErrorHandler">
  ...
</camel:camelContext>

errorHandler(noErrorHandler());

<camel:errorHandler id="noErrorHandler" type="NoErrorHandler"/>

<camel:camelContext errorHandlerRef="noErrorHandler">
  ...
</camel:camelContext>

RouteBuilder builder = new RouteBuilder() {
    public void configure() {
        errorHandler(deadLetterChannel("seda:error"));

        // here is our regular route
        from("seda:a").to("seda:b");
    }
};

RouteBuilder builder = new RouteBuilder() {
    public void configure() {
        // this route is using a nested error handler
        from("seda:a")
            // here we configure the error handler
            .errorHandler(deadLetterChannel("seda:error"))
            // and we continue with the routing here
            .to("seda:b");

        // this route will use the default error handler
        from("seda:b").to("seda:c");
    }
};

<route>
    <errorHandler>
        <deadLetterChannel deadLetterUri="mock:dead">
            <redeliveryPolicy maximumRedeliveries="3" redeliveryDelay="250"/>
        </deadLetterChannel>
    </errorHandler>
    <from uri="direct:in"/>
    <process ref="myFailureProcessor"/>
    <to uri="mock:result"/>
</route>

    <!-- here we configure our DeadLetterChannel -->
    <bean id="myDeadLetterErrorHandler" class="org.apache.camel.builder.DeadLetterChannelBuilder">
        <!-- exchanges is routed to mock:dead in cased redelivery failed -->
        <property name="deadLetterUri" value="mock:dead"/>
        <!-- reference the redelivery policy to use -->
        <property name="redeliveryPolicy" ref="myRedeliveryPolicyConfig"/>
    </bean>

    <!-- here we set the redelivery settings -->
    <bean id="myRedeliveryPolicyConfig" class="org.apache.camel.processor.errorhandler.RedeliveryPolicy">
        <!-- try redelivery at most 3 times, after that the exchange is dead and its routed to the mock:dead endpoint -->
        <property name="maximumRedeliveries" value="3"/>
        <!-- delay 250ms before redelivery -->
        <property name="redeliveryDelay" value="250"/>
    </bean>

    <camelContext xmlns="http://camel.apache.org/schema/spring">
        <!-- set the errorHandlerRef to our DeadLetterChannel, this applies for this route only -->
        <route errorHandlerRef="myDeadLetterErrorHandler">
            <from uri="direct:in"/>
            <process ref="myFailureProcessor"/>
            <to uri="mock:result"/>
        </route>
    </camelContext>

- route:
    errorHandler:
      deadLetterChannel:
        deadLetterUri: mock:dead
        redeliveryPolicy:
          maximumRedeliveries: 3
          redeliveryDelay: 250
    from:
      uri: direct:in
      steps:
        - process:
            ref: myFailureProcessor
        - to:
            uri: mock:result

// in case of io exception then try to redeliver up till 2 times
// (do not use any delay due faster unit testing)
onException(IOException.class)
    .maximumRedeliveries(2).redeliveryDelay(0);

from("direct:start")
    .to("mock:a")
    // call sub route (using direct)
    .to("direct:sub")
    .to("mock:c");

from("direct:sub")
    // disable error handler, so the entire route can be retried in case of redelivery
    .errorHandler(noErrorHandler())
    .to("mock:b")
    .bean("myProcessor");

<!-- this is the processor that will fail the first 2 attempts -->
<bean id="myProcessor" class="org.apache.camel.processor.RedeliverToSubRouteTest.MyProcessor"/>

<camelContext xmlns="http://camel.apache.org/schema/spring">

    <!-- setup no error handler with an id, we refer to from the 2nd route -->
    <errorHandler id="noErrorHandler" type="NoErrorHandler"/>

    <!-- configure on exception to redelivery at most 2 times when an IOException was thrown
         do not use redelivery delay to run unit test faster -->
    <onException>
        <exception>java.io.IOException</exception>
        <redeliveryPolicy maximumRedeliveries="2" redeliveryDelay="0"/>
    </onException>

    <!-- 1st route, no need to setup error handler, as it will use the default error handler -->
    <route>
        <from uri="direct:start"/>
        <to uri="mock:a"/>
        <to uri="direct:sub"/>
        <to uri="mock:c"/>
    </route>

    <!-- disable error handler on this route, so the entire route can be redelivered
         when called from the 1st route -->
    <route errorHandlerRef="noErrorHandler">
        <from uri="direct:sub"/>
        <to uri="mock:b"/>
        <process ref="myProcessor"/>
    </route>
</camelContext>

<route>
    <from uri="direct:start"/>
    <onException>
        <exception>java.io.IOException</exception>
        <redeliveryPolicy maximumRedeliveries="2" redeliveryDelay="0"/>
    </onException>
    <to uri="mock:a"/>
    <to uri="direct:sub"/>
    <to uri="mock:c"/>
</route>

<route>
    <errorHandler>
        <noErrorHandler/>
    </errorHandler>
    <from uri="direct:sub"/>
    <to uri="mock:b"/>
    <process ref="myProcessor"/>
</route>

- onException:
    # in case of io exception then try to redeliver up till 2 times
    # (do not use any delay due faster unit testing)
    exception:
      - java.io.IOException
    redeliveryPolicy:
      maximumRedeliveries: 2
      redeliveryDelay: 0
- route:
    from:
      uri: direct:start
      steps:
        - to:
            uri: mock:a
        - to:
            uri: direct:sub
        - to:
            uri: mock:c
- route:
    errorHandler:
      noErrorHandler: {}
    from:
      uri: direct:sub
      steps:
        - to:
            uri: mock:b
        - process:
            ref: myProcessor

public static class MyProcessor implements Processor {

    private int counter;

    @Override
    public void process(Exchange exchange) throws Exception {
        // use a processor to simulate error in the first 2 calls
        if (counter++ < 2) {
            throw new IOException("Forced");
        }
        exchange.getIn().setBody("Bye World");
    }
}