CSC/ECE 517 Spring 2015/ch1a 17 WL

Apache Camel

Overview

Apache Camel is an open-source framework to exchange, route and transform data using various protocols. It is prepackaged with components for dealing with various backend systems and powerful routing and filter capabilities.<ref>http://www.methodsandtools.com/tools/tools.php?camel</ref> The domain-specific language means that Apache Camel can support type-safe smart completion of routing rules in an integrated development environment using regular Java code without large amounts of XML configuration files, though XML configuration inside Spring is also supported.<ref>http://en.wikipedia.org/wiki/Apache_Camel</ref>

Background

Camel is an integration framework that aims to make your integration projects productive and fun. The Camel project was started in early 2007, but although it’s relatively young, Camel is already a mature open source project, available under the liberal Apache 2 license, and it has a strong community. Camel’s focus is on simplifying integration. We’re confident that by the time you finish reading these pages, you’ll appreciate Camel and add it to your “must have” list of tools. The Apache Camel project was named Camel simply because the name is short and easy to remember. Rumor has it the name may be inspired by the fact that one of the founders once smoked Camel cigarettes. At the Camel website a FAQ entry lists other lighthearted reasons for the name.<ref>http://manning.com/ibsen/chapter1sample.pdf</ref>

In order to understand what Apache Camel is, we need to understand what Enterprise Integration Patterns are.

Let's start with what we presumably already know: The Singleton pattern, the Factory pattern, etc; They are merely ways of organizing your solution to the problem, but they are not solutions themselves. These patterns were analyzed and extracted for the rest of us by the Gang of Four, when they published their book: Design Patterns. They saved some of us tremendous effort in thinking of how to best structure our code.

Much like the Gang of Four, Gregor Hohpe and Bobby Woolf authored the book Enterprise Integration Patterns (EIP) in which they propose and document a set of new patterns and blueprints for how we could best design large component-based systems, where components can be running on the same process or in a different machine.

They basically propose that we structure our system to be message oriented -- where components communicate with each others using messages as inputs and outputs and absolutely nothing else. They show us a complete set of patterns that we may choose from and implement in our different components that will together form the whole system.<ref>http://stackoverflow.com/questions/8845186/what-exactly-is-apache-camel</ref>

Examples

Example 1

This mini-guide takes you through the source code of a simple example.<ref>http://camel.apache.org/walk-through-an-example.html</ref> We start with creating a CamelContext - which is a container for Components, Routes etc:

CamelContext context = new DefaultCamelContext();

There is more than one way of adding a Component to the CamelContext. You can add components implicitly - when we set up the routing - as we do here for the FileComponent:

context.addRoutes(new RouteBuilder() {
    public void configure() {
        from("test-jms:queue:test.queue").to("file://test");
    }
});

or explicitly - as we do here when we add the JMS Component:

ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("vm://localhost?broker.persistent=false");
// Note we can explicit name the component
context.addComponent("test-jms", JmsComponent.jmsComponentAutoAcknowledge(connectionFactory));

The above works with any JMS provider. If we know we are using ActiveMQ we can use an even simpler form using the activeMQComponent() method while specifying the brokerURL used to connect to ActiveMQ

camelContext.addComponent("activemq", activeMQComponent("vm://localhost?broker.persistent=false"));

In normal use, an external system would be firing messages or events directly into Camel through one if its Components but we are going to use the ProducerTemplate which is a really easy way for testing your configuration:

ProducerTemplate template = context.createProducerTemplate();

Next you must start the camel context. If you are using Spring to configure the camel context this is automatically done for you; though if you are using a pure Java approach then you just need to call the start() method

camelContext.start();

This will start all of the configured routing rules. So after starting the CamelContext, we can fire some objects into camel:

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

Example 2

The second sample <ref> http://www.methodsandtools.com/tools/tools.php?camel </ref> moves a file from directory A to directory B. Because this is rather easy, we'll add a XSLT transformation to it. Using the Java DSL, the definition is:

from("file: //inbox")	      (1)
.to("xslt:someXSLT.xsl")  (2)
.to("file://outbox");	      (3)

What does this do? In line (1), a route definition starts with the from keyword. As a parameter, the URL-style string defines that the file component shall be used for this. Everything after the slashes is passed as a parameter to the file component. In this case, the component scans the "inbox" folder for files and passes them on the next processing step.

In line (2), another component is instantiated. This time, the XSLT component is used with an XSL template, loaded from the Java classpath. Everything sent to this component gets transformed using that XSLT. The output of the transformation is passed on to the next step.

In line (3), another file component is used. This actually is another instance of the same component which was already configured on line (1). Everything sent to it will be written to the "outbox" folder. As you see, this is a very straightforward and convenient way of configuring data flow. The next sample is a little bit more complex.

Example 3

This sample <ref> http://www.methodsandtools.com/tools/tools.php?camel </ref> may be used to upload data into a database.

For this to work, you must know that the JDBC component of Apache Camel sends SQL queries to a datasource. To use that component, you need to read the file content, create an SQL query from it and send this, to the database.

Using the Spring DSL, the result is (slightly modified from the Apache Camel homepage):

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
   <route>
      <from uri="file://inbox"/>
      <to uri="xslt:someXSL.xsl"/>
      <to uri="jdbc:testdb"/>
   </route>
</camelContext>
<!-- Just add a demo to show how to bind a date source for camel in Spring-->
<bean id="testdb"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName"value="org.hsqldb.jdbcDriver"/>
      <property name="url"value="jdbc:hsqldb:mem:camel_jdbc"/>
      <property name="username"value="sa"/>
   <property name="password"value="" />
</bean>

Instead of using a stylesheet to perform the transformation, it would also be valid to use a Java bean, which serves the same purpose but may perform some more powerful operations.

Example 4

In the forth sample<ref> http://www.methodsandtools.com/tools/tools.php?camel </ref> , we'll take a look at how we can read data from the database and dump it to a file. Since that would be very much like what we did before, we'll add a persistence layer to it, with a JMS queue in-between.

Using the Java DSL, we get this source code:

from("timer://foo?period=60000").
   setBody(constant("select content from downloadTable")).
   to("jdbc:testDB").
   to("jms:queue:order ");
from("jms:queue:order").to("file://outbox");

The above sample does use the timer component. Every minute, the given SQL statement is executed and its result is sent to the JMS queue. From there, it is read and sent to the file system.

References

<references/>