Apache Camel
U S E R G U I D E
Version 2.11.0
Copyright 2007-2013, Apache Software Foundation
1
www.princexml.comPrince - Non-commercial LicenseThis document was created with Prince, a great way of getting web content onto paper.
Table of Contents
Table of Contents......................................................................... ii
Chapter 1Introduction ...................................................................................1
Chapter 1Quickstart.......................................................................................1
Chapter 1Getting Started..............................................................................7
Chapter 1Architecture................................................................................ 17
Chapter 1Enterprise Integration Patterns.............................................. 37
Chapter 1Cook Book ................................................................................... 42
Chapter 1Tutorials..................................................................................... 122
Chapter 1Language Appendix.................................................................. 221
Chapter 1DataFormat Appendix............................................................. 297
Chapter 1Pattern Appendix..................................................................... 383
Chapter 1Component Appendix ............................................................. 532
Index ................................................................................................0
ii APACHE CAMEL
C H A P T E R 1
Introduction
Apache Camel is a versatile open-source integration framework based on known EnterpriseIntegration Patterns.Camel empowers you to define routing and mediation rules in a variety of domain-specificlanguages, including a Java-based Fluent API, Spring or Blueprint XML Configuration files, and aScala DSL. This means you get smart completion of routing rules in your IDE, whether in a Java,Scala or XML editor.
Apache Camel uses URIs to work directly with any kind of Transport or messaging modelsuch as HTTP, ActiveMQ, JMS, JBI, SCA, MINA or CXF, as well as pluggable Components andData Format options. Apache Camel is a small library with minimal dependencies for easyembedding in any Java application. Apache Camel lets you work with the same API regardlesswhich kind of Transport is used - so learn the API once and you can interact with all theComponents provided out-of-box.
Apache Camel provides support for Bean Binding and seamless integration with popularframeworks such as Spring, Blueprint and Guice. Camel also has extensive support for unittesting your routes.
The following projects can leverage Apache Camel as a routing and mediation engine: Apache ServiceMix - a popular distributed open source ESB and JBI container Apache ActiveMQ - a mature, widely used open source message broker Apache CXF - a smart web services suite (JAX-WS and JAX-RS) Apache Karaf - a small OSGi based runtime in which applications can be deployed Apache MINA - a high-performance NIO-driven networking framework
So don't get the hump - try Camel today!
CHAPTER 1 - INTRODUCTION 1
http://camel.apache.org/enterprise-integration-patterns.htmlhttp://camel.apache.org/enterprise-integration-patterns.htmlhttp://camel.apache.org/dsl.htmlhttp://camel.apache.org/spring.htmlhttp://camel.apache.org/using-osgi-blueprint-with-camel.htmlhttp://camel.apache.org/xml-configuration.htmlhttp://camel.apache.org/scala-dsl.htmlhttp://camel.apache.org/uris.htmlhttp://camel.apache.org/transport.htmlhttp://camel.apache.org/http.htmlhttp://camel.apache.org/activemq.htmlhttp://camel.apache.org/jms.htmlhttp://camel.apache.org/jbi.htmlhttp://camel.apache.org/mina.htmlhttp://camel.apache.org/cxf.htmlhttp://camel.apache.org/components.htmlhttp://camel.apache.org/data-format.htmlhttp://camel.apache.org/what-are-the-dependencies.htmlhttp://camel.apache.org/exchange.htmlhttp://camel.apache.org/transport.htmlhttp://camel.apache.org/components.htmlhttp://camel.apache.org/bean-binding.htmlhttp://camel.apache.org/spring.htmlhttp://camel.apache.org/using-osgi-blueprint-with-camel.htmlhttp://camel.apache.org/guice.htmlhttp://camel.apache.org/testing.htmlhttp://camel.apache.org/testing.htmlhttp://servicemix.apache.org/http://activemq.apache.org/http://cxf.apache.org/http://karaf.apache.org/http://mina.apache.org/http://en.wikipedia.org/wiki/New_I/O
Too many buzzwords - what exactly is Camel?Okay, so the description above is technology focused.There's a great discussion about Camel at Stack Overflow. We suggest you view thepost, read the comments, and browse the suggested links for more details.
2 CHAPTER 1 - INTRODUCTION
http://stackoverflow.com/questions/8845186/what-exactly-is-apache-camel
C H A P T E R 2
Quickstart
To start using Apache Camel quickly, you can read through some simple examples in thischapter. For readers who would like a more thorough introduction, please skip ahead toChapter 3.
WALK THROUGH AN EXAMPLE CODE
This mini-guide takes you through the source code of a simple example.
Camel can be configured either by using Spring or directly in Java - which this example does.
This example is available in the examples\camel-example-jms-file directory ofthe Camel distribution.
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 addcomponents 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 = newActiveMQConnectionFactory("vm://localhost?broker.persistent=false");// Note we can explicit name the componentcontext.addComponent("test-jms",JmsComponent.jmsComponentAutoAcknowledge(connectionFactory));
The above works with any JMS provider. If we know we are using ActiveMQ we can use aneven simpler form using the activeMQComponent() method while specifying thebrokerURL used to connect to ActiveMQ
CHAPTER 2 - QUICKSTART 1
https://svn.apache.org/repos/asf/camel/trunk/examples/camel-example-jms-file/src/main/java/org/apache/camel/example/jmstofile/CamelJmsToFileExample.javahttp://camel.apache.org/spring.htmlhttps://svn.apache.org/repos/asf/camel/trunk/examples/camel-example-jms-file/src/main/java/org/apache/camel/example/jmstofile/CamelJmsToFileExample.javahttp://camel.apache.org/download.htmlhttp://camel.apache.org/camelcontext.htmlhttp://camel.apache.org/components.htmlhttp://camel.apache.org/routes.htmlhttp://camel.apache.org/file2.htmlhttp://camel.apache.org/activemq.htmlhttp://activemq.apache.org/maven/5.5.0/activemq-camel/apidocs/org/apache/activemq/camel/component/ActiveMQComponent.html#activeMQComponent%28java.lang.String%29http://activemq.apache.org/maven/5.5.0/activemq-camel/apidocs/org/apache/activemq/camel/component/ActiveMQComponent.html#activeMQComponent%28java.lang.String%29http://activemq.apache.org/configuring-transports.html
camelContext.addComponent("activemq",activeMQComponent("vm://localhost?broker.persistent=false"));
In normal use, an external system would be firing messages or events directly into Camelthrough one if its Components but we are going to use the ProducerTemplate which is a reallyeasy 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 contextthis is automatically done for you; though if you are using a pure Java approach then you justneed 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);
}
WHAT HAPPENS?
From the ProducerTemplate - we send objects (in this case text) into the CamelContext to theComponent test-jms:queue:test.queue. These text objects will be converted automatically intoJMS Messages and posted to a JMS Queue named test.queue. When we set up the Route, weconfigured the FileComponent to listen of the test.queue.
The File FileComponent will take messages off the Queue, and save them to a directorynamed test. Every message will be saved in a file that corresponds to its destination and messageid.
Finally, we configured our own listener in the Route - to take notifications from theFileComponent and print them out as text.
That's it!
If you have the time then use 5 more minutes to Walk through another example thatdemonstrates the Spring DSL (XML based) routing.
2 CHAPTER 2 - QUICKSTART
http://camel.apache.org/components.htmlhttp://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/ProducerTemplate.htmlhttp://camel.apache.org/spring.htmlhttp://camel.apache.org/camelcontext.htmlhttp://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/ProducerTemplate.htmlhttp://camel.apache.org/camelcontext.htmlhttp://camel.apache.org/type-converter.htmlhttp://camel.apache.org/routes.htmlhttp://camel.apache.org/file2.htmlhttp://camel.apache.org/file2.htmlhttp://camel.apache.org/routes.htmlhttp://camel.apache.org/file2.htmlhttp://camel.apache.org/walk-through-another-example.html
WALK THROUGH ANOTHER EXAMPLE
Introduction
Continuing the walk from our first example, we take a closer look at the routing and explain afew pointers - so you won't walk into a bear trap, but can enjoy an after-hours walk to the localpub for a large beer
First we take a moment to look at the Enterprise Integration Patterns - the base patterncatalog for integration scenarios. In particular we focus on Pipes and Filters - a central pattern.This is used to route messages through a sequence of processing steps, each performing aspecific function - much like the Java Servlet Filters.
Pipes and filters
In this sample we want to process a message in a sequence of steps where each steps canperform their specific function. In our example we have a JMS queue for receiving new orders.When an order is received we need to process it in several steps:
validate register send confirm email
This can be created in a route like this:
Where as the bean ref is a reference for a spring bean id, so we define our beans usingregular Spring XML as:
Our validator bean is a plain POJO that has no dependencies to Camel what so ever. So youcan implement this POJO as you like. Camel uses rather intelligent Bean Binding to invoke yourPOJO with the payload of the received message. In this example we will not dig into this howthis happens. You should return to this topic later when you got some hands on experiencewith Camel how it can easily bind routing using your existing POJO beans.
So what happens in the route above. Well when an order is received from the JMS queuethe message is routed like Pipes and Filters:1. payload from the JMS is sent as input to the validateOrder bean
CHAPTER 2 - QUICKSTART 3
http://camel.apache.org/walk-through-an-example.htmlhttp://camel.apache.org/enterprise-integration-patterns.htmlhttp://camel.apache.org/pipes-and-filters.htmlhttp://camel.apache.org/jms.htmlhttp://camel.apache.org/bean-binding.htmlhttp://camel.apache.org/jms.htmlhttp://camel.apache.org/pipes-and-filters.htmlhttp://camel.apache.org/jms.html
Pipeline is defaultIn the route above we specify pipeline but it can be omitted as its default, soyou can write the route as:
This is commonly used not to state the pipeline.
An example where the pipeline needs to be used, is when using a multicast and "one" ofthe endpoints to send to (as a logical group) is a pipeline of other endpoints. For example.
The above sends the order (from jms:queue:order) to two locations at the same time,our log component, and to the "pipeline" of beans which goes one to the other. If youconsider the opposite, sans the
you would see that multicast would not "flow" the message from one bean to the next, butrather send the order to all 4 endpoints (1x log, 3x bean) in parallel, which is not (for this
4 CHAPTER 2 - QUICKSTART
example) what we want. We need the message to flow to the validateOrder, then to theregisterOrder, then the sendConfirmEmail so adding the pipeline, provides this facility.
2. the output from validateOrder bean is sent as input to the registerOrder bean3. the output from registerOrder bean is sent as input to the sendConfirmEmail bean
Using Camel Components
In the route lets imagine that the registration of the order has to be done by sending data to aTCP socket that could be a big mainframe. As Camel has many Components we will use thecamel-mina component that supports TCP connectivity. So we change the route to:
What we now have in the route is a to type that can be used as a direct replacement for thebean type. The steps is now:1. payload from the JMS is sent as input to the validateOrder bean2. the output from validateOrder bean is sent as text to the mainframe using TCP3. the output from mainframe is sent back as input to the sendConfirmEmai bean
What to notice here is that the to is not the end of the route (the world ) in thisexample it's used in the middle of the Pipes and Filters. In fact we can change the bean types toto as well:
As the to is a generic type we must state in the uri scheme which component it is. So we mustwrite bean: for the Bean component that we are using.
CHAPTER 2 - QUICKSTART 5
http://camel.apache.org/components.htmlhttp://camel.apache.org/mina.htmlhttp://camel.apache.org/jms.htmlhttp://camel.apache.org/pipes-and-filters.htmlhttp://camel.apache.org/bean.html
Conclusion
This example was provided to demonstrate the Spring DSL (XML based) as opposed to thepure Java DSL from the first example. And as well to point about that the to doesn't have to bethe last node in a route graph.
This example is also based on the in-only message exchange pattern. What you mustunderstand as well is the in-out message exchange pattern, where the caller expects aresponse. We will look into this in another example.
See also
Examples Tutorials User Guide
6 CHAPTER 2 - QUICKSTART
http://camel.apache.org/walk-through-an-example.htmlhttp://camel.apache.org/examples.htmlhttp://camel.apache.org/tutorials.htmlhttp://camel.apache.org/user-guide.html
C H A P T E R 3
Getting Started with ApacheCamel
THE ENTERPRISE INTEGRATION PATTERNS (EIP) BOOK
The purpose of a "patterns" book is not to advocate new techniques that the authors haveinvented, but rather to document existing best practices within a particular field. By doing this,the authors of a patterns book hope to spread knowledge of best practices and promote avocabulary for discussing architectural designs.One of the most famous patterns books is Design Patterns: Elements of Reusable Object-orientedSoftware by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides, commonly known asthe "Gang of Four" (GoF) book. Since the publication of Design Patterns, many other patternbooks, of varying quality, have been written. One famous patterns book is called EnterpriseIntegration Patterns: Designing, Building, and Deploying Messaging Solutions by Gregor Hohpe andBobby Woolf. It is common for people to refer to this book by its initials EIP. As the subtitle ofEIP suggests, the book focuses on design patterns for asynchronous messaging systems. Thebook discusses 65 patterns. Each pattern is given a textual name and most are also given agraphical symbol, intended to be used in architectural diagrams.
THE CAMEL PROJECT
Camel (http://camel.apache.org) is an open-source, Java-based project that helps the userimplement many of the design patterns in the EIP book. Because Camel implements many of thedesign patterns in the EIP book, it would be a good idea for people who work with Camel tohave the EIP book as a reference.
ONLINE DOCUMENTATION FOR CAMEL
The documentation is all under the Documentation category on the right-side menu of theCamel website (also available in PDF form. Camel-related books are also available, in particularthe Camel in Action book, presently serving as the Camel bible--it has a free Chapter One(pdf), which is highly recommended to read to get more familiar with Camel.
CHAPTER 3 - GETTING STARTED WITH APACHE CAMEL 7
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612http://en.wikipedia.org/wiki/Design_Patternshttp://www.amazon.com/Enterprise-Integration-Patterns-Designing-Deploying/dp/0321200683http://www.amazon.com/Enterprise-Integration-Patterns-Designing-Deploying/dp/0321200683http://camel.apache.orghttp://camel.apache.org/manual.htmlhttp://camel.apache.org/books.htmlhttp://manning.com/ibsenhttp://www.manning.com/ibsen/chapter1sample.pdfhttp://www.manning.com/ibsen/chapter1sample.pdf
A useful tip for navigating the online documentation
The breadcrumbs at the top of the online Camel documentation can help you navigate betweenparent and child subsections.For example, If you are on the "Languages" documentation page then the left-hand side of thereddish bar contains the following links.
Apache Camel > Documentation > Architecture > Languages
As you might expect, clicking on "Apache Camel" takes you back to the home page of theApache Camel project, and clicking on "Documentation" takes you to the main documentationpage. You can interpret the "Architecture" and "Languages" buttons as indicating you are in the"Languages" section of the "Architecture" chapter. Adding browser bookmarks to pages thatyou frequently reference can also save time.
ONLINE JAVADOC DOCUMENTATION
The Apache Camel website provides Javadoc documentation. It is important to note that theJavadoc documentation is spread over several independent Javadoc hierarchies rather than beingall contained in a single Javadoc hierarchy. In particular, there is one Javadoc hierarchy for thecore APIs of Camel, and a separate Javadoc hierarchy for each component technology supportedby Camel. For example, if you will be using Camel with ActiveMQ and FTP then you need tolook at the Javadoc hierarchies for the core API and Spring API.
CONCEPTS AND TERMINOLOGY FUNDAMENTAL TO CAMEL
In this section some of the concepts and terminology that are fundamental to Camel areexplained. This section is not meant as a complete Camel tutorial, but as a first step in thatdirection.
Endpoint
The term endpoint is often used when talking about inter-process communication. For example,in client-server communication, the client is one endpoint and the server is the other endpoint.Depending on the context, an endpoint might refer to an address, such as a host:port pair forTCP-based communication, or it might refer to a software entity that is contactable at thataddress. For example, if somebody uses "www.example.com:80" as an example of an endpoint,they might be referring to the actual port at that host name (that is, an address), or they mightbe referring to the web server (that is, software contactable at that address). Often, thedistinction between the address and software contactable at that address is not an importantone.Some middleware technologies make it possible for several software entities to be contactableat the same physical address. For example, CORBA is an object-oriented, remote-procedure-
8 CHAPTER 3 - GETTING STARTED WITH APACHE CAMEL
http://camel.apache.org/maven/current/camel-core/apidocs/index.htmlhttp://camel.apache.org/maven/current/camel-core/apidocs/index.htmlhttp://camel.apache.org/maven/current/camel-spring/apidocs/index.html
call (RPC) middleware standard. If a CORBA server process contains several objects then aclient can communicate with any of these objects at the same physical address (host:port), but aclient communicates with a particular object via that object's logical address (called an IOR inCORBA terminology), which consists of the physical address (host:port) plus an id that uniquelyidentifies the object within its server process. (An IOR contains some additional informationthat is not relevant to this present discussion.) When talking about CORBA, some people mayuse the term "endpoint" to refer to a CORBA server's physical address, while other people mayuse the term to refer to the logical address of a single CORBA object, and other people stillmight use the term to refer to any of the following:
The physical address (host:port) of the CORBA server process The logical address (host:port plus id) of a CORBA object. The CORBA server process (a relatively heavyweight software entity) A CORBA object (a lightweight software entity)
Because of this, you can see that the term endpoint is ambiguous in at least two ways. First, it isambiguous because it might refer to an address or to a software entity contactable at thataddress. Second, it is ambiguous in the granularity of what it refers to: a heavyweight versuslightweight software entity, or physical address versus logical address. It is useful to understandthat different people use the term endpoint in slightly different (and hence ambiguous) waysbecause Camel's usage of this term might be different to whatever meaning you had previouslyassociated with the term.Camel provides out-of-the-box support for endpoints implemented with many differentcommunication technologies. Here are some examples of the Camel-supported endpointtechnologies.
A JMS queue. A web service. A file. A file may sound like an unlikely type of endpoint, until you realize that in some
systems one application might write information to a file and, later, anotherapplication might read that file.
An FTP server. An email address. A client can send a message to an email address, and a server can
read an incoming message from a mail server. A POJO (plain old Java object).
In a Camel-based application, you create (Camel wrappers around) some endpoints andconnect these endpoints with routes, which I will discuss later in Section 4.8 ("Routes,RouteBuilders and Java DSL"). Camel defines a Java interface called Endpoint. Each Camel-supported endpoint has a class that implements this Endpoint interface. As I discussed inSection 3.3 ("Online Javadoc documentation"), Camel provides a separate Javadoc hierarchy foreach communications technology supported by Camel. Because of this, you will finddocumentation on, say, the JmsEndpoint class in the JMS Javadoc hierarchy, whiledocumentation for, say, the FtpEndpoint class is in the FTP Javadoc hierarchy.
CHAPTER 3 - GETTING STARTED WITH APACHE CAMEL 9
http://camel.apache.org/maven/current/camel-jms/apidocs/http://camel.apache.org/maven/current/camel-ftp/apidocs/
CamelContext
A CamelContext object represents the Camel runtime system. You typically have oneCamelContext object in an application. A typical application executes the following steps.
1. Create a CamelContext object.2. Add endpoints and possibly Components, which are discussed in Section 4.5
("Components") to the CamelContext object.3. Add routes to the CamelContext object to connect the endpoints.4. Invoke the start() operation on the CamelContext object. This starts Camel-
internal threads that are used to process the sending, receiving and processing ofmessages in the endpoints.
5. Eventually invoke the stop() operation on the CamelContext object. Doing thisgracefully stops all the endpoints and Camel-internal threads.
Note that the CamelContext.start() operation does not block indefinitely. Rather, itstarts threads internal to each Component and Endpoint and then start() returns.Conversely, CamelContext.stop() waits for all the threads internal to each Endpointand Component to terminate and then stop() returns.If you neglect to call CamelContext.start() in your application then messages will not beprocessed because internal threads will not have been created.If you neglect to call CamelContext.stop() before terminating your application then theapplication may terminate in an inconsistent state. If you neglect to callCamelContext.stop() in a JUnit test then the test may fail due to messages not havinghad a chance to be fully processed.
CamelTemplate
Camel used to have a class called CamelClient, but this was renamed to beCamelTemplate to be similar to a naming convention used in some other open-sourceprojects, such as the TransactionTemplate and JmsTemplate classes in Spring.The CamelTemplate class is a thin wrapper around the CamelContext class. It hasmethods that send a Message or Exchange both discussed in Section 4.6 ("Message andExchange")) to an Endpoint discussed in Section 4.1 ("Endpoint"). This provides a way toenter messages into source endpoints, so that the messages will move along routes discussedin Section 4.8 ("Routes, RouteBuilders and Java DSL") to destination endpoints.
The Meaning of URL, URI, URN and IRI
Some Camel methods take a parameter that is a URI string. Many people know that a URI is"something like a URL" but do not properly understand the relationship between URI and URL,or indeed its relationship with other acronyms such as IRI and URN.Most people are familiar with URLs (uniform resource locators), such as "http://...", "ftp://...","mailto:...". Put simply, a URL specifies the location of a resource.A URI (uniform resource identifier) is a URL or a URN. So, to fully understand what URI means,
10 CHAPTER 3 - GETTING STARTED WITH APACHE CAMEL
http://www.springframework.org/
you need to first understand what is a URN.URN is an acronym for uniform resource name. There are may "unique identifier" schemes in theworld, for example, ISBNs (globally unique for books), social security numbers (unique within acountry), customer numbers (unique within a company's customers database) and telephonenumbers. Each "unique identifier" scheme has its own notation. A URN is a wrapper fordifferent "unique identifier" schemes. The syntax of a URN is "urn::". A URN uniquely identifies a resource, such as a book, person or piece of equipment.By itself, a URN does not specify the location of the resource. Instead, it is assumed that aregistry provides a mapping from a resource's URN to its location. The URN specification doesnot state what form a registry takes, but it might be a database, a server application, a wall chartor anything else that is convenient. Some hypothetical examples of URNs are"urn:employee:08765245", "urn:customer:uk:3458:hul8" and"urn:foo:0000-0000-9E59-0000-5E-2". The ("employee", "customer" and "foo"in these examples) part of a URN implicitly defines how to parse and interpret the that follows it. An arbitrary URN is meaningless unless: (1) you know the semanticsimplied by the , and (2) you have access to the registry appropriate for the. A registry does not have to be public or globally accessible. For example,"urn:employee:08765245" might be meaningful only within a specific company.To date, URNs are not (yet) as popular as URLs. For this reason, URI is widely misused as asynonym for URL.IRI is an acronym for internationalized resource identifier. An IRI is simply an internationalizedversion of a URI. In particular, a URI can contain letters and digits in the US-ASCII characterset, while a IRI can contain those same letters and digits, and also European accented characters,Greek letters, Chinese ideograms and so on.
Components
Component is confusing terminology; EndpointFactory would have been more appropriate becausea Component is a factory for creating Endpoint instances. For example, if a Camel-basedapplication uses several JMS queues then the application will create one instance of theJmsComponent class (which implements the Component interface), and then the applicationinvokes the createEndpoint() operation on this JmsComponent object several times.Each invocation of JmsComponent.createEndpoint() creates an instance of theJmsEndpoint class (which implements the Endpoint interface). Actually, application-levelcode does not invoke Component.createEndpoint() directly. Instead, application-levelcode normally invokes CamelContext.getEndpoint(); internally, the CamelContextobject finds the desired Component object (as I will discuss shortly) and then invokescreateEndpoint() on it.Consider the following code.
myCamelContext.getEndpoint("pop3://[email protected]?password=myPassword");
CHAPTER 3 - GETTING STARTED WITH APACHE CAMEL 11
The parameter to getEndpoint() is a URI. The URI prefix (that is, the part before ":")specifies the name of a component. Internally, the CamelContext object maintains a mappingfrom names of components to Component objects. For the URI given in the above example,the CamelContext object would probably map the pop3 prefix to an instance of theMailComponent class. Then the CamelContext object invokescreateEndpoint("pop3://[email protected]?password=myPassword")on that MailComponent object. The createEndpoint() operation splits the URI into itscomponent parts and uses these parts to create and configure an Endpoint object.In the previous paragraph, I mentioned that a CamelContext object maintains a mappingfrom component names to Component objects. This raises the question of how this map ispopulated with named Component objects. There are two ways of populating the map. Thefirst way is for application-level code to invoke CamelContext.addComponent(StringcomponentName, Component component). The example below shows a singleMailComponent object being registered in the map under 3 different names.
Component mailComponent = new org.apache.camel.component.mail.MailComponent();myCamelContext.addComponent("pop3", mailComponent);myCamelContext.addComponent("imap", mailComponent);myCamelContext.addComponent("smtp", mailComponent);
The second (and preferred) way to populate the map of named Component objects in theCamelContext object is to let the CamelContext object perform lazy initialization. Thisapproach relies on developers following a convention when they write a class that implementsthe Component interface. I illustrate the convention by an example. Let's assume you write aclass called com.example.myproject.FooComponent and you want Camel toautomatically recognize this by the name "foo". To do this, you have to write a properties filecalled "META-INF/services/org/apache/camel/component/foo" (without a ".properties" fileextension) that has a single entry in it called class, the value of which is the fully-scoped nameof your class. This is shown below.
Listing 1.Listing 1. META-INF/services/org/apache/camel/component/fooMETA-INF/services/org/apache/camel/component/foo
class=com.example.myproject.FooComponent
If you want Camel to also recognize the class by the name "bar" then you write anotherproperties file in the same directory called "bar" that has the same contents. Once you havewritten the properties file(s), you create a jar file that contains thecom.example.myproject.FooComponent class and the properties file(s), and you addthis jar file to your CLASSPATH. Then, when application-level code invokescreateEndpoint("foo:...") on a CamelContext object, Camel will find the "foo""properties file on the CLASSPATH, get the value of the class property from that propertiesfile, and use reflection APIs to create an instance of the specified class.As I said in Section 4.1 ("Endpoint"), Camel provides out-of-the-box support for numerouscommunication technologies. The out-of-the-box support consists of classes that implement the
12 CHAPTER 3 - GETTING STARTED WITH APACHE CAMEL
Component interface plus properties files that enable a CamelContext object to populateits map of named Component objects.Earlier in this section I gave the following example of callingCamelContext.getEndpoint().
myCamelContext.getEndpoint("pop3://[email protected]?password=myPassword");
When I originally gave that example, I said that the parameter to getEndpoint() was a URI.I said that because the online Camel documentation and the Camel source code both claim theparameter is a URI. In reality, the parameter is restricted to being a URL. This is because whenCamel extracts the component name from the parameter, it looks for the first ":", which is asimplistic algorithm. To understand why, recall from Section 4.4 ("The Meaning of URL, URI,URN and IRI") that a URI can be a URL or a URN. Now consider the following calls togetEndpoint.
myCamelContext.getEndpoint("pop3:...");myCamelContext.getEndpoint("jms:...");myCamelContext.getEndpoint("urn:foo:...");myCamelContext.getEndpoint("urn:bar:...");
Camel identifies the components in the above example as "pop3", "jms", "urn" and "urn". Itwould be more useful if the latter components were identified as "urn:foo" and "urn:bar" or,alternatively, as "foo" and "bar" (that is, by skipping over the "urn:" prefix). So, in practice youmust identify an endpoint with a URL (a string of the form ":...") rather than with aURN (a string of the form "urn::..."). This lack of proper support for URNs means theyou should consider the parameter to getEndpoint() as being a URL rather than (asclaimed) a URI.
Message and Exchange
The Message interface provides an abstraction for a single message, such as a request, replyor exception message.There are concrete classes that implement the Message interface for each Camel-supportedcommunications technology. For example, the JmsMessage class provides a JMS-specificimplementation of the Message interface. The public API of the Message interface providesget- and set-style methods to access the message id, body and individual header fields of amessge.The Exchange interface provides an abstraction for an exchange of messages, that is, arequest message and its corresponding reply or exception message. In Camel terminology, therequest, reply and exception messages are called in, out and fault messages.There are concrete classes that implement the Exchange interface for each Camel-supportedcommunications technology. For example, the JmsExchange class provides a JMS-specificimplementation of the Exchange interface. The public API of the Exchange interface is quite
CHAPTER 3 - GETTING STARTED WITH APACHE CAMEL 13
limited. This is intentional, and it is expected that each class that implements this interface willprovide its own technology-specific operations.Application-level programmers rarely access the Exchange interface (or classes thatimplement it) directly. However, many classes in Camel are generic types that are instantiatedon (a class that implements) Exchange. Because of this, the Exchange interface appears alot in the generic signatures of classes and methods.
Processor
The Processor interface represents a class that processes a message. The signature of thisinterface is shown below.
Listing 1.Listing 1. ProcessorProcessor
package org.apache.camel;public interface Processor {
void process(Exchange exchange) throws Exception;}
Notice that the parameter to the process() method is an Exchange rather than aMessage. This provides flexibility. For example, an implementation of this method initiallymight call exchange.getIn() to get the input message and process it. If an error occursduring processing then the method can call exchange.setException().An application-level developer might implement the Processor interface with a class thatexecutes some business logic. However, there are many classes in the Camel library thatimplement the Processor interface in a way that provides support for a design pattern in theEIP book. For example, ChoiceProcessor implements the message router pattern, that is, ituses a cascading if-then-else statement to route a message from an input queue to one ofseveral output queues. Another example is the FilterProcessor class which discardsmessages that do not satisfy a stated predicate (that is, condition).
Routes, RouteBuilders and Java DSL
A route is the step-by-step movement of a Message from an input queue, through arbitrarytypes of decision making (such as filters and routers) to a destination queue (if any). Camelprovides two ways for an application developer to specify routes. One way is to specify routeinformation in an XML file. A discussion of that approach is outside the scope of this document.The other way is through what Camel calls a Java DSL (domain-specific language).
Introduction to Java DSL
For many people, the term "domain-specific language" implies a compiler or interpreter that canprocess an input file containing keywords and syntax specific to a particular domain. This is notthe approach taken by Camel. Camel documentation consistently uses the term "Java DSL"
14 CHAPTER 3 - GETTING STARTED WITH APACHE CAMEL
instead of "DSL", but this does not entirely avoid potential confusion. The Camel "Java DSL" is aclass library that can be used in a way that looks almost like a DSL, except that it has a bit ofJava syntactic baggage. You can see this in the example below. Comments afterwards explainsome of the constructs used in the example.
Listing 1.Listing 1. Example of Camel's "Java DSL"Example of Camel's "Java DSL"
RouteBuilder builder = new RouteBuilder() {public void configure() {
from("queue:a").filter(header("foo").isEqualTo("bar")).to("queue:b");from("queue:c").choice()
.when(header("foo").isEqualTo("bar")).to("queue:d")
.when(header("foo").isEqualTo("cheese")).to("queue:e")
.otherwise().to("queue:f");}
};CamelContext myCamelContext = new DefaultCamelContext();myCamelContext.addRoutes(builder);
The first line in the above example creates an object which is an instance of an anonymoussubclass of RouteBuilder with the specified configure() method.The CamelContext.addRoutes(RouterBuilder builder) method invokesbuilder.setContext(this) so the RouteBuilder object knows whichCamelContext object it is associated with and then invokes builder.configure().The body of configure() invokes methods such as from(), filter(), choice(),when(), isEqualTo(), otherwise() and to().The RouteBuilder.from(String uri) method invokes getEndpoint(uri) on theCamelContext associated with the RouteBuilder object to get the specified Endpointand then puts a FromBuilder "wrapper" around this Endpoint. TheFromBuilder.filter(Predicate predicate) method creates aFilterProcessor object for the Predicate (that is, condition) object built from theheader("foo").isEqualTo("bar") expression. In this way, these operationsincrementally build up a Route object (with a RouteBuilder wrapper around it) and add itto the CamelContext object associated with the RouteBuilder.
Critique of Java DSL
The online Camel documentation compares Java DSL favourably against the alternative ofconfiguring routes and endpoints in a XML-based Spring configuration file. In particular, JavaDSL is less verbose than its XML counterpart. In addition, many integrated developmentenvironments (IDEs) provide an auto-completion feature in their editors. This auto-completionfeature works with Java DSL, thereby making it easier for developers to write Java DSL.However, there is another option that the Camel documentation neglects to consider: that ofwriting a parser that can process DSL stored in, say, an external file. Currently, Camel does notprovide such a DSL parser, and I do not know if it is on the "to do" list of the Camel
CHAPTER 3 - GETTING STARTED WITH APACHE CAMEL 15
maintainers. I think that a DSL parser would offer a significant benefit over the current JavaDSL. In particular, the DSL would have a syntactic definition that could be expressed in arelatively short BNF form. The effort required by a Camel user to learn how to use DSL byreading this BNF would almost certainly be significantly less than the effort currently requiredto study the API of the RouterBuilder classes.
Continue Learning about Camel
Return to the main Getting Started page for additional introductory reference information.
16 CHAPTER 3 - GETTING STARTED WITH APACHE CAMEL
http://camel.apache.org/getting-started.html
C H A P T E R 4
Architecture
Camel uses a Java based Routing Domain Specific Language (DSL) or an Xml Configuration toconfigure routing and mediation rules which are added to a CamelContext to implement thevarious Enterprise Integration Patterns.
At a high level Camel consists of a CamelContext which contains a collection of Componentinstances. A Component is essentially a factory of Endpoint instances. You can explicitlyconfigure Component instances in Java code or an IoC container like Spring or Guice, or theycan be auto-discovered using URIs.
An Endpoint acts rather like a URI or URL in a web application or a Destination in a JMSsystem; you can communicate with an endpoint; either sending messages to it or consumingmessages from it. You can then create a Producer or Consumer on an Endpoint to exchangemessages with it.
The DSL makes heavy use of pluggable Languages to create an Expression or Predicate tomake a truly powerful DSL which is extensible to the most suitable language depending on yourneeds. The following languages are supported
Bean Language for using Java for expressions Constant the unified EL from JSP and JSF Header JXPath Mvel OGNL Ref Language Property Scripting Languages such as
BeanShell JavaScript Groovy Python PHP Ruby
Simple File Language
Spring Expression Language SQL
CHAPTER 4 - ARCHITECTURE 17
http://camel.apache.org/dsl.htmlhttp://camel.apache.org/xml-configuration.htmlhttp://camel.apache.org/routes.htmlhttp://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/CamelContext.htmlhttp://camel.apache.org/enterprise-integration-patterns.htmlhttp://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/CamelContext.htmlhttp://camel.apache.org/component.htmlhttp://camel.apache.org/component.htmlhttp://camel.apache.org/endpoint.htmlhttp://camel.apache.org/component.htmlhttp://camel.apache.org/uris.htmlhttp://camel.apache.org/endpoint.htmlhttp://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Producer.htmlhttp://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Consumer.htmlhttp://camel.apache.org/endpoint.htmlhttp://camel.apache.org/dsl.htmlhttp://camel.apache.org/languages.htmlhttp://camel.apache.org/expression.htmlhttp://camel.apache.org/predicate.htmlhttp://camel.apache.org/bean-language.htmlhttp://camel.apache.org/constant.htmlhttp://camel.apache.org/el.htmlhttp://camel.apache.org/header.htmlhttp://camel.apache.org/jxpath.htmlhttp://camel.apache.org/mvel.htmlhttp://camel.apache.org/ognl.htmlhttp://camel.apache.org/ref-language.htmlhttp://camel.apache.org/property.htmlhttp://camel.apache.org/scripting-languages.htmlhttp://camel.apache.org/beanshell.htmlhttp://camel.apache.org/javascript.htmlhttp://camel.apache.org/groovy.htmlhttp://camel.apache.org/python.htmlhttp://camel.apache.org/php.htmlhttp://camel.apache.org/ruby.htmlhttp://camel.apache.org/simple.htmlhttp://camel.apache.org/file-language.htmlhttp://camel.apache.org/spel.htmlhttp://camel.apache.org/sql.html
Tokenizer XPath XQuery VTD-XML
Most of these languages is also supported used as Annotation Based Expression Language.
For a full details of the individual languages see the Language Appendix
URIS
Camel makes extensive use of URIs to allow you to refer to endpoints which are lazily createdby a Component if you refer to them within Routes.
Current Supported URIs
Component / ArtifactId / URI Description
AHC / camel-ahc
ahc:hostname:[port]To call external HTTP servicesusing Async Http Client
AMQP / camel-amqp
amqp:[topic:]destinationNameFor Messaging with AMQPprotocol
APNS / camel-apns
apns:notify[?options]For sending notifications to AppleiOS devices
Atom / camel-atom
atom:uri
Working with Apache Abdera foratom integration, such asconsuming an atom feed.
Avro / camel-avro
avro:http://hostname[:port][?options]Working with Apache Avro fordata serialization.
18 CHAPTER 4 - ARCHITECTURE
http://camel.apache.org/tokenizer.htmlhttp://camel.apache.org/xpath.htmlhttp://camel.apache.org/xquery.htmlhttp://camel.apache.org/vtd-xml.htmlhttp://camel.apache.org/annotation-based-expression-language.htmlhttp://camel.apache.org/book-languages-appendix.htmlhttp://camel.apache.org/component.htmlhttp://camel.apache.org/routes.htmlhttp://camel.apache.org/ahc.htmlhttp://github.com/sonatype/async-http-clienthttp://camel.apache.org/amqp.htmlhttp://www.amqp.org/http://www.amqp.org/http://camel.apache.org/apns.htmlhttp://camel.apache.org/atom.htmlhttp://incubator.apache.org/abdera/http://camel.apache.org/avro.htmlhttp://avro.apache.org/
importantMake sure to read How do I configure endpoints to learn more about configuringendpoints. For example how to refer to beans in the Registry or how to use rawvalues for password options, and using property placeholders etc.
AWS-CW / camel-aws
aws-cw://namespace[?options]For working with Amazon'sCloudWatch (CW).
AWS-DDB / camel-aws
aws-ddb://tableName[?options]For working with Amazon'sDynamoDB (DDB).
AWS-SDB / camel-aws
aws-sdb://domainName[?options]For working with Amazon'sSimpleDB (SDB).
AWS-SES / camel-aws
aws-ses://from[?options]For working with Amazon'sSimple Email Service (SES).
AWS-SNS / camel-aws
aws-sns://topicname[?options]For Messaging with Amazon'sSimple Notification Service (SNS).
AWS-SQS / camel-aws
aws-sqs://queuename[?options]For Messaging with Amazon'sSimple Queue Service (SQS).
AWS-S3 / camel-aws
aws-s3://bucketname[?options]For working with Amazon'sSimple Storage Service (S3).
CHAPTER 4 - ARCHITECTURE 19
http://camel.apache.org/aws-cw.htmlhttp://camel.apache.org/aws.htmlhttp://aws.amazon.com/cloudwatch/http://aws.amazon.com/cloudwatch/http://camel.apache.org/aws-ddb.htmlhttp://camel.apache.org/aws.htmlhttp://aws.amazon.com/dynamodb/http://aws.amazon.com/dynamodb/http://camel.apache.org/aws-sdb.htmlhttp://camel.apache.org/aws.htmlhttp://aws.amazon.com/simpledb/http://aws.amazon.com/simpledb/http://camel.apache.org/aws-ses.htmlhttp://camel.apache.org/aws.htmlhttp://aws.amazon.com/ses/http://aws.amazon.com/ses/http://camel.apache.org/aws-sns.htmlhttp://camel.apache.org/aws.htmlhttp://aws.amazon.com/sns/http://aws.amazon.com/sns/http://camel.apache.org/aws-sqs.htmlhttp://camel.apache.org/aws.htmlhttp://aws.amazon.com/sqs/http://aws.amazon.com/sqs/http://camel.apache.org/aws-s3.htmlhttp://camel.apache.org/aws.htmlhttp://aws.amazon.com/s3/http://aws.amazon.com/s3/http://camel.apache.org/how-do-i-configure-endpoints.htmlhttp://camel.apache.org/registry.htmlhttp://camel.apache.org/using-propertyplaceholder.html
Bean / camel-core
bean:beanName[?method=someMethod]
Uses the Bean Binding to bindmessage exchanges to beans in theRegistry. Is also used for exposingand invoking POJO (Plain Old JavaObjects).
Bean Validation / camel-bean-validator
bean-validator:something
Validates the payload of a messageusing the Java Validation API (JSR303 and JAXP Validation) and itsreference implementationHibernate Validator
Browse / camel-core
browse:someName
Provides a simpleBrowsableEndpoint which can beuseful for testing, visualisationtools or debugging. The exchangessent to the endpoint are allavailable to be browsed.
Cache / camel-cache
cache://cachename[?options]
The cache component facilitatescreation of caching endpoints andprocessors using EHCache as thecache implementation.
Class / camel-core
class:className[?method=someMethod]
Uses the Bean Binding to bindmessage exchanges to beans in theRegistry. Is also used for exposingand invoking POJO (Plain Old JavaObjects).
CMIS / camel-cmis
cmis://cmisServerUrl[?options]
Uses the Apache Chemistry clientAPI to interface with CMISsupporting CMS
Cometd / camel-cometd
cometd://host:port/channelname
Used to deliver messages usingthe jetty cometd implementationof the bayeux protocol
20 CHAPTER 4 - ARCHITECTURE
http://camel.apache.org/bean.htmlhttp://camel.apache.org/bean-binding.htmlhttp://camel.apache.org/registry.htmlhttp://camel.apache.org/bean-validation.htmlhttp://jcp.org/en/jsr/detail?id=303http://jcp.org/en/jsr/detail?id=303http://docs.jboss.org/hibernate/stable/validator/reference/en/html_single/http://camel.apache.org/browse.htmlhttp://camel.apache.org/browsableendpoint.htmlhttp://camel.apache.org/cache.htmlhttp://ehcache.org/http://camel.apache.org/class.htmlhttp://camel.apache.org/bean-binding.htmlhttp://camel.apache.org/registry.htmlhttp://camel.apache.org/cmis.htmlhttp://chemistry.apache.org/java/opencmis.htmlhttp://camel.apache.org/cometd.htmlhttp://docs.codehaus.org/display/JETTY/Cometd+(aka+Bayeux)http://svn.xantus.org/shortbus/trunk/bayeux/bayeux.html
Context / camel-context
context:camelContextId:localEndpointName
Used to refer to endpoints withina separate CamelContext toprovide a simple black boxcomposition approach so thatroutes can be combined into aCamelContext and then used as ablack box component inside otherroutes in other CamelContexts
ControlBus / camel-core
controlbus:command[?options]
ControlBus EIP that allows tosend messages to Endpoints formanaging and monitoring yourCamel applications.
CouchDB / camel-couchdb
couchdb:http://hostname[:port]/database[?options]To integrate with ApacheCouchDB.
Crypto (Digital Signatures) / camel-crypto
crypto:sign:name[?options]crypto:verify:name[?options]
Used to sign and verify exchangesusing the Signature Service of theJava Cryptographic Extension.
CXF / camel-cxf
cxf:address[?serviceClass=...]Working with Apache CXF forweb services integration
CXF Bean / camel-cxf
cxf:bean name
Proceess the exchange using aJAX WS or JAX RS annotatedbean from the registry. Requiresless configuration than the aboveCXF Component
CXFRS / camel-cxf
cxfrs:address[?resourcesClasses=...]Working with Apache CXF forREST services integration
CHAPTER 4 - ARCHITECTURE 21
http://camel.apache.org/context.htmlhttp://camel.apache.org/context.htmlhttp://camel.apache.org/context.htmlhttp://camel.apache.org/controlbus-component.htmlhttp://camel.apache.org/controlbus.htmlhttp://camel.apache.org/endpoint.htmlhttp://camel.apache.org/couchdb.htmlhttp://couchdb.apache.org/http://couchdb.apache.org/http://camel.apache.org/crypto-digital-signatures.htmlhttp://camel.apache.org/cxf.htmlhttp://apache.org/cxf/http://camel.apache.org/cxf-bean-component.htmlhttp://camel.apache.org/cxfrs.htmlhttp://apache.org/cxf/
DataSet / camel-core
dataset:name
For load & soak testing theDataSet provides a way to createhuge numbers of messages forsending to Components orasserting that they are consumedcorrectly
Direct / camel-core
direct:name
Synchronous call to anotherendpoint from sameCamelContext.
Direct-VM / camel-core
direct-vm:name
Synchronous call to anotherendpoint in anotherCamelContext running in thesame JVM.
DNS / camel-dns
dns:operation
To lookup domain informationand run DNS queries usingDNSJava
EJB / camel-ejb
ejb:ejbName[?method=someMethod]
Uses the Bean Binding to bindmessage exchanges to EJBs. Itworks like the Bean componentbut just for accessing EJBs.Supports EJB 3.0 onwards.
ElasticSearch / camel-elasticsearch
elasticsearch://clusterNameFor interfacing with anElasticSearch server.
Event / camel-spring
event://defaultspring-event://default
Working with SpringApplicationEvents
EventAdmin / camel-eventadmin
eventadmin:topicReceiving OSGi EventAdminevents
22 CHAPTER 4 - ARCHITECTURE
http://camel.apache.org/dataset.htmlhttp://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/component/dataset/DataSet.htmlhttp://camel.apache.org/components.htmlhttp://camel.apache.org/direct.htmlhttp://camel.apache.org/direct-vm.htmlhttp://camel.apache.org/dns.htmlhttp://www.xbill.org/dnsjava/http://camel.apache.org/ejb.htmlhttp://camel.apache.org/bean-binding.htmlhttp://camel.apache.org/bean.htmlhttp://camel.apache.org/elasticsearch.htmlhttp://elasticsearch.orghttp://camel.apache.org/event.htmlhttp://camel.apache.org/eventadmin.html
Exec / camel-exec
exec://executable[?options] For executing system commands
File / camel-core
file://nameOfFileOrDirectorySending messages to a file orpolling a file or directory.
Flatpack / camel-flatpack
flatpack:[fixed|delim]:configFile
Processing fixed width ordelimited files or messages usingthe FlatPack library
FOP / camel-fop
fop:outputFormat
Renders the message intodifferent output formats usingApache FOP
FreeMarker / camel-freemarker
freemarker:someTemplateResourceGenerates a response using aFreeMarker template
FTP / camel-ftp
ftp://host[:port]/fileNameSending and receiving files overFTP.
FTPS / camel-ftp
ftps://host[:port]/fileNameSending and receiving files overFTP Secure (TLS and SSL).
GAuth / camel-gae
gauth://name[?options]
Used by web applications toimplement an OAuth consumer.See also Camel Components forGoogle App Engine.
GHttp / camel-gae
ghttp://hostname[:port][/path][?options]ghttp:///path[?options]
Provides connectivity to the URLfetch service of Google AppEngine but can also be used toreceive messages from servlets.See also Camel Components forGoogle App Engine.
CHAPTER 4 - ARCHITECTURE 23
http://camel.apache.org/exec.htmlhttp://camel.apache.org/file2.htmlhttp://camel.apache.org/flatpack.htmlhttp://flatpack.sourceforge.nethttp://camel.apache.org/fop.htmlhttp://xmlgraphics.apache.org/fop/index.htmlhttp://camel.apache.org/freemarker.htmlhttp://freemarker.org/http://camel.apache.org/ftp2.htmlhttp://camel.apache.org/ftp2.htmlhttp://camel.apache.org/gauth.htmlhttp://camel.apache.org/gae.htmlhttp://code.google.com/apis/accounts/docs/OAuth.htmlhttp://camel.apache.org/gae.htmlhttp://camel.apache.org/gae.htmlhttp://camel.apache.org/ghttp.htmlhttp://camel.apache.org/gae.htmlhttp://code.google.com/appengine/docs/java/urlfetch/http://code.google.com/appengine/docs/java/urlfetch/http://camel.apache.org/gae.htmlhttp://camel.apache.org/gae.html
GLogin / camel-gae
glogin://hostname[:port][?options]
Used by Camel applicationsoutside Google App Engine (GAE)for programmatic login to GAEapplications. See also CamelComponents for Google AppEngine.
GTask / camel-gae
gtask://queue-name
Supports asynchronous messageprocessing on Google App Engineby using the task queueing serviceas message queue. See also CamelComponents for Google AppEngine.
GMail / camel-gae
gmail://[email protected][?options]gmail://[email protected][?options]
Supports sending of emails via themail service of Google AppEngine. See also CamelComponents for Google AppEngine.
Google Guava EventBus / camel-guava-eventbus
guava-eventbus:busName[?eventClass=className]
The Google Guava EventBusallows publish-subscribe-stylecommunication betweencomponents without requiring thecomponents to explicitly registerwith one another (and thus beaware of each other). Thiscomponent provides integrationbridge between Camel andGoogle Guava EventBusinfrastructure.
Hazelcast / camel-hazelcast
hazelcast://[type]:cachename[?options]
Hazelcast is a data grid entirelyimplemented in Java (single jar).This component supports map,multimap, seda, queue, set, atomicnumber and simple clustersupport.
HBase / camel-hbase
hbase://table[?options]For reading/writing from/to anHBase store (Hadoop database)
24 CHAPTER 4 - ARCHITECTURE
http://camel.apache.org/glogin.htmlhttp://camel.apache.org/gae.htmlhttp://camel.apache.org/gae.htmlhttp://camel.apache.org/gae.htmlhttp://camel.apache.org/gae.htmlhttp://camel.apache.org/gtask.htmlhttp://camel.apache.org/gae.htmlhttp://code.google.com/appengine/docs/java/taskqueue/http://camel.apache.org/gae.htmlhttp://camel.apache.org/gae.htmlhttp://camel.apache.org/gae.htmlhttp://camel.apache.org/gmail.htmlhttp://camel.apache.org/gae.htmlhttp://code.google.com/appengine/docs/java/mail/http://camel.apache.org/gae.htmlhttp://camel.apache.org/gae.htmlhttp://camel.apache.org/gae.htmlhttp://camel.apache.org/guava-eventbus.htmlhttp://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/eventbus/package-summary.htmlhttp://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/eventbus/package-summary.htmlhttp://camel.apache.org/hazelcast-component.htmlhttp://camel.apache.org/hazelcast-component.htmlhttp://www.hazelcast.comhttp://camel.apache.org/hbase.htmlhttp://hadoop.apache.org/hbase/
HDFS / camel-hdfs
hdfs://path[?options]For reading/writing from/to anHDFS filesystem
HL7 / camel-hl7
mina:tcp://hostname[:port]
For working with the HL7 MLLPprotocol and the HL7 model usingthe HAPI library
HTTP / camel-http
http://hostname[:port]
For calling out to external HTTPservers using Apache HTTP Client3.x
HTTP4 / camel-http4
http4://hostname[:port]
For calling out to external HTTPservers using Apache HTTP Client4.x
iBATIS / camel-ibatis
ibatis://statementName
Performs a query, poll, insert,update or delete in a relationaldatabase using Apache iBATIS
IMAP / camel-mail
imap://hostname[:port] Receiving email using IMAP
IRC / camel-irc
irc:host[:port]/#room For IRC communication
JavaSpace / camel-javaspace
javaspace:jini://host?spaceName=mySpace?...Sending and receiving messagesthrough JavaSpace
JBI / servicemix-camel
jbi:serviceNameFor JBI integration such asworking with Apache ServiceMix
CHAPTER 4 - ARCHITECTURE 25
http://camel.apache.org/hdfs.htmlhttp://hadoop.apache.org/hdfs/http://camel.apache.org/hl7.htmlhttp://hl7api.sourceforge.nethttp://camel.apache.org/http.htmlhttp://camel.apache.org/http4.htmlhttp://camel.apache.org/ibatis.htmlhttp://ibatis.apache.org/http://camel.apache.org/mail.htmlhttp://en.wikipedia.org/wiki/Internet_Message_Access_Protocolhttp://camel.apache.org/irc.htmlhttp://camel.apache.org/javaspace.htmlhttp://java.sun.com/products/jini/2.1/doc/specs/html/js-spec.htmlhttp://camel.apache.org/jbi.htmlhttp://servicemix.apache.org
jclouds / jclouds
jclouds:[blobstore|computservice]:provider
For interacting with cloudcompute & blobstore service viajclouds
JCR / camel-jcr
jcr://user:password@repository/path/to/node
Storing a message in a JCRcompliant repository like ApacheJackrabbit
JDBC / camel-jdbc
jdbc:dataSourceName?optionsFor performing JDBC queries andoperations
Jetty / camel-jetty
jetty:url For exposing services over HTTP
JMS / camel-jms
jms:[topic:]destinationName Working with JMS providers
JMX / camel-jmx
jmx://platform?optionsFor working with JMX notificationlisteners
JPA / camel-jpa
jpa://entityName
For using a database as a queue viathe JPA specification for workingwith OpenJPA, Hibernate orTopLink
Jsch / camel-jsch
scp://localhost/destination Support for the scp protocol
JT/400 / camel-jt400
jt400://user:pwd@system/
For integrating with data queueson an AS/400 (aka System i, IBM i,i5, ...) system
26 CHAPTER 4 - ARCHITECTURE
http://camel.apache.org/jclouds.htmlhttp://www.jclouds.orghttp://camel.apache.org/jcr.htmlhttp://jackrabbit.apache.orghttp://jackrabbit.apache.orghttp://camel.apache.org/jdbc.htmlhttp://camel.apache.org/jetty.htmlhttp://camel.apache.org/jms.htmlhttp://camel.apache.org/jmx.htmlhttp://camel.apache.org/jpa.htmlhttp://openjpa.apache.org/http://www.hibernate.org/http://camel.apache.org/jsch.htmlhttp://camel.apache.org/jt400.html
Kestrel / camel-kestrel
kestrel://[addresslist/]queuename[?options]For producing to or consumingfrom Kestrel queues
Krati / camel-krati
krati://[path to datastore/][?options]For producing to or consuming toKrati datastores
Language / camel-core
language://languageName[:script][?options] Executes Languages scripts
LDAP / camel-ldap
ldap:host[:port]?base=...[&scope=]
Performing searches on LDAPservers ( must be one ofobject|onelevel|subtree)
Log / camel-core
log:loggingCategory[?level=ERROR]
Uses Jakarta Commons Logging tolog the message exchange to someunderlying logging system likelog4j
Lucene / camel-lucene
lucene:searcherName:insert[?analyzer=]lucene:searcherName:query[?analyzer=]
Uses Apache Lucene to performJava-based indexing and full textbased searches using advancedanalysis/tokenization capabilities
Mail / camel-mail
mail://user-info@host:port Sending and receiving email
MINA / camel-mina
[tcp|udp|vm]:host[:port] Working with Apache MINA
Mock / camel-core
mock:nameFor testing routes and mediationrules using mocks
CHAPTER 4 - ARCHITECTURE 27
http://camel.apache.org/kestrel.htmlhttps://github.com/robey/kestrelhttp://camel.apache.org/krati.htmlhttp://sna-projects.com/krati/http://camel.apache.org/language.htmlhttp://camel.apache.org/languages.htmlhttp://camel.apache.org/ldap.htmlhttp://camel.apache.org/log.htmlhttp://camel.apache.org/lucene.htmlhttp://camel.apache.org/mail.htmlhttp://camel.apache.org/mina.htmlhttp://mina.apache.org/http://camel.apache.org/mock.html
MongoDB / camel-mongodb
mongodb:connection?options
Interacts with MongoDBdatabases and collections. Offersproducer endpoints to performCRUD-style operations and moreagainst databases and collections,as well as consumer endpoints tolisten on collections and dispatchobjects to Camel routes
MQTT / camel-mqtt
mqtt:name
Component for communicatingwith MQTT M2M messagebrokers
MSV / camel-msv
msv:someLocalOrRemoteResourceValidates the payload of a messageusing the MSV Library
MyBatis / camel-mybatis
mybatis://statementName
Performs a query, poll, insert,update or delete in a relationaldatabase using MyBatis
Nagios / camel-nagios
nagios://host[:port]?optionsSending passive checks to Nagiosusing JSendNSCA
Netty / camel-netty
netty:tcp//host[:port]?optionsnetty:udp//host[:port]?options
Working with TCP and UDPprotocols using Java NIO basedcapabilities offered by the JBossNetty community project
Pax-Logging / camel-paxlogging
paxlogging:appenderReceiving Pax-Logging events inOSGi
POP / camel-mail
pop3://user-info@host:portReceiving email using POP3 andJavaMail
28 CHAPTER 4 - ARCHITECTURE
http://camel.apache.org/mongodb.htmlhttp://www.mongodb.org/http://camel.apache.org/mqtt.htmlhttp://mqtt.orghttp://camel.apache.org/msv.htmlhttps://msv.dev.java.net/http://camel.apache.org/mybatis.htmlhttp://mybatis.org/http://camel.apache.org/nagios.htmlhttp://www.nagios.org/http://code.google.com/p/jsendnsca/http://camel.apache.org/netty.htmlhttp://www.jboss.org/nettyhttp://www.jboss.org/nettyhttp://camel.apache.org/pax-logging.htmlhttp://camel.apache.org/mail.html
Printer / camel-printer
lpr://host:port/path/to/printer[?options]
The printer component facilitatescreation of printer endpoints tolocal, remote and wirelessprinters. The endpoints providethe ability to print camel directedpayloads when utilized on camelroutes.
Properties / camel-core
properties://key[?options]
The properties componentfacilitates using propertyplaceholders directly in endpointuri definitions.
Quartz / camel-quartz
quartz://groupName/timerName
Provides a scheduled delivery ofmessages using the Quartzscheduler
Quickfix / camel-quickfix
quickfix-server:config filequickfix-client:config-file
Implementation of the QuickFixfor Java engine which allow tosend/receive FIX messages
Ref / camel-core
ref:nameComponent for lookup of existingendpoints bound in the Registry.
Restlet / camel-restlet
restlet:restletUrl[?options]
Component for consuming andproducing Restful resources usingRestlet
RMI / camel-rmi
rmi://host[:port] Working with RMI
RNC / camel-jing
rnc:/relativeOrAbsoluteUriValidates the payload of a messageusing RelaxNG Compact Syntax
CHAPTER 4 - ARCHITECTURE 29
http://camel.apache.org/printer.htmlhttp://camel.apache.org/properties.htmlhttp://camel.apache.org/quartz.htmlhttp://www.quartz-scheduler.org/http://www.quartz-scheduler.org/http://camel.apache.org/quickfix.htmlhttp://www.fixprotocol.orghttp://camel.apache.org/ref.htmlhttp://camel.apache.org/registry.htmlhttp://camel.apache.org/restlet.htmlhttp://www.restlet.orghttp://camel.apache.org/rmi.htmlhttp://camel.apache.org/jing.htmlhttp://relaxng.org/compact-tutorial-20030326.html
RNG / camel-jing
rng:/relativeOrAbsoluteUriValidates the payload of a messageusing RelaxNG
Routebox / camel-routebox
routebox:routeboxName[?options]
Facilitates the creation ofspecialized endpoints that offerencapsulation and a strategy/mapbased indirection service to acollection of camel routes hostedin an automatically created oruser injected camel context
RSS / camel-rss
rss:uri
Working with ROME for RSSintegration, such as consuming anRSS feed.
SEDA / camel-core
seda:name
Asynchronous call to anotherendpoint in the same CamelContext
SERVLET / camel-servlet
servlet:uri
For exposing services over HTTPthrough the servlet which isdeployed into the Web container.
SFTP / camel-ftp
sftp://host[:port]/fileNameSending and receiving files overSFTP (FTP over SSH).
Sip / camel-sip
sip://user@host[:port]?[options]sips://user@host[:port]?[options]
Publish/Subscribe communicationcapability using the Telecom SIPprotocol. RFC3903 - SessionInitiation Protocol (SIP) Extensionfor Event
SJMS / camel-sjms
sjms:[topic:]destinationName?[options]A ground up implementation of aJMS client
30 CHAPTER 4 - ARCHITECTURE
http://camel.apache.org/jing.htmlhttp://relaxng.org/http://camel.apache.org/routebox.htmlhttp://camel.apache.org/rss.htmlhttp://rometools.org/http://camel.apache.org/seda.htmlhttp://camel.apache.org/servlet.htmlhttp://camel.apache.org/ftp2.htmlhttp://camel.apache.org/sip.htmlhttp://www.ietf.org/rfc/rfc3903.txthttp://www.ietf.org/rfc/rfc3903.txthttp://www.ietf.org/rfc/rfc3903.txthttp://camel.apache.org/sjms.html
SMTP / camel-mail
smtp://user-info@host[:port]Sending email using SMTP andJavaMail
SMPP / camel-smpp
smpp://user-info@host[:port]?options
To send and receive SMS usingShort Messaging Service Centerusing the JSMPP library
SNMP / camel-snmp
snmp://host[:port]?options
Polling OID values and receivingtraps using SNMP via SNMP4Jlibrary
Solr / camel-solr
solr://host[:port]/solr?[options]
Uses the Solrj client API tointerface with an Apache LuceneSolr server
SpringBatch / camel-spring-batch
spring-batch:job[?options] To bridge Camel and Spring Batch
SpringIntegration / camel-spring-integration
spring-integration:defaultChannelNameThe bridge component of Cameland Spring Integration
Spring LDAP / camel-spring-ldap
spring-ldap:spring-ldap-template-bean?options Camel wrapper for Spring LDAP
Spring Redis / camel-spring-redis
spring-redis:restletUrl[?options]
Component for consuming andproducing from Redis key-valuestore Redis
Spring Web Services / camel-spring-ws
spring-ws:[mapping-type:]address[?options]
Client-side support for accessingweb services, and server-sidesupport for creating your owncontract-first web services usingSpring Web Services
CHAPTER 4 - ARCHITECTURE 31
http://camel.apache.org/mail.htmlhttp://camel.apache.org/smpp.htmlhttp://code.google.com/p/jsmpp/http://camel.apache.org/snmp.htmlhttp://snmp4j.comhttp://camel.apache.org/solr.htmlhttp://wiki.apache.org/solr/Solrjhttp://lucene.apache.org/solr/http://lucene.apache.org/solr/http://camel.apache.org/springbatch.htmlhttp://www.springsource.org/spring-batchhttp://camel.apache.org/springintegration.htmlhttp://www.springframework.org/spring-integrationhttp://camel.apache.org/spring-ldap.htmlhttp://www.springsource.org/ldaphttp://camel.apache.org/spring-redis.htmlhttp://redis.iohttp://camel.apache.org/spring-web-services.htmlhttp://static.springsource.org/spring-ws/sites/1.5/
SQL / camel-sql
sql:select * from table where id=#Performing SQL queries usingJDBC
SSH component / camel-ssh
ssh:[username[:password]@]host[:port][?options]For sending commands to a SSHserver
StAX / camel-stax
stax:contentHandlerClassNameProcess messages through a SAXContentHandler.
Stream / camel-stream
stream:[in|out|err|file]
Read or write to an input/output/error/file stream rather like unixpipes
StringTemplate / camel-stringtemplate
string-template:someTemplateResourceGenerates a response using aString Template
Stub / camel-core
stub:someOtherCamelUri
Allows you to stub out somephysical middleware endpoint foreasier testing or debugging
TCP / camel-mina
mina:tcp://host:portWorking with TCP protocolsusing Apache MINA
Test / camel-spring
test:expectedMessagesEndpointUri
Creates a Mock endpoint whichexpects to receive all the messagebodies that could be polled fromthe given underlying endpoint
Timer / camel-core
timer://name A timer endpoint
32 CHAPTER 4 - ARCHITECTURE
http://camel.apache.org/sql-component.htmlhttp://camel.apache.org/ssh.htmlhttp://camel.apache.org/stax.htmlhttp://download.oracle.com/javase/6/docs/api/org/xml/sax/ContentHandler.htmlhttp://camel.apache.org/stream.htmlhttp://camel.apache.org/stringtemplate.htmlhttp://www.stringtemplate.org/http://camel.apache.org/stub.htmlhttp://camel.apache.org/stub.htmlhttp://camel.apache.org/stub.htmlhttp://camel.apache.org/mina.htmlhttp://mina.apache.org/http://camel.apache.org/test.htmlhttp://camel.apache.org/mock.htmlhttp://camel.apache.org/timer.html
Twitter / camel-twitter
twitter://[endpoint]?[options] A twitter endpoint
UDP / camel-mina
mina:udp://host:portWorking with UDP protocolsusing Apache MINA
Validation / camel-core (camel-spring for Camel 2.8 orolder)
validation:someLocalOrRemoteResource
Validates the payload of a messageusing XML Schema and JAXPValidation
Velocity / camel-velocity
velocity:someTemplateResourceGenerates a response using anApache Velocity template
VM / camel-core
vm:nameAsynchronous call to anotherendpoint in the same JVM
Websocket / camel-websocket
websocket://host:port/pathCommunicating with Websocketclients
XMPP / camel-xmpp
xmpp://host:port/room Working with XMPP and Jabber
XQuery / camel-saxon
xquery:someXQueryResourceGenerates a response using anXQuery template
XSLT / camel-core (camel-spring for Camel 2.8 orolder)
xslt:someTemplateResource
Generates a response using anXSLT template
CHAPTER 4 - ARCHITECTURE 33
http://camel.apache.org/twitter.htmlhttp://camel.apache.org/mina.htmlhttp://mina.apache.org/http://camel.apache.org/validation.htmlhttp://www.w3.org/XML/Schemahttp://camel.apache.org/velocity.htmlhttp://velocity.apache.org/http://camel.apache.org/vm.htmlhttp://camel.apache.org/websocket.htmlhttp://wiki.eclipse.org/Jetty/Feature/WebSocketshttp://camel.apache.org/xmpp.htmlhttp://camel.apache.org/xquery-endpoint.htmlhttp://camel.apache.org/xquery.htmlhttp://camel.apache.org/xslt.htmlhttp://www.w3.org/TR/xslt
Zookeeper / camel-zookeeper
zookeeper://host:port/pathWorking with ZooKeepercluster(s)
URI's for external components
Other projects and companies have also created Camel components to integrate additionalfunctionality into Camel. These components may be provided under licenses that are notcompatible with the Apache License, use libraries that are not compatible, etc... Thesecomponents are not supported by the Camel team, but we provide links here to help users findthe additional functionality.
Component / ArtifactId / URI License Description
ActiveMQ / activemq-camel
activemq:[topic:]destinationName Apache
For JMSMessaging withApacheActiveMQ
ActiveMQ Journal / activemq-core
activemq.journal:directory-on-filesystem Apache
Uses ActiveMQ'sfast diskjournalingimplementationto store messagebodies in arolling log file
Activiti / activiti-camel
activiti:camelProcess:serviceTask Apache
For workingwith Activiti, alight-weightworkflow andBusiness ProcessManagement(BPM) platformwhich supportsBPMN 2
Db4o / camel-db4o in camel-extra
db4o://className GPL
For using a db4odatastore as aqueue via thedb4o library
34 CHAPTER 4 - ARCHITECTURE
http://camel.apache.org/zookeeper.htmlhttp://hadoop.apache.org/zookeeper/http://camel.apache.org/activemq.htmlhttp://activemq.apache.org/http://activemq.apache.org/http://camel.apache.org/activemq-journal.htmlhttp://www.activiti.org/http://www.activiti.org/http://camel.apache.org/db4o.htmlhttp://code.google.com/p/camel-extra/http://www.db4o.com/
Esper / camel-esper in camel-extra
esper:name GPL
Working withthe Esper Libraryfor Event StreamProcessing
Hibernate / camel-hibernate in camel-extra
hibernate://entityName GPL
For using adatabase as aqueue via theHibernate library
JGroups / camel-jgroups in camel-extra
jgroups://clusterName LGPL
The jgroups:componentprovidesexchange ofmessagesbetween Camelinfrastructureand JGroupsclusters.
NMR / servicemix-nmr
nmr://serviceName Apache
Integration withthe NormalizedMessage RouterBUS inServiceMix 4.x
Scalate / scalate-camel
scalate:templateNameApache
Uses the givenScalate templateto transform themessage
Smooks / camel-smooks in camel-extra.
unmarshal(edi) GPL
For workingwith EDI parsingusing theSmooks library.This componentis deprecatedas Smooks nowprovides Camelintegration outof the box
CHAPTER 4 - ARCHITECTURE 35
http://camel.apache.org/esper.htmlhttp://code.google.com/p/camel-extra/http://esper.codehaus.orghttp://camel.apache.org/hibernate.htmlhttp://code.google.com/p/camel-extra/http://www.hibernate.org/http://camel.apache.org/jgroups.htmlhttp://code.google.com/p/camel-extra/http://camel.apache.org/nmr.htmlhttp://servicemix.apache.org/SMX4NMR/index.htmlhttp://scalate.fusesource.org/camel.htmlhttp://scalate.fusesource.org/http://camel.apache.org/smooks.htmlhttp://code.google.com/p/camel-extra/http://milyn.codehaus.org/Smookshttp://www.smooks.org/mediawiki/index.php?title=V1.5:Smooks_v1.5_User_Guide#Apache_Camel_Integrationhttp://www.smooks.org/mediawiki/index.php?title=V1.5:Smooks_v1.5_User_Guide#Apache_Camel_Integrationhttp://www.smooks.org/mediawiki/index.php?title=V1.5:Smooks_v1.5_User_Guide#Apache_Camel_Integration
Spring Neo4j / camel-spring-neo4j in camel-extra
spring-neo4j:http://hostname[:port]/database[?options]to beeclarified
Component forproducing toNeo4j datastoreusing the SpringData Neo4jlibrary
ZeroMQ / camel-zeromq in camel-extra.
zeromq:(tcp|ipc)://hostname:port LGPL
The ZeroMQcomponentallows you toconsumer orproducemessages usingZeroMQ.
For a full details of the individual components see the Component Appendix
36 CHAPTER 4 - ARCHITECTURE
http://camel.apache.org/spring-neo4j.htmlhttp://code.google.com/p/camel-extra/http://www.springsource.org/spring-data/neo4jhttp://www.springsource.org/spring-data/neo4jhttp://camel.apache.org/zeromq.htmlhttp://code.google.com/p/camel-extra/http://zeromq.orghttp://camel.apache.org/book-component-appendix.html
C H A P T E R 5
Enterprise Integration Patterns
Camel supports most of the Enterprise Integration Patterns from the excellent book of thesame name by Gregor Hohpe and Bobby Woolf. Its a highly recommended book, particularlyfor users of Camel.
PATTERN INDEX
There now follows a list of the Enterprise Integration Patterns from the book along withexamples of the various patterns using Apache Camel
Messaging Systems
MessageChannel
How does one application communicate with another usingmessaging?
MessageHow can two applications connected by a message channelexchange a piece of information?
Pipes andFilters
How can we perform complex processing on a message whilemaintaining independence and flexibility?
MessageRouter
How can you decouple individual processing steps so thatmessages can be passed to different filters depending on a set ofconditions?
MessageTranslator
How can systems using different data formats communicate witheach other using messaging?
MessageEndpoint
How does an application connect to a messaging channel to sendand receive messages?
CHAPTER 5 - ENTERPRISE INTEGRATION PATTERNS 37
http://www.enterpriseintegrationpatterns.com/toc.htmlhttp://www.amazon.com/dp/0321200683?tag=enterpriseint-20&camp=14573&creative=327641&linkCode=as1&creativeASIN=0321200683&adid=1VPQTCMNNEMCJXPKRFPG&http://camel.apache.org/message-channel.htmlhttp://camel.apache.org/message-channel.htmlhttp://camel.apache.org/message.htmlhttp://camel.apache.org/pipes-and-filters.htmlhttp://camel.apache.org/pipes-and-filters.htmlhttp://camel.apache.org/message-router.htmlhttp://camel.apache.org/message-router.htmlhttp://camel.apache.org/message-translator.htmlhttp://camel.apache.org/message-translator.htmlhttp://camel.apache.org/message-endpoint.htmlhttp://camel.apache.org/message-endpoint.html
Messaging Channels
Point toPointChannel
How can the caller be sure that exactly one receiver will receivethe document or perform the call?
PublishSubscribeChannel
How can the sender broadcast an event to all interestedreceivers?
DeadLetterChannel
What will the messaging system do with a message it cannotdeliver?
GuaranteedDelivery
How can the sender make sure that a message will be delivered,even if the messaging system fails?
MessageBus
What is an architecture that enables separate applications towork together, but in a de-coupled fashion such that applicationscan be easily added or removed without affecting the others?
Message Construction
Event MessageHow can messaging be used to transmit events from oneapplication to another?
Request ReplyWhen an application sends a message, how can it get aresponse from the receiver?
CorrelationIdentifier
How does a requestor that has received a reply know whichrequest this is the reply for?
ReturnAddress
How does a replier know where to send the reply?
Message Routing
ContentBasedRouter
How do we handle a situation where the implementation of asingle logical function (e.g., inventory check) is spread acrossmultiple physical systems?
MessageFilter
How can a component avoid receiving uninteresting messages?
DynamicRouter
How can you avoid the dependency of the router on allpossible destinations while maintaining its efficiency?
38 CHAPTER 5 - ENTERPRISE INTEGRATION PATTERNS
http://camel.apache.org/point-to-point-channel.htmlhttp://camel.apache.org/point-to-point-channel.htmlhttp://camel.apache.org/point-to-point-channel.htmlhttp://camel.apache.org/publish-subscribe-channel.htmlhttp://camel.apache.org/publish-subscribe-channel.htmlhttp://camel.apache.org/publish-subscribe-channel.htmlhttp://camel.apache.org/dead-letter-channel.htmlhttp://camel.apache.org/dead-letter-channel.htmlhttp://camel.apache.org/dead-letter-channel.htmlhttp://camel.apache.org/guaranteed-delivery.htmlhttp://camel.apache.org/guaranteed-delivery.htmlhttp://camel.apache.org/message-bus.htmlhttp://camel.apache.org/message-bus.htmlhttp://camel.apache.org/event-message.htmlhttp://camel.apache.org/request-reply.htmlhttp://camel.apache.org/correlation-identifier.htmlhttp://camel.apache.org/correlation-identifier.htmlhttp://camel.apache.org/return-address.htmlhttp://camel.apache.org/return-address.htmlhttp://camel.apache.org/content-based-router.htmlhttp://camel.apache.org/content-based-router.htmlhttp://camel.apache.org/content-based-router.htmlhttp://camel.apache.org/message-filter.htmlhttp://camel.apache.org/message-filter.htmlhttp://camel.apache.org/dynamic-router.htmlhttp://camel.apache.org/dynamic-router.html
RecipientList
How do we route a message to a list of (static or dynamically)specified recipients?
SplitterHow can we process a message if it contains multipleelements, each of which may have to be processed in adifferent way?
AggregatorHow do we combine the results of individual, but relatedmessages so that they can be processed as a whole?
ResequencerHow can we get a stream of related but out-of-sequencemessages back into the correct order?
ComposedMessageProcessor
How can you maintain the overall message flow whenprocessing a message consisting of multiple elements, each ofwhich may require different processing?
Scatter-Gather
How do you maintain the overall message flow when amessage needs to be sent to multiple recipients, each of whichmay send a reply?
Routing SlipHow do we route a message consecutively through a series ofprocessing steps when the sequence of steps is not known atdesign-time and may vary for each message?
ThrottlerHow can I throttle messages to ensure that a specific endpointdoes not get overloaded, or we don't exceed an agreed SLAwith some external service?
SamplingHow can I sample one message out of many in a given periodto avoid downstream route does not get overloaded?
Delayer How can I delay the sending of a message?
LoadBalancer
How can I balance load across a number of endpoints?
MulticastHow can I route a message to a number of endpoints at thesame time?
Loop How can I repeat processing a message in a loop?
Message Transformation
ContentEnricher
How do we communicate with another system if the messageoriginator does not have all the required data items available?
CHAPTER 5 - ENTERPRISE INTEGRATION PATTERNS 39
http://camel.apache.org/recipient-list.htmlhttp://camel.apache.org/recipient-list.htmlhttp://camel.apache.org/splitter.htmlhttp://camel.apache.org/aggregator2.htmlhttp://camel.apache.org/resequencer.htmlhttp://camel.apache.org/composed-message-processor.htmlhttp://camel.apache.org/composed-message-processor.htmlhttp://camel.apache.org/composed-message-processor.htmlhttp://camel.apache.org/scatter-gather.htmlhttp://camel.apache.org/scatter-gather.htmlhttp://camel.apache.org/routing-slip.htmlhttp://camel.apache.org/throttler.htmlhttp://camel.apache.org/sampling.htmlhttp://camel.apache.org/delayer.htmlhttp://camel.apache.org/load-balancer.htmlhttp://camel.apache.org/load-balancer.htmlhttp://camel.apache.org/multicast.htmlhttp://camel.apache.org/loop.htmlhttp://camel.apache.org/content-enricher.htmlhttp://camel.apache.org/content-enricher.html
ContentFilter
How do you simplify dealing with a large message, when you areinterested only in a few data items?
ClaimCheck
How can we reduce the data volume of message sent across thesystem without sacrificing information content?
NormalizerHow do you process messages that are semantically equivalent,but arrive in a different format?
Sort How can I sort the body of a message?
Validate How can I validate a message?
Messaging Endpoints
MessagingMapper
How do you move data between domain objects and themessaging infrastructure while keeping the two independent ofeach other?
Event DrivenConsumer
How can an application automatically consume messages as theybecome available?
PollingConsumer
How can an application consume a message when theapplication is ready?
CompetingConsumers
How can a messaging client process multiple messagesconcurrently?
MessageDispatcher
How can multiple consumers on a single channel coordinatetheir message processing?
SelectiveConsumer
How can a message consumer select which messages it wishesto receive?
DurableSubscriber
How can a subscriber avoid missing messages while it's notlistening for them?
IdempotentConsumer
How can a message receiver deal with duplicate messages?
TransactionalClient
How can a client control its transactions with the messagingsystem?
MessagingGateway
How do you encapsulate access to the messaging system fromthe rest of the application?
40 CHAPTER 5 - ENTERPRISE INTEGRATION PATTERNS
http://camel.apache.org/content-filter.htmlhttp://camel.apache.org/content-filter.htmlhttp://camel.apache.org/claim-check.htmlhttp://camel.apache.org/claim-check.htmlhttp://camel.apache.org/normalizer.htmlhttp://camel.apache.org/sort.htmlhttp://camel.apache.org/validate.htmlhttp://camel.apache.org/messaging-mapper.htmlhttp://camel.apache.org/messaging-mapper.htmlhttp://camel.apache.org/event-driven-consumer.htmlhttp://camel.apache.org/event-driven-consumer.htmlhttp://camel.apache.org/polling-consumer.htmlhttp://camel.apache.org/polling-consumer.htmlhttp://camel.apache.org/competing-consumers.htmlhttp://camel.apache.org/competing-consumers.htmlhttp://camel.apache.org/message-dispatcher.htmlhttp://camel.apache.org/message-dispatcher.htmlhttp://camel.apache.org/selective-consumer.htmlhttp://camel.apache.org/selective-consumer.htmlhttp://camel.apache.org/durable-subscriber.htmlhttp://camel.apache.org/durable-subscriber.htmlhttp://camel.apache.org/idempotent-consumer.htmlhttp://camel.apache.org/idempotent-consumer.htmlhttp://camel.apache.org/transactional-client.htmlhttp://camel.apache.org/transactional-client.htmlhttp://camel.apache.org/messaging-gateway.htmlhttp://camel.apache.org/messaging-gateway.html
ServiceActivator
How can an application design a service to be invoked both viavarious messaging technologies and via non-messagingtechniques?
System Management
ControlBusHow can we effectively administer a messaging system that isdistributed across multiple platforms and a wide geographic area?
DetourHow can you route a message through intermediate steps toperform validation, testing or debugging functions?
Wire TapHow do you inspect messages that travel on a point-to-pointchannel?
MessageHistory
How can we effectively analyze and debug the flow of messagesin a loosely coupled system?
Log How can I log processing a message?
For a full breakdown of each pattern see the Book Pattern Appendix
CHAPTER 5 - ENTERPRISE INTEGRATION PATTERNS 41
http://camel.apache.org/service-activator.htmlhttp://camel.apache.org/service-activator.htmlhttp://camel.apache.org/controlbus.htmlhttp://camel.apache.org/detour.htmlhttp://camel.apache.org/wire-tap.htmlhttp://camel.apache.org/message-history.htmlhttp://camel.apache.org/message-history.htmlhttp://camel.apache.org/logeip.htmlhttp://camel.apache.org/book-pattern-appendix.html
CookBook
This document describes various recipes for working with Camel Bean Integration describes how to work with beans and Camel in a loosely coupled
way so that your beans do not have to depend on any Camel APIs Annotation Based Expression Language binds expressions to method
parameters Bean Binding defines which methods are invoked and how the Message is
converted into the parameters of the method when it is invoked Bean Injection for injecting Camel related resources into your POJOs Parameter Binding Annotations for extracting various headers, properties
or payloads from a M
Top Related