// here we register exception cause for MyFunctionException
// when this exception occurs we want it to be processed by our
// processor
onException(MyFunctionalException.class)
  .process(new MyFunctionFailureHandler())
  .stop();

public static class MyFunctionFailureHandler implements Processor {

    @Override
    public void process(Exchange exchange) throws Exception {
        // the caused by exception is stored in a property on the exchange
        Throwable caused = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Throwable.class);
        assertNotNull(caused);
        // here you can do what you want, but Camel regards this exception as
        // handled, and this processor as a failure handler, so it won't do redeliveries.
        // So this is the end of this route.
    }
}

onException(ValidationException)
    .handled(true);

<onException>
    <exception>org.apache.camel.ValidationException</exception>
    <handled>
      <constant>true</constant>
    </handled>
</onException>

- onException:
    exception:
      - org.apache.camel.ValidationException
    handled:
      constant: "true"

    // we do special error handling for when OrderFailedException is
    // thrown
    onException(OrderFailedException.class)
        // we mark the exchange as handled so the caller doesn't
        // receive the
        // OrderFailedException but whatever we want to return
        // instead
        .handled(true)
        // this bean handles the error handling where we can
        // customize the error
        // response using java code
        .bean(OrderService.class, "orderFailed")
        // and since this is an unit test we use mocks for testing
        .to("mock:error");

    // this is just the generic error handler where we set the
    // destination
    // and the number of redeliveries we want to try
    errorHandler(deadLetterChannel("mock:error").maximumRedeliveries(1));

    // this is our route where we handle orders
    from("direct:start")
        // this bean is our order service
        .bean(OrderService.class, "handleOrder")
        // this is the destination if the order is OK
        .to("mock:result");

    /**
     * Order service as a plain POJO class
     */
    public static class OrderService {

        /**
         * This method handle our order input and return the order
         */
        public Object handleOrder(@Headers Map headers, @Body String payload) throws OrderFailedException {
            headers.put("customerid", headers.get("customerid"));
            if ("Order: kaboom".equals(payload)) {
                throw new OrderFailedException("Cannot order: kaboom");
            } else {
                headers.put("orderid", "123");
                return "Order OK";
            }
        }

        /**
         * This method creates the response to the caller if the order could not
         * be processed
         */
        public Object orderFailed(@Headers Map headers, @Body String payload) {
            headers.put("customerid", headers.get("customerid"));
            headers.put("orderid", "failed");
            return "Order ERROR";
        }
    }

    public static class OrderFailedException extends Exception {

        public OrderFailedException(String message) {
            super(message);
        }

    }

 <!-- setup our error handler as the deal letter channel -->
<bean id="errorHandler" class="org.apache.camel.builder.DeadLetterChannelBuilder">
    <property name="deadLetterUri" value="mock:error"/>
</bean>

<!-- this is our POJO bean with our business logic defined as a plain spring bean -->
<bean id="orderService" class="org.apache.camel.spring.processor.onexception.OrderService" />

<!-- this is the camel context where we define the routes -->
<!-- define our error handler as a global error handler -->
<camelContext errorHandlerRef="errorHandler" xmlns="http://camel.apache.org/schema/spring">

  <onException>
    <!-- the exception is full qualified names as plain strings -->
    <!-- there can be more just add a 2nd, 3rd exception element (unbounded) -->
    <exception>org.apache.camel.spring.processor.onexception.OrderFailedException</exception>
    <!-- we can set the redelivery policy here as well -->
    <redeliveryPolicy maximumRedeliveries="1" />
    <!-- mark this as handled -->
    <handled>
      <constant>true</constant>
    </handled>
    <!-- let our order service handle this exception, call the orderFailed method -->
    <bean ref="orderService" method="orderFailed" />
    <!-- and since this is a unit test we use mock for assertions -->
    <to uri="mock:error" />
  </onException>

  <route>
    <!-- the route -->
    <from uri="direct:start" />
    <!-- in the normal route then route to our order service and call handleOrder method -->
    <bean ref="orderService" method="handleOrder" />
    <!-- and since this is a unit test we use mock for assertions -->
    <to uri="mock:result" />
  </route>

</camelContext>

- beans:
  - name: "orderService"
    type: "org.apache.camel.spring.processor.onexception.OrderService"
- errorHandler:
    deadLetterChannel:
      deadLetterUri: mock:error
- onException:
    exception:
      - org.apache.camel.spring.processor.onexception.OrderFailedException
    handled:
      constant:
        expression: "true"
    redeliveryPolicy:
      maximumRedeliveries: 1
    steps:
      - bean:
          ref: orderService
          method: orderFailed
      - to:
          uri: mock:error
- route:
    from:
      uri: direct:start
      steps:
        - bean:
            ref: orderService
            method: handleOrder
        - to:
            uri: mock:result

.onException(Exception.class)
    .handled(true)
    .process(new Processor() {
        @Override
        public void process(Exchange exchange) throws Exception {
            Exception cause = exchange.getException();
            // why cause exception is null ???
        }
    })
.end()

Exception cause = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class);

