anchor.diff:  the destination is a mock endpoint.
   
   First we configure the standard Spring XML to declare a JMS connection
  -factory, a JMS transaction manager and our ActiveMQ component that we
  +factory, a JMS transaction manager and our xref:ROOT:activemq-component.adoc[ActiveMQ] component that we
   use in our routing.
   
   [source,xml]
  
positive.code: === About JTA Transactions
  
  TODO:
  
  == Using Transactions in Camel
  
  TODO:
  
  === Transaction error handler
  
  When a route is marked as transacted using ``<transacted/>` Camel will
  automatically use `TransactionErrorHandler` as the
  xref:latest@manual:ROOT:error-handler.adoc[Error Handler].
  
  This error handler supports basically the same
  feature set as the xref:latest@manual:ROOT:defaulterrorhandler.adoc[DefaultErrorHandler].
  
  === Transaction Policies
  
  Outbound endpoints will automatically enlist in the current transaction
  context. But what if you do not want your outbound endpoint to enlist in
  the same transaction as your inbound endpoint? The solution is to add a
  Transaction Policy to the processing route. You first have to define
  transaction policies that you will be using. The policies use a spring
  TransactionTemplate under the covers for declaring the transaction
  demarcation to use. So you will need to add something like the following
  to your spring xml:
  
  [source,xml]
  ----
  <bean id="PROPAGATION_REQUIRED" class="org.apache.camel.spring.spi.SpringTransactionPolicy">
      <property name="transactionManager" ref="jmsTransactionManager"/>
  </bean>
  
  <bean id="PROPAGATION_REQUIRES_NEW" class="org.apache.camel.spring.spi.SpringTransactionPolicy">
      <property name="transactionManager" ref="jmsTransactionManager"/>
      <property name="propagationBehaviorName" value="PROPAGATION_REQUIRES_NEW"/>
  </bean>
  ----
  
  Then in your
  https://www.javadoc.io/doc/org.apache.camel/camel-spring/current/org/apache/camel/spring/SpringRouteBuilder.html[SpringRouteBuilder],
  you just need to create new SpringTransactionPolicy objects for each of
  the templates.
  
  [source,java]
  ----
  public void configure() {
      ...
      Policy required = bean(SpringTransactionPolicy.class, "PROPAGATION_REQUIRED"));
      Policy requirenew = bean(SpringTransactionPolicy.class, "PROPAGATION_REQUIRES_NEW"));
      ...
  }
  ----
  
  Once created, you can use the Policy objects in your processing routes:
  
  [source,java]
  ----
  // Send to bar in a new transaction
  from("activemq:queue:foo").policy(requirenew)
      .to("activemq:queue:bar");
  
  // Send to bar without a transaction.
  from("activemq:queue:foo").policy(notsupported)
      .to("activemq:queue:bar");
  ----
  
  == Transaction example with database
  
  
negative.code: 
  === About Spring Transactions
  
  Camel uses Spring Transaction (`camel-spring`) to manage transactions via its `TransactionManager`
  API. Depending on the kinds of resources that are taking part in the transaction,
  an appropriate implementation of the transaction manager must be chosen. Spring
  offers a number of transaction managers out of the box that work for various local
  