Introduction to Apache Camel

by Niraj Singh on August 13th, 2013 | Filed in: Enterprise Java Tags: Apache Camel

Apache Camel is a open source implementation of famous Enterprise Integration Patterns. Camel is a Routing and Mediation Engine and facilitates the developers to create routes and mediation rules in variety of Domain Specific language(DSL) such as java, Spring/XML, scala etc.

Camel is versatile

Camel uses URIs to supports large number of transport and messaging models such as HTTP, JMS, JBI, Mina, SCA, CXF it also works well with external components and dataformats. To get a feel of versatility of Camel you can browse the list of Components and URIs it supports in the link below. http://camel.apache.org/components.html

Camel is easy to use

Camel allows us to use same set of APIs to create routes and mediate messages between various components. This makes it extremely easy to use

Unit Testing camel is a breeze

Unit testing is essential to writing any quality code. Camel makes this facade of software development extremely easy. It provides bunch of ready make components like CamelContextSupport, camel-guice, camel-test-blueprint for easily testing the code. More of this in a future post.

The Camel Terminologies/Classes/Interfaces

Endpoint

Endpoints are places where the exchange of messages takes place. It may refer to an address, a POJO, email address, webservice uri, queue uri, file etc. In camel an endpoint is implemented by implemented Endpoint interface. The endpoints are wrapped by something called routes.

CamelContext

CamelContext is at heart of all camel application and it represents Camel run time system.

Create camelcontext.
Add endpoints or components.
Add Routes to connect the endpoints.
Invoke camelcontext.start() – This starts all the camel-internal threads which are responsible for receiving, sending and processing messages in the endpoints.
Lastly invoking camelcontext.stop() when all the messages are exchanged and processed. This will gracefully stop all the camel-internal threads and endpoints.

CamelTemplate

This is a thin wrapper around the CamelContext object and it is responsible to sending exchange or messages to an endpoint.

Component

Component is really an endpoint factory. As camel supports lots of different kind of resources, each of these resources have different kind of endpoints. In practical cases application don’t create endpoints directly using Components. Instead CamelContext decideds which component to instantiate and then uses that component instance to create endpoints. So in app we will have. CamelContext.getEndpoint(“pop3://john.smith@mailserv.example.com?password=myPassword”); Now pop3 in this case is name of the component. CamelContext maps all the component name with the component classes and using the name it instantiates the instance. Once it has handle to the component it instantiates the endpoint by calling. Component.createInstance() method.

Message

Mesaage represents a single concrete message ie request, reply or exception. All concrete message class impements a message interface for example JmsMessage class.

Exchange

Exchange is a container of message. It is created when a message is received by a consumer during routing process.

Processor

Processor interface represents a class that processes a message. It contains a single method public void process(Exchange exchange) throws exception Application developers can implement this interface to preform business logic on the message when message is received by the consumer.

Routes and RouteBuilder

Route is the step by step movement of message from a source, through arbitrary types of decision by filters or routers to a destination. They are configured by help of DSL (Domain Specific language). Java DSL is created by implementing routebuilder interface. It has single method called configure() which defines the entire route of message. Routes can also be configured via xml file using spring.

A Small Example of Camel code.

Lets follow this with a small example to get a taste of what Camel can do. In this example we will move group of files present in a folder to a different folder. In this process we will do following

Checkout the dependencies for Camel.
Create a simple RouterBuilder.
Registering CamelContext in a spring file.
Injecting the routerbuilder in a the CamelContext Bean
Executing the class by starting the Camelcontext and finally stopping it once the execution is done.

1. Dependencies – Add following dependencies in your pom.xml


            org.apache.camel
            camel-core
            ${camel-version}
        

        
            org.apache.camel
            camel-spring
            ${camel-version}
        

        
            org.apache.camel
            camel-aws
            ${camel-version}

2. Create RouterBuilder - RouterBuilder can be created by extending org.apache.camel.builder.RouterBuilder class and overriding configure() method. Here is an example

import org.apache.camel.builder.RouteBuilder;

/**
 * Created by IntelliJ IDEA.
 * User: Niraj Singh
 * Date: 7/28/13
 * Time: 10:29 AM
 * To change this template use File | Settings | File Templates.
 */
public class MyFirstRouterBuilder extends RouteBuilder {
     @Override
    public void configure() throws Exception {
        try{
            from( "file:d:/vids").to("file:d:/temp");
        }catch(Exception e){

        }
     }
}

From() is the source endpoint and contains uri of file or directory which camel will be polling.
to() represents the target endpoint and contains name of target file or directory.
The file component uri is of form “file://nameOfFileOrDirectory“.

3. Registering CamelContext in spring and injecting RouterBuilder in spring.

4. Starting the camel context and executing the code and stopping the camel context.

import org.apache.camel.CamelContext;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * Created by IntelliJ IDEA.
 * User: Niraj Singh
 * Date: 4/16/13
 * Time: 11:21 AM
 * To change this template use File | Settings | File Templates.
 */
public class CamelHello {
    public static void main(String args[]) throws Exception {
        try {
                ApplicationContext springcontext = new FileSystemXmlApplicationContext("D:/samayik/awsdemo/src/main/resources/hellocamel.xml");
                CamelContext context = springcontext.getBean("firstCamelContext", CamelContext.class);
                context.start();
                Thread.sleep(10000);
                context.stop();

            } catch ( Exception e ) {
                System.out.println(e);
            }

    }
}

If you run this class then first we load the camelcontext from the spring config file. Inject the router builder in it. After the context starts then all the file from source directory is copied to the target directory. Once all the file are copied then try copying a new file to the source directory, it will be copied to target as well until the context is running 10000 ms in this case.

I have few more advanced tutorials on camel. Perhaps you will find them useful. There links are listed in the reference sections.

References

That is all folks. Though no one will write comments, but I like to persevere, and still request folks to drop in a line or two if you like this tutorial.

Warm Regards

Niraj

Kumar's Blog

Tuesday, November 19, 2013