.onException(Exception.class).handled(true)
    .process(new Processor() {
        @Override
        public void process(Exchange exchange) throws Exception {
            Exception cause = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class);
            // we now have the caused exception
        }
    })
.end()

// we catch MyFunctionalException and want to mark it as handled
// (= no failure returned to client)
// but we want to return a fixed text response, so we transform
// OUT body as Sorry.
onException(MyFunctionalException.class)
  .handled(true)
  .transform().constant("Sorry");

// we catch MyFunctionalException and want to mark it as handled
// (= no failure returned to client)
// but we want to return a fixed text response, so we transform
// OUT body and return the exception message
onException(MyFunctionalException.class)
  .handled(true)
  .transform(exceptionMessage());

// we catch MyFunctionalException and want to mark it as handled
// (= no failure returned to client)
// but we want to return a fixed text response, so we transform
// OUT body and return a nice message
// using the simple language where we want insert the exception
// message
onException(MyFunctionalException.class)
  .handled(true)
  .transform().simple("Error reported: ${exception.message} - cannot process this message.");

onException(IDontCareException.class)
    .continued(true);

<onException>
    <exception>com.foo.IDontCareException</exception>
    <continued>
      <constant>true</constant>
    </continued>
</onException>

- onException:
    exception:
      - com.foo.IDontCareException
    continued:
      constant: "true"

onException(IllegalArgumentException.class).continued(true);

from("direct:start")
  .to("mock:start")
  .throwException(new IllegalArgumentException("Forced"))
  .to("mock:result");

<onException>
    <exception>java.lang.IllegalArgumentException</exception>
    <!-- tell Camel to handle and continue when this exception was thrown -->
    <continued><constant>true</constant></continued>
</onException>

<route>
    <from uri="direct:start"/>
    <to uri="mock:start"/>
    <throwException message="Forced" exceptionType="java.lang.IllegalArgumentException"/>
    <to uri="mock:result"/>
</route>

- onException:
    exception:
      - java.lang.IllegalArgumentException
    continued:
      constant:
        expression: "true"
- route:
    from:
      uri: direct:start
      steps:
        - to:
            uri: mock:start
        - throwException:
            message: Forced
            exceptionType: java.lang.IllegalArgumentException
        - to:
            uri: mock:result

from("jms:queue:order:input")
    .to("bean:validateOrder")
    .to("bean:transformOrder")
    .to("bean:handleOrder");

<route>
    <from uri="jms:queue:order:input"/>
    <to uri="bean:validateOrder"/>
    <to uri="bean:transformOrder"/>
    <to uri="bean:handleOrder"/>
</route>

- route:
    from:
      uri: jms:queue:order:input
      steps:
        - to:
            uri: bean:validateOrder
        - to:
            uri: bean:transformOrder
        - to:
            uri: bean:handleOrder

// will use original input message (body and headers)
onException(MyOrderException.class)
    .useOriginalMessage()
    .handled(true)
    .to("jms:queue:order:failed");

from("jms:queue:order:input")
    .to("bean:validateOrder")
    .to("bean:transformOrder")
    .to("bean:handleOrder");

<onException useOriginalMessage="true">
    <exception>com.foo.MyOrderException</exception>
    <handled>
        <constant>true</constant>
    </handled>
    <to uri="jms:queue:order:failed"/>
</onException>

<route>
    <from uri="jms:queue:order:input"/>
    <to uri="bean:validateOrder"/>
    <to uri="bean:transformOrder"/>
    <to uri="bean:handleOrder"/>
</route>

- onException:
    useOriginalMessage: "true"
    exception:
      - com.foo.MyOrderException
    handled:
      constant:
        expression: "true"
    steps:
      - to:
          uri: jms:queue:order:failed
- route:
    from:
      uri: jms:queue:order:input
      steps:
        - to:
            uri: bean:validateOrder
        - to:
            uri: bean:transformOrder
        - to:
            uri: bean:handleOrder

// will use original input body
onException(MyOrderException.class)
    .useOriginalBody()
    .handled(true)
    .to("jms:queue:order:failed");

from("jms:queue:order:input")
    .setHeader("application", constant("OrderApp"))
    .to("bean:validateOrder")
    .to("bean:transformOrder")
    .to("bean:handleOrder");

<onException useOriginalBody="true">
    <exception>com.foo.MyOrderException</exception>
    <handled>
        <constant>true</constant>
    </handled>
    <to uri="jms:queue:order:failed"/>
</onException>

<route>
    <from uri="jms:queue:order:input"/>
    <setHeader name="application">
        <constant>OrderApp</constant>
    </setHeader>
    <to uri="bean:validateOrder"/>
    <to uri="bean:transformOrder"/>
    <to uri="bean:handleOrder"/>
</route>

- onException:
    useOriginalBody: "true"
    exception:
      - com.foo.MyOrderException
    handled:
      constant:
        expression: "true"
    steps:
      - to:
          uri: jms:queue:order:failed
- route:
    from:
      uri: jms:queue:order:input
      steps:
        - setHeader:
            name: application
            expression:
              constant:
                expression: OrderApp
        - to:
            uri: bean:validateOrder
        - to:
            uri: bean:transformOrder
        - to:
            uri: bean:handleOrder