So after starting the CamelContext, we can fire some objects into Camel.

In normal use, an external system would be firing messages or events directly into Camel through one if its components but we're going to use the CamelTemplate, which is a really easy way to test your configuration:

    CamelTemplate template = new CamelTemplate(context);

We can now send some test messages over JMS using the CamelTemplate:

for (int i = 0; i < 10; i++) {
    template.sendBody("test-jms:queue:test.queue", "Test Message: " + i);
}

From the CamelTemplate we send objects (in this case text) into the CamelContext to the Component test-jms:queue:test.queue. These text objects will be converted automatically into JMS Messages and posted to a JMS queue named test.queue. When we set up the route, we configured the FileComponent to listen of the test.queue.

The file FileComponent will take messages from the queue and save them to a directory named test. Every message will be saved in a file that corresponds to its destination and message ID.

Finally, we configured our own listener in the route to take notifications from the FileComponent and print them out as text.

Spring XML Configuration
This example will use Spring XML configuration to transform files from a directory using XQuery and send the results to a JMS queue. It parsers some files from a directory, transforms them using XQuery then sends them to a message queue. To make it easy to look at the generated files, we also have another route that consumes from the JMS queue and writes them to an output directory.

Running the Example
To run the example we use the Camel Maven Plugin. For example, from the source or binary distribution the following should work:

cd examples/camel-example-spring-xquery
mvn camel:run

You should now see the generated files in the target/outputFiles directory, which are the transformed messages read from the JMS queue.

Code Walkthrough
What this does is boot up the Spring ApplicationContext defined in the file META-INF/spring/camelContext.xml on the classpath. This is a regular Spring XML document that uses the Camel XML configuration to configure a CamelContext.

Note that at the end of this XML example file we explicitly configure the ActiveMQ component with details on how to connect to the broker.

The main part of the Spring XML file is here:

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

   <!-- lets parse files, transform them with XQuery and send them to JMS -->
   <route>
     <from uri="file:src/data?noop=true"/>
     <to uri="xquery:myTransform.xquery"/>
     <to uri="jms:MyQueue"/>
   </route>

   <!-- now lets write messages from the queue to a directory -->
   <route>
     <from uri="jms:MyQueue"/>
     <to uri="file:target/outputFiles"/>
   </route>

</camelContext>

<!-- lets configure the default ActiveMQ broker URL -->
<bean id="jms" class="org.apache.camel.component.jms.JmsComponent">
   <property name="connectionFactory">
     <bean class="org.apache.activemq.ActiveMQConnectionFactory">
       <property name="brokerURL" value="vm://localhost?broker.persistent=false"/>
     </bean>
   </property>
</bean>

This hopefully has given you a flavor of how easy it is to do enterprise integration using Apache Camel. For more information see the Web site at http://activemq.apache.org/camel/.

Resources
www.enterpriseintegrationpatterns.com/