{"id":16737,"date":"2013-08-28T16:00:54","date_gmt":"2013-08-28T13:00:54","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=16737"},"modified":"2013-08-28T12:28:01","modified_gmt":"2013-08-28T09:28:01","slug":"getting-started-with-apache-camel-using-java","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2013\/08\/getting-started-with-apache-camel-using-java.html","title":{"rendered":"Getting started with Apache Camel using Java"},"content":{"rendered":"

Apache Camel is a very useful library that helps you process events or messages from many different sources. You may move these messages through many different protocols such as between VM, HTTP, FTP, JMS, or even DIRECTORY\/FILE, and yet still keep your processing code free of transport logic. This allows you to concentrate on digesting the content of the messages instead.<\/p>\n

Here I will provide a tutorial on how you can get started with Apache Camel using Java instead of Groovy<\/a>.<\/p>\n

Let\u2019s start by creating a Maven project pom.xml<\/code> file first.
\n <\/p>\n

<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\"\r\n    xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n    xsi:schemaLocation=\"\r\n        http:\/\/maven.apache.org\/POM\/4.0.0\r\n        http:\/\/maven.apache.org\/maven-v4_0_0.xsd\">\r\n\r\n    <modelVersion>4.0.0<\/modelVersion>\r\n    <groupId>camel-spring-demo<\/groupId>\r\n    <artifactId>camel-spring-demo<\/artifactId>\r\n    <version>1.0-SNAPSHOT<\/version>\r\n    <packaging>jar<\/packaging>\r\n\r\n    <properties>\r\n        <project.build.sourceEncoding>UTF-8<\/project.build.sourceEncoding>\r\n        <camel.version>2.11.1<\/camel.version>\r\n    <\/properties>\r\n\r\n    <dependencies>\r\n        <dependency>\r\n            <groupId>org.apache.camel<\/groupId>\r\n            <artifactId>camel-core<\/artifactId>\r\n            <version>${camel.version}<\/version>\r\n        <\/dependency>\r\n        <dependency>\r\n            <groupId>org.slf4j<\/groupId>\r\n            <artifactId>slf4j-simple<\/artifactId>\r\n            <version>1.7.5<\/version>\r\n        <\/dependency>\r\n    <\/dependencies>\r\n\r\n<\/project><\/pre>\n
We are only going to explore the camel-core<\/code>, which actually contains quite of few useful components that you may use. Also for logging purpose, I have added a slf4j-simple<\/code> as a logger implementation<\/a> so we may see output on console.<\/p>\n
Next you just need a class to construct an Route<\/code>. A Route<\/code> is like a instruction definition to Camel on how to move your messages from one point to another. We are going to create src\/main\/java\/camelcoredemo\/TimerRouteBuilder.java<\/code> file that will generate a timer message on every second, and then pass to a processor that simply logs it.<\/p>\n
package camelcoredemo;\r\n\r\nimport org.slf4j.*;\r\nimport org.apache.camel.*;\r\nimport org.apache.camel.builder.*;\r\n\r\npublic class TimerRouteBuilder extends RouteBuilder {\r\n    static Logger LOG = LoggerFactory.getLogger(TimerRouteBuilder.class);\r\n    public void configure() {\r\n        from(\"timer:\/\/timer1?period=1000\")\r\n        .process(new Processor() {\r\n            public void process(Exchange msg) {\r\n                LOG.info(\"Processing {}\", msg);\r\n            }\r\n        });\r\n    }\r\n}<\/pre>\n
That\u2019s all you needed to get started. Now you may build and run this simple demo.<\/p>\n
bash> mvn compile\r\nbash> mvn exec:java -Dexec.mainClass=org.apache.camel.main.Main -Dexec.args='-r camelcoredemo.TimerRouteBuilder'<\/pre>\n
Notice that we didn\u2019t even write a Java main<\/strong> class, but simply use the org.apache.camel.main.Main<\/code> option to accepts a RouteBuilder<\/code> class name as parameter. Then it will load and create the route automatically.<\/p>\n
Controlling the CamelContext<\/code><\/h2>\n
When you start Camel, it creates a CamelContext<\/code> object that holds many information on how to run it, including the definition of the Route<\/code> we created. Now if you want to have more control over this CamelContext<\/code>, then you would need to write your own Main<\/code> class. I will show you a simple one here.
 
<\/div> <\/div><\/p>\n
package camelcoredemo;\r\n\r\nimport org.slf4j.*;\r\nimport org.apache.camel.*;\r\nimport org.apache.camel.impl.*;\r\nimport org.apache.camel.builder.*;\r\n\r\npublic class TimerMain {\r\n    static Logger LOG = LoggerFactory.getLogger(TimerMain.class);\r\n    public static void main(String[] args) throws Exception {\r\n        new TimerMain().run();\r\n    }\r\n    void run() throws Exception {\r\n        final CamelContext camelContext = new DefaultCamelContext();\r\n        camelContext.addRoutes(createRouteBuilder());\r\n        camelContext.setTracing(true);\r\n        camelContext.start();\r\n\r\n        Runtime.getRuntime().addShutdownHook(new Thread() {\r\n            public void run() {\r\n                try {\r\n                    camelContext.stop();\r\n                } catch (Exception e) {\r\n                    throw new RuntimeException(e);\r\n                }\r\n            }\r\n        });\r\n\r\n        waitForStop();\r\n    }\r\n    RouteBuilder createRouteBuilder() {\r\n        return new TimerRouteBuilder();\r\n    }\r\n    void waitForStop() {\r\n        while (true) {\r\n            try {\r\n                Thread.sleep(Long.MAX_VALUE);\r\n            } catch (InterruptedException e) {\r\n                break;\r\n            }\r\n        }\r\n    }\r\n}<\/pre>\n
As you can see, we re-used the existing TimerRouteBuilder<\/code> class inside createRouteBuilder()<\/code> method. Our Main<\/code> class now have full control when to create, start and stop the CamelContext<\/code><\/a>. This context allow you to have control on how to configure Camel globally rather than on Route<\/code> level. The javadoc link gives all the setter methods that you can explore on what it can do.<\/p>\n
Noticed that we also need to provide few setup codes in our Main<\/code> class. First we need to handle graceful shutdown, so we added a Java shutdown hook to invoke the context stop()<\/code>. Secondly we need to add a thread block after context has started. The reason for this is that the CamelContext#start()<\/code> method is non-blocking! If you don\u2019t block your Main<\/code> thread after start, then it will simply exit right after it, which will have not much use. You want to run Camel as a service (like a server) until you explicitly press CTRL+C<\/code> to terminate the process.<\/p>\n
Improving the Main<\/code> class to start CamelContext<\/code><\/h2>\n
If you don\u2019t want to deal with much of the Main<\/code> class setup code such as above, then you may simply extends the org.apache.camel.main.Main<\/code> class provided by camel-core<\/code> intead. By piggy-back on this class, you will only not have your Context auto setup, but you will get all the additional command line features such as controlling how long to run the process for, enabling tracing, loading custom route class etc.<\/p>\n
Refactoring previous example, here is how it look like.<\/p>\n
package camelcoredemo;\r\n\r\nimport org.slf4j.*;\r\nimport org.apache.camel.builder.*;\r\nimport org.apache.camel.main.Main;\r\n\r\npublic class TimerMain2 extends Main {\r\n    static Logger LOG = LoggerFactory.getLogger(TimerMain2.class);\r\n    public static void main(String[] args) throws Exception {\r\n        TimerMain2 main = new TimerMain2();\r\n        main.enableHangupSupport();\r\n        main.addRouteBuilder(createRouteBuilder());\r\n        main.run(args);\r\n    }\r\n    static RouteBuilder createRouteBuilder() {\r\n        return new TimerRouteBuilder();\r\n    }\r\n}<\/pre>\n
Now our TimerMain2<\/code> is much shorter, and you may try it out and it should function the same as before.<\/p>\n
bash> mvn compile\r\nbash> mvn exec:java -Dexec.mainClass=camelcoredemo.TimerMain2 -Dexec.args='-t'<\/pre>\n
Notice that we have given -t<\/code> option and it will dump Route<\/code> tracing. Use -h<\/code> and you will see all the available options.<\/p>\n
Adding bean to the Camel Registry<\/code><\/h2>\n
In the TimerRouteBuilder<\/code> example above, we have created a Processor<\/code> on the fly. Now if you were to combine few different Processor<\/code> together, it would be nicer to minimize the noise. Camel allow you to do this by registering processing beans in their registry space, and then you simply reference them in your route as bean<\/code> component. Here is how I can convert above example into beans processing.<\/p>\n
package camelcoredemo;\r\n\r\nimport org.slf4j.*;\r\nimport org.apache.camel.*;\r\nimport org.apache.camel.builder.*;\r\nimport org.apache.camel.main.Main;\r\n\r\npublic class TimerBeansMain extends Main {\r\n    static Logger LOG = LoggerFactory.getLogger(TimerBeansMain.class);\r\n    public static void main(String[] args) throws Exception {\r\n        TimerBeansMain main = new TimerBeansMain();\r\n        main.enableHangupSupport();\r\n        main.bind(\"processByBean1\", new Bean1());\r\n        main.bind(\"processAgainByBean2\", new Bean2());\r\n        main.addRouteBuilder(createRouteBuilder());\r\n        main.run(args);\r\n    }\r\n    static RouteBuilder createRouteBuilder() {\r\n        return new RouteBuilder() {\r\n                public void configure() {\r\n                    from(\"timer:\/\/timer1?period=1000\")\r\n                    .to(\"bean:processByBean1\")\r\n                    .to(\"bean:processAgainByBean2\");\r\n                }\r\n            };\r\n    }\r\n\r\n    \/\/ Processor beans\r\n    static class Bean1 implements Processor {\r\n        public void process(Exchange msg) {\r\n            LOG.info(\"First process {}\", msg);\r\n        }\r\n    }\r\n    static class Bean2 implements Processor {\r\n        public void process(Exchange msg) {\r\n            LOG.info(\"Second process {}\", msg);\r\n        }\r\n    }\r\n}<\/pre>\n
Now you see my Route<\/code> is very slim and without noise clutter; and I have refactored my processing code into individual classes. This promotes better code management and testing as you write more complex Route<\/code> to address business logic. It let you build LEGO like block of re-usable POJO beans. Besides just processing beans, Camel use this registry space for many other services as well. For example you may customize many other component endpoints with additional features and or configurations. Or thing such as thread pool strategy implementation replacement etc.<\/p>\n
The Route<\/code> in example above is constructed using what\u2019s called Java DSL. The route is very readable, and yet you\u2019ll get full IDE support to browse all the methods available to use for your route.<\/p>\n
I hope this article has helped you jump start your Camel ride. Besides the timer<\/code> component mentioned, the camel-core<\/code> also comes with the following components out of it\u2019s core jar.<\/p>\n