anchor.diff:  
   [source,java]
   ----------------------------------------------------------------------------------------------------------------------------------------
  -    // we pretend to send it to some non existing dummy queue
  -    template.send("activemq:queue:dummy, new Processor() {
  -        public void process(Exchange exchange) throws Exception {
  -            // and here we override the destination with the ReplyTo destination object so the message is sent to there instead of dummy
  -            exchange.getIn().setHeader(JmsConstants.JMS_DESTINATION, replyDestination);
  -            exchange.getIn().setBody("Here is the late reply.");
  -        }
  +// we pretend to send it to some non existing dummy queue
  +template.send("activemq:queue:dummy, new Processor() {
  +   public void process(Exchange exchange) throws Exception {
  +      // and here we override the destination with the ReplyTo destination object so the message is sent to there instead of dummy
  +      exchange.getIn().setHeader(JmsConstants.JMS_DESTINATION, replyDestination);
  +      exchange.getIn().setBody("Here is the late reply.");
       }
  +}
   ----------------------------------------------------------------------------------------------------------------------------------------
   
   ### Using a request timeout
  
positive.code: method = `InOut`) to the slow queue for further processing in Camel and
  we wait for a return reply:
  
  ### Samples
  
  JMS is used in many examples for other components as well. But we
  provide a few samples below to get started.
  
  #### Receiving from JMS
  
  In the following sample we configure a route that receives JMS messages
  and routes the message to a POJO:
  
  [source,java]
  --------------------------------
     from("jms:queue:foo").
       to("bean:myBusinessLogic");
  --------------------------------
  
  You can of course use any of the EIP patterns so the route can be
  context based. For example, here's how to filter an order topic for the
  big spenders:
  
  [source,java]
  ----------------------------------------------
  from("jms:topic:OrdersTopic").
    filter().method("myBean", "isGoldCustomer").
      to("jms:queue:BigSpendersQueue");
  ----------------------------------------------
  
  #### Sending to JMS
  
  In the sample below we poll a file folder and send the file content to a
  JMS topic. As we want the content of the file as a `TextMessage` instead
  of a `BytesMessage`, we need to convert the body to a `String`:
  
  [source,java]
  ------------------------------
  from("file://orders").
    convertBodyTo(String.class).
    to("jms:topic:OrdersTopic");
  ------------------------------
  
  #### Using Annotations
  
  Camel also has annotations so you can use link:pojo-consuming.html[POJO
  Consuming] and POJO Producing.
  
  #### Spring DSL sample
  
  The preceding examples use the Java DSL. Camel also supports Spring XML
  DSL. Here is the big spender sample using Spring DSL:
  
  [source,xml]
  ---------------------------------------------------
  <route>
    <from uri="jms:topic:OrdersTopic"/>
    <filter>
      <method bean="myBean" method="isGoldCustomer"/>
      <to uri="jms:queue:BigSpendersQueue"/>
    </filter>
  </route>
  ---------------------------------------------------
  
  #### Other samples
  
  JMS appears in many of the examples for other components and EIP
  patterns, as well in this Camel documentation. So feel free to browse
  the documentation. If you have time, check out the this tutorial that
  uses JMS but focuses on how well Spring Remoting and Camel works
  together Tutorial-JmsRemoting.
  
  #### Using JMS as a Dead Letter Queue storing Exchange
  
  Normally, when using <<jms-component,JMS>> as the transport, it only
  transfers the body and headers as the payload. If you want to use
  <<jms-component,JMS>> with a link:dead-letter-channel.html[Dead Letter
  Channel], using a JMS queue as the Dead Letter Queue, then normally the
  caused Exception is not stored in the JMS message. You can, however, use
  the `transferExchange` option on the JMS dead letter queue to instruct
  Camel to store the entire Exchange in the queue as a
  `javax.jms.ObjectMessage` that holds a
  `org.apache.camel.impl.DefaultExchangeHolder`. This allows you to
  consume from the Dead Letter Queue and retrieve the caused exception
  from the Exchange property with the key `Exchange.EXCEPTION_CAUGHT`. The
  demo below illustrates this:
  
  [source,java]
  ------------------------------------------------------------------------
  // setup error handler to use JMS as queue and store the entire Exchange
  errorHandler(deadLetterChannel("jms:queue:dead?transferExchange=true"));
  ------------------------------------------------------------------------
  
  Then you can consume from the JMS queue and analyze the problem:
  
  [source,java]
  -----------------------------------------------------------------------------------
  from("jms:queue:dead").to("bean:myErrorAnalyzer");
  
  // and in our bean
  String body = exchange.getIn().getBody();
  Exception cause = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class);
  // the cause message is
  String problem = cause.getMessage();
  -----------------------------------------------------------------------------------
  
  #### Using JMS as a Dead Letter Channel storing error only
  
  You can use JMS to store the cause error message or to store a custom
  body, which you can initialize yourself. The following example uses the
  Message Translator EIP to do a
  transformation on the failed exchange before it is moved to the
  <<jms-component,JMS>> dead letter queue:
  
  [source,java]
  --------------------------------------------------------------------------------------------------
  // we sent it to a seda dead queue first
  errorHandler(deadLetterChannel("seda:dead"));
  
  // and on the seda dead queue we can do the custom transformation before its sent to the JMS queue
  from("seda:dead").transform(exceptionMessage()).to("jms:queue:dead");
  --------------------------------------------------------------------------------------------------
  
  Here we only store the original cause error message in the transform.
  You can, however, use any Expression to send
  whatever you like. For example, you can invoke a method on a Bean or use
  a custom processor.
  
  ### Sending an InOnly message and keeping the JMSReplyTo header
  
  
negative.code: http://activemq.apache.org/jmstemplate-gotchas.html[poor performance].
  
  If you intend to use http://activemq.apache.org/[Apache ActiveMQ] as
  your message broker, the the recommendation is that you do one of the
  following: 
  
  * Use the ActiveMQ component, which is already
  optimized to use ActiveMQ efficiently
  