Author: cmueller
Date: Thu Oct 29 20:28:10 2015
New Revision: 970685
Log:
Uploading released manuals for camel-2.15.4
Added:
websites/production/camel/content/manual/camel-manual-2.15.4.html
Added: websites/production/camel/content/manual/camel-manual-2.15.4.html
==============================================================================
--- websites/production/camel/content/manual/camel-manual-2.15.4.html (added)
+++ websites/production/camel/content/manual/camel-manual-2.15.4.html Thu Oct
29 20:28:10 2015
@@ -0,0 +1,27179 @@
+<html>
+<head>
+<link href="http://camel.apache.org/styles/camel-manual.css"; rel="stylesheet"
type="text/css" />
+ <style type="text/css">
+ @page :left {
+ @top-left {
+ content: "Apache Camel 2.15.4 Developer's
Manual";
+ }
+ }
+ </style>
+
+ <link
href='http://camel.apache.org/styles/highlighter/styles/shCoreCamel.css'
rel='stylesheet' type='text/css' />
+ <link
href='http://camel.apache.org/styles/highlighter/styles/shThemeCamel.css'
rel='stylesheet' type='text/css' />
+ <script
src='http://camel.apache.org/styles/highlighter/scripts/shCore.js'
type='text/javascript'></script>
+ <script
src='http://camel.apache.org/styles/highlighter/scripts/shBrushSql.js'
type='text/javascript'></script>
+ <script
src='http://camel.apache.org/styles/highlighter/scripts/shBrushJava.js'
type='text/javascript'></script>
+ <script
src='http://camel.apache.org/styles/highlighter/scripts/shBrushXml.js'
type='text/javascript'></script>
+ <script
src='http://camel.apache.org/styles/highlighter/scripts/shBrushPlain.js'
type='text/javascript'></script>
+
+ <script type="text/javascript">
+ SyntaxHighlighter.defaults['toolbar'] = false;
+ SyntaxHighlighter.all();
+ </script>
+</head>
+<body><div class="wiki-content maincontent"><div class="titlepage"
id="titlepage"><h1 id="BookInOnePage-ApacheCamel">Apache Camel</h1><h2
id="BookInOnePage-UserGuide">User Guide</h2><h3>Version 2.15.4</h3>
+<p><br clear="none"> Copyright 2007-2015, Apache Software Foundation</p></div>
+<div class="toc" id="toc">
+<h1 id="BookInOnePage-TableofContents">Table of Contents</h1>
+
+<p>
+</p><ul class="toc"><li class="frontmatter"><a shape="rect" href="#toc">Table
of Contents</a></li><li class="chapter"><a shape="rect"
href="#chapter-introduction">Introduction</a></li><li class="chapter"><a
shape="rect" href="#chapter-quickstart">Quickstart</a></li><li
class="chapter"><a shape="rect" href="#chapter-getting-started">Getting
Started</a></li><li class="chapter"><a shape="rect"
href="#chapter-architecture">Architecture</a></li><li class="chapter"><a
shape="rect" href="#chapter-enterprise-integration-patterns">Enterprise
Integration Patterns</a></li><li class="chapter"><a shape="rect"
href="#chapter-cook-book">Cook Book</a></li><li class="chapter"><a shape="rect"
href="#chapter-tutorials">Tutorials</a></li><li class="chapter"><a shape="rect"
href="#chapter-languages-supported-Appendix">Language Appendix</a></li><li
class="chapter"><a shape="rect" href="#chapter-dataformat-Appendix">DataFormat
Appendix</a></li><li class="chapter"><a shape="rect" href="#chapter-pattern-app
endix">Pattern Appendix</a></li><li class="chapter"><a shape="rect"
href="#chapter-component-appendix">Component Appendix</a></li><li
class="endmatter"><a shape="rect" href="#index">Index</a></li></ul>
+</div>
+<div class="chapter page-reset" id="chapter-introduction">
+<h1 id="BookInOnePage-Introduction">Introduction</h1>
+
+Apache Camel ™ is a versatile open-source integration framework based on
known <a shape="rect" href="enterprise-integration-patterns.html">Enterprise
Integration Patterns</a>.
+
+<p>Camel empowers you to define routing and mediation rules in a variety of
domain-specific languages, including a Java-based <a shape="rect"
href="dsl.html">Fluent API</a>, <a shape="rect" href="spring.html">Spring</a>
or <a shape="rect" href="using-osgi-blueprint-with-camel.html">Blueprint</a> <a
shape="rect" href="xml-configuration.html">XML Configuration</a> files, and a
<a shape="rect" href="scala-dsl.html">Scala DSL</a>. This means you get smart
completion of routing rules in your IDE, whether in a Java, Scala or XML
editor.</p>
+
+<p>Apache Camel uses <a shape="rect" href="uris.html">URIs</a> to work
directly with any kind of <a shape="rect" href="transport.html">Transport</a>
or messaging model such as <a shape="rect" href="http.html">HTTP</a>, <a
shape="rect" href="activemq.html">ActiveMQ</a>, <a shape="rect"
href="jms.html">JMS</a>, <a shape="rect" href="jbi.html">JBI</a>, SCA, <a
shape="rect" href="mina.html">MINA</a> or <a shape="rect"
href="cxf.html">CXF</a>, as well as pluggable <a shape="rect"
href="components.html">Components</a> and <a shape="rect"
href="data-format.html">Data Format</a> options. Apache Camel is a small
library with minimal <a shape="rect"
href="what-are-the-dependencies.html">dependencies</a> for easy embedding in
any Java application. Apache Camel lets you work with the same <a shape="rect"
href="exchange.html">API</a> regardless which kind of <a shape="rect"
href="transport.html">Transport</a> is used - so learn the API once and you can
interact with all the <a shape="rect" href=
"components.html">Components</a> provided out-of-box.</p>
+
+<p>Apache Camel provides support for <a shape="rect"
href="bean-binding.html">Bean Binding</a> and seamless integration with popular
frameworks such as <a shape="rect" href="spring.html">Spring</a>, <a
shape="rect" href="using-osgi-blueprint-with-camel.html">Blueprint</a> and <a
shape="rect" href="guice.html">Guice</a>. Camel also has extensive support for
<a shape="rect" href="testing.html">unit testing</a> your routes. </p>
+
+<p>The following projects can leverage Apache Camel as a routing and mediation
engine:</p>
+
+<ul><li><a shape="rect" class="external-link"
href="http://servicemix.apache.org/";>Apache ServiceMix</a> - a popular
distributed open source ESB and JBI container</li><li><a shape="rect"
class="external-link" href="http://activemq.apache.org/";>Apache ActiveMQ</a> -
a mature, widely used open source message broker</li><li><a shape="rect"
href="http://cxf.apache.org/";>Apache CXF</a> - a smart web services suite
(JAX-WS and JAX-RS)</li><li><a shape="rect" class="external-link"
href="http://karaf.apache.org/";>Apache Karaf</a> - a small OSGi based runtime
in which applications can be deployed</li><li><a shape="rect"
class="external-link" href="http://mina.apache.org/";>Apache MINA</a> - a
high-performance <a shape="rect" class="external-link"
href="http://en.wikipedia.org/wiki/New_I/O"; rel="nofollow">NIO</a>-driven
networking framework</li></ul>
+
+
+<p>So don't get the hump - try Camel today! <img class="emoticon
emoticon-smile"
src="https://cwiki.apache.org/confluence/s/en_GB/5982/f2b47fb3d636c8bc9fd0b11c0ec6d0ae18646be7.1/_/images/icons/emoticons/smile.png";
data-emoticon-name="smile" alt="(smile)"></p>
+
+<div class="confluence-information-macro confluence-information-macro-tip"><p
class="title">Too many buzzwords - what exactly is Camel?</p><span
class="aui-icon aui-icon-small aui-iconfont-approve
confluence-information-macro-icon"></span><div
class="confluence-information-macro-body">
+<p>Okay, so the description above is technology focused. <br clear="none">
+There's a great discussion about Camel at <a shape="rect"
class="external-link"
href="http://stackoverflow.com/questions/8845186/what-exactly-is-apache-camel";
rel="nofollow">Stack Overflow</a>. We suggest you view the post, read the
comments, and browse the suggested links for more details.</p></div></div></div>
+<div class="chapter page-reset" id="chapter-quickstart">
+<h1 id="BookInOnePage-Quickstart">Quickstart</h1>
+
+<p>To start using Apache Camel quickly, you can read through some simple
examples in this chapter. For readers who would like a more thorough
introduction, please skip ahead to Chapter 3.</p>
+
+<h2 id="BookInOnePage-WalkthroughanExampleCode">Walk through an Example
Code</h2><p>This mini-guide takes you through the source code of a <a
shape="rect" class="external-link"
href="https://svn.apache.org/repos/asf/camel/trunk/examples/camel-example-jms-file/src/main/java/org/apache/camel/example/jmstofile/CamelJmsToFileExample.java";>simple
example</a>.</p><p>Camel can be configured either by using <a shape="rect"
href="spring.html">Spring</a> or directly in Java - which <a shape="rect"
class="external-link"
href="https://svn.apache.org/repos/asf/camel/trunk/examples/camel-example-jms-file/src/main/java/org/apache/camel/example/jmstofile/CamelJmsToFileExample.java";>this
example does</a>.</p><p>This example is available in the
<code>examples\camel-example-jms-file</code> directory of the <a shape="rect"
href="download.html">Camel distribution</a>.</p><p>We start with creating a <a
shape="rect" href="camelcontext.html">CamelContext</a> - which is a container
for <a shape="rect" href=
"components.html">Components</a>, <a shape="rect"
href="routes.html">Routes</a> etc:</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+CamelContext context = new DefaultCamelContext();
+]]></script>
+</div></div><p>There is more than one way of adding a Component to the
CamelContext. You can add components implicitly - when we set up the routing -
as we do here for the <a shape="rect"
href="file2.html">FileComponent</a>:</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+context.addRoutes(new RouteBuilder() {
+ public void configure() {
+
from("test-jms:queue:test.queue").to("file://test");
+ }
+});
+]]></script>
+</div></div><p>or explicitly - as we do here when we add the JMS
Component:</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+ConnectionFactory connectionFactory = new
ActiveMQConnectionFactory("vm://localhost?broker.persistent=false");
+// Note we can explicit name the component
+context.addComponent("test-jms",
JmsComponent.jmsComponentAutoAcknowledge(connectionFactory));
+]]></script>
+</div></div><p>The above works with any JMS provider. If we know we are using
<a shape="rect" href="activemq.html">ActiveMQ</a> we can use an even simpler
form using the <a shape="rect" class="external-link"
href="http://activemq.apache.org/maven/5.5.0/activemq-camel/apidocs/org/apache/activemq/camel/component/ActiveMQComponent.html#activeMQComponent%28java.lang.String%29";><code>activeMQComponent()</code>
method</a> while specifying the <a shape="rect" class="external-link"
href="http://activemq.apache.org/configuring-transports.html";>brokerURL</a>
used to connect to ActiveMQ</p><div class="error"><span class="error">Error
formatting macro: snippet: java.lang.IndexOutOfBoundsException: Index: 20,
Size: 20</span> </div><p>In normal use, an external system would be firing
messages or events directly into Camel through one if its <a shape="rect"
href="components.html">Components</a> but we are going to use the <a
shape="rect" class="external-link" href="http://camel.apache.org/maven/cu
rrent/camel-core/apidocs/org/apache/camel/ProducerTemplate.html">ProducerTemplate</a>
which is a really easy way for testing your configuration:</p><div class="code
panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+ProducerTemplate template = context.createProducerTemplate();
+]]></script>
+</div></div><p>Next you <strong>must</strong> start the camel context. If you
are using <a shape="rect" href="spring.html">Spring</a> to configure the camel
context this is automatically done for you; though if you are using a pure Java
approach then you just need to call the start() method</p><div class="code
panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[camelContext.start();
+]]></script>
+</div></div><p>This will start all of the configured routing rules.</p><p>So
after starting the <a shape="rect" href="camelcontext.html">CamelContext</a>,
we can fire some objects into camel:</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+for (int i = 0; i < 10; i++) {
+ template.sendBody("test-jms:queue:test.queue", "Test
Message: " + i);
+}
+]]></script>
+</div></div><h2 id="BookInOnePage-Whathappens?">What happens?</h2><p>From the
<a shape="rect" class="external-link"
href="http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/ProducerTemplate.html";>ProducerTemplate</a>
- we send objects (in this case text) into the <a shape="rect"
href="camelcontext.html">CamelContext</a> to the Component
<em>test-jms:queue:test.queue</em>. These text objects will be <a shape="rect"
href="type-converter.html">converted automatically</a> into JMS Messages and
posted to a JMS Queue named <em>test.queue</em>. When we set up the <a
shape="rect" href="routes.html">Route</a>, we configured the <a shape="rect"
href="file2.html">FileComponent</a> to listen off the
<em>test.queue</em>.</p><p>The File <a shape="rect"
href="file2.html">FileComponent</a> will take messages off the Queue, and save
them to a directory named <em>test</em>. Every message will be saved in a file
that corresponds to its destination and message id.</p><p>Finally,
we configured our own listener in the <a shape="rect"
href="routes.html">Route</a> - to take notifications from the <a shape="rect"
href="file2.html">FileComponent</a> and print them out as
text.</p><p><strong>That's it!</strong></p><p>If you have the time then use 5
more minutes to <a shape="rect" href="walk-through-another-example.html">Walk
through another example</a> that demonstrates the Spring DSL (XML based)
routing.</p>
+<h2 id="BookInOnePage-Walkthroughanotherexample">Walk through another
example</h2>
+
+<h3 id="BookInOnePage-Introduction.1">Introduction</h3>
+<p>Continuing the walk from our first <a shape="rect"
href="walk-through-an-example.html">example</a>, we take a closer look at the
routing and explain a few pointers - so you won't walk into a bear trap, but
can enjoy an after-hours walk to the local pub for a large beer <img
class="emoticon emoticon-wink"
src="https://cwiki.apache.org/confluence/s/en_GB/5982/f2b47fb3d636c8bc9fd0b11c0ec6d0ae18646be7.1/_/images/icons/emoticons/wink.png";
data-emoticon-name="wink" alt="(wink)"></p>
+
+<p>First we take a moment to look at the <a shape="rect"
href="enterprise-integration-patterns.html">Enterprise Integration Patterns</a>
- the base pattern catalog for integration scenarios. In particular we focus on
<a shape="rect" href="pipes-and-filters.html">Pipes and filters</a> - a central
pattern. This is used to route messages through a sequence of processing steps,
each performing a specific function - much like the Java Servlet Filters. </p>
+
+<h3 id="BookInOnePage-Pipesandfilters">Pipes and filters</h3>
+<p>In this sample we want to process a message in a sequence of steps where
each steps can perform their specific function. In our example we have a <a
shape="rect" href="jms.html">JMS</a> queue for receiving new orders. When an
order is received we need to process it in several steps:</p>
+<ul class="alternate"><li>validate</li><li>register</li><li>send confirm
email</li></ul>
+
+
+<p>This can be created in a route like this:</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+<route>
+ <from uri="jms:queue:order"/>
+ <pipeline>
+ <bean ref="validateOrder"/>
+ <bean ref="registerOrder"/>
+ <bean ref="sendConfirmEmail"/>
+ </pipeline>
+</route>
+]]></script>
+</div></div>
+
+<div class="confluence-information-macro confluence-information-macro-tip"><p
class="title">Pipeline is default</p><span class="aui-icon aui-icon-small
aui-iconfont-approve confluence-information-macro-icon"></span><div
class="confluence-information-macro-body">
+<p>In the route above we specify <code>pipeline</code> but it can be omitted
as its default, so you can write the route as:</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+<route>
+ <from uri="jms:queue:order"/>
+ <bean ref="validateOrder"/>
+ <bean ref="registerOrder"/>
+ <bean ref="sendConfirmEmail"/>
+</route>
+]]></script>
+</div></div>
+<p>This is commonly used not to state the pipeline. </p>
+
+<p>An example where the pipeline needs to be used, is when using a multicast
and "one" of the endpoints to send to (as a logical group) is a pipeline of
other endpoints. For example.</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+<route>
+ <from uri="jms:queue:order"/>
+ <multicast>
+ <to uri="log:org.company.log.Category"/>
+ <pipeline>
+ <bean ref="validateOrder"/>
+ <bean ref="registerOrder"/>
+ <bean ref="sendConfirmEmail"/>
+ </pipeline>
+ </multicast>
+</route>
+]]></script>
+</div></div>
+
+<p>The above sends the order (from <code>jms:queue:order</code>) to two
locations at the same time, our log component, and to the "pipeline" of beans
which goes one to the other. If you consider the opposite, sans the
<code><pipeline></code></p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+<route>
+ <from uri="jms:queue:order"/>
+ <multicast>
+ <to uri="log:org.company.log.Category"/>
+ <bean ref="validateOrder"/>
+ <bean ref="registerOrder"/>
+ <bean ref="sendConfirmEmail"/>
+ </multicast>
+</route>
+]]></script>
+</div></div>
+
+<p>you would see that multicast would not "flow" the message from one bean to
the next, but rather send the order to all 4 endpoints (1x log, 3x bean) in
parallel, which is not (for this example) what we want. We need the message to
flow to the validateOrder, then to the registerOrder, then the sendConfirmEmail
so adding the pipeline, provides this facility. </p>
+</div></div>
+
+<p>Where as the <code>bean ref</code> is a reference for a spring bean id, so
we define our beans using regular Spring XML as:</p>
+
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+ <bean id="validateOrder"
class="com.mycompany.MyOrderValidator"/>
+]]></script>
+</div></div>
+
+<p>Our validator bean is a plain POJO that has no dependencies to Camel what
so ever. So you can implement this POJO as you like. Camel uses rather
intelligent <a shape="rect" href="bean-binding.html">Bean Binding</a> to invoke
your POJO with the payload of the received message. In this example we will
<strong>not</strong> dig into this how this happens. You should return to this
topic later when you got some hands on experience with Camel how it can easily
bind routing using your existing POJO beans.</p>
+
+<p>So what happens in the route above. Well when an order is received from the
<a shape="rect" href="jms.html">JMS</a> queue the message is routed like <a
shape="rect" href="pipes-and-filters.html">Pipes and filters</a>:<br
clear="none">
+1. payload from the <a shape="rect" href="jms.html">JMS</a> is sent as input
to the validateOrder bean<br clear="none">
+2. the output from validateOrder bean is sent as input to the registerOrder
bean<br clear="none">
+3. the output from registerOrder bean is sent as input to the sendConfirmEmail
bean</p>
+
+<h3 id="BookInOnePage-UsingCamelComponents">Using Camel Components</h3>
+<p>In the route lets imagine that the registration of the order has to be done
by sending data to a TCP socket that could be a big mainframe. As Camel has
many <a shape="rect" href="components.html">Components</a> we will use the
camel-mina component that supports <a shape="rect" href="mina.html">TCP</a>
connectivity. So we change the route to:</p>
+
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+<route>
+ <from uri="jms:queue:order"/>
+ <bean ref="validateOrder"/>
+ <to uri="mina:tcp://mainframeip:4444?textline=true"/>
+ <bean ref="sendConfirmEmail"/>
+</route>
+]]></script>
+</div></div>
+
+<p>What we now have in the route is a <code>to</code> type that can be used as
a direct replacement for the bean type. The steps is now:<br clear="none">
+1. payload from the <a shape="rect" href="jms.html">JMS</a> is sent as input
to the validateOrder bean<br clear="none">
+2. the output from validateOrder bean is sent as text to the mainframe using
TCP<br clear="none">
+3. the output from mainframe is sent back as input to the sendConfirmEmai
bean</p>
+
+<p>What to notice here is that the <code>to</code> is not the end of the route
(the world <img class="emoticon emoticon-wink"
src="https://cwiki.apache.org/confluence/s/en_GB/5982/f2b47fb3d636c8bc9fd0b11c0ec6d0ae18646be7.1/_/images/icons/emoticons/wink.png";
data-emoticon-name="wink" alt="(wink)">) in this example it's used in the
middle of the <a shape="rect" href="pipes-and-filters.html">Pipes and
filters</a>. In fact we can change the <code>bean</code> types to
<code>to</code> as well:</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+<route>
+ <from uri="jms:queue:order"/>
+ <to uri="bean:validateOrder"/>
+ <to uri="mina:tcp://mainframeip:4444?textline=true"/>
+ <to uri="bean:sendConfirmEmail"/>
+</route>
+]]></script>
+</div></div>
+
+<p>As the <code>to</code> is a generic type we must state in the uri scheme
which component it is. So we must write <strong>bean:</strong> for the <a
shape="rect" href="bean.html">Bean</a> component that we are using.</p>
+
+<h3 id="BookInOnePage-Conclusion">Conclusion</h3>
+<p>This example was provided to demonstrate the Spring DSL (XML based) as
opposed to the pure Java DSL from the <a shape="rect"
href="walk-through-an-example.html">first example</a>. And as well to point
about that the <code>to</code> doesn't have to be the last node in a route
graph.</p>
+
+<p>This example is also based on the <strong>in-only</strong> message exchange
pattern. What you must understand as well is the <strong>in-out</strong>
message exchange pattern, where the caller expects a response. We will look
into this in another example.</p>
+
+<h3 id="BookInOnePage-Seealso">See also</h3>
+<ul class="alternate"><li><a shape="rect"
href="examples.html">Examples</a></li><li><a shape="rect"
href="tutorials.html">Tutorials</a></li><li><a shape="rect"
href="user-guide.html">User Guide</a></li></ul></div>
+<div class="chapter" id="chapter-getting-started">
+<h1 id="BookInOnePage-GettingStartedwithApacheCamel">Getting Started with
Apache Camel</h1></div>
+
+<p><span class="confluence-anchor-link" id="BookInOnePage-eip-book"></span></p>
+<h2 id="BookInOnePage-TheEnterpriseIntegrationPatterns(EIP)book">The
<em>Enterprise Integration Patterns</em> (EIP) book</h2>
+<p>The purpose of a "patterns" book is not to advocate new techniques that the
authors have invented, 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 a vocabulary for discussing
architectural designs.<br clear="none">
+One of the most famous patterns books is <a shape="rect" class="external-link"
href="http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612";
rel="nofollow"><em>Design Patterns: Elements of Reusable Object-oriented
Software</em></a> by Erich Gamma, Richard Helm, Ralph Johnson and John
Vlissides, commonly known as the <a shape="rect" class="external-link"
href="http://en.wikipedia.org/wiki/Design_Patterns"; rel="nofollow">"Gang of
Four" (GoF)</a> book. Since the publication of <em>Design Patterns</em>, many
other pattern books, of varying quality, have been written. One famous patterns
book is called <a shape="rect" class="external-link"
href="http://www.amazon.com/Enterprise-Integration-Patterns-Designing-Deploying/dp/0321200683";
rel="nofollow"><em>Enterprise Integration Patterns: Designing, Building, and
Deploying Messaging Solutions</em></a> by Gregor Hohpe and Bobby Woolf. It is
common for people to refer to this book by its initials <em>EIP</em>. As
the subtitle of EIP suggests, the book focuses on design patterns for
asynchronous messaging systems. The book discusses 65 patterns. Each pattern is
given a textual name and most are also given a graphical symbol, intended to be
used in architectural diagrams.</p>
+
+<h2 id="BookInOnePage-TheCamelproject">The Camel project</h2>
+<p>Camel (<a shape="rect" class="external-link"
href="http://camel.apache.org";>http://camel.apache.org</a>) is an open-source,
Java-based project that helps the user implement many of the design patterns in
the EIP book. Because Camel implements many of the design patterns in the EIP
book, it would be a good idea for people who work with Camel to have the EIP
book as a reference.</p>
+
+<h2 id="BookInOnePage-OnlinedocumentationforCamel">Online documentation for
Camel</h2>
+<p>The documentation is all under the Documentation category on the right-side
menu of the Camel website (also available in <a shape="rect"
class="external-link" href="http://camel.apache.org/manual.html";>PDF form</a>.
<a shape="rect" href="books.html">Camel-related books</a> are also available,
in particular the <a shape="rect" class="external-link"
href="http://manning.com/ibsen"; rel="nofollow">Camel in Action</a> book,
presently serving as the Camel bible--it has a <a shape="rect"
class="external-link" href="http://www.manning.com/ibsen/chapter1sample.pdf";
rel="nofollow">free Chapter One (pdf)</a>, which is highly recommended to read
to get more familiar with Camel.</p>
+
+<h3 id="BookInOnePage-Ausefultipfornavigatingtheonlinedocumentation">A useful
tip for navigating the online documentation</h3>
+<p>The breadcrumbs at the top of the online Camel documentation can help you
navigate between parent and child subsections. <br clear="none">
+For example, If you are on the "Languages" documentation page then the
left-hand side of the reddish bar contains the following links.</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+Apache Camel > Documentation > Architecture > Languages
+]]></script>
+</div></div>
+<p>As you might expect, clicking on "Apache Camel" takes you back to the home
page of the Apache Camel project, and clicking on "Documentation" takes you to
the main documentation page. 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 that you frequently
reference can also save time. </p>
+
+<p><span class="confluence-anchor-link"
id="BookInOnePage-online-javadoc-docs"></span></p>
+<h2 id="BookInOnePage-OnlineJavadocdocumentation">Online Javadoc
documentation</h2>
+<p>The Apache Camel website provides <a shape="rect" class="external-link"
href="http://camel.apache.org/maven/current/camel-core/apidocs/index.html";>Javadoc
documentation</a>. It is important to note that the Javadoc documentation is
spread over several <em>independent</em> Javadoc hierarchies rather than being
all contained in a single Javadoc hierarchy. In particular, there is one
Javadoc hierarchy for the <em>core</em> APIs of Camel, and a separate Javadoc
hierarchy for each component technology supported by Camel. For example, if you
will be using Camel with ActiveMQ and FTP then you need to look at the Javadoc
hierarchies for the <a shape="rect" class="external-link"
href="http://camel.apache.org/maven/current/camel-core/apidocs/index.html";>core
API</a> and <a shape="rect" class="external-link"
href="http://camel.apache.org/maven/current/camel-spring/apidocs/index.html";>Spring
API</a>.</p>
+
+<h2 id="BookInOnePage-ConceptsandterminologyfundamentaltoCamel">Concepts and
terminology fundamental to Camel</h2>
+<p>In this section some of the concepts and terminology that are fundamental
to Camel are explained. This section is not meant as a complete Camel tutorial,
but as a first step in that direction.</p>
+
+<p><span class="confluence-anchor-link" id="BookInOnePage-endpoint"></span></p>
+<h3 id="BookInOnePage-Endpoint">Endpoint</h3>
+<p>The term <em>endpoint</em> 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 <em>address</em>, such as a host:port pair for
TCP-based communication, or it might refer to a <em>software entity</em> that
is contactable at that address. 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 might be
referring to the web server (that is, software contactable at that address).
Often, the distinction between the address and software contactable at that
address is not an important one.<br clear="none">
+Some middleware technologies make it possible for several software entities to
be contactable at the same physical address. For example, CORBA is an
object-oriented, remote-procedure-call (RPC) middleware standard. If a CORBA
server process contains several objects then a client can communicate with any
of these objects at the same <em>physical</em> address (host:port), but a
client communicates with a particular object via that object's <em>logical</em>
address (called an <em>IOR</em> in CORBA terminology), which consists of the
physical address (host:port) plus an id that uniquely identifies the object
within its server process. (An IOR contains some additional information that is
not relevant to this present discussion.) When talking about CORBA, some people
may use the term "endpoint" to refer to a CORBA server's <em>physical
address</em>, while other people may use the term to refer to the <em>logical
address</em> of a single CORBA object, and other people still might use the t
erm to refer to any of the following:</p>
+<ul><li>The physical address (host:port) of the CORBA server
process</li><li>The logical address (host:port plus id) of a CORBA
object.</li><li>The CORBA server process (a relatively heavyweight software
entity)</li><li>A CORBA object (a lightweight software entity)</li></ul>
+
+
+<p>Because of this, you can see that the term <em>endpoint</em> is ambiguous
in at least two ways. First, it is ambiguous because it might refer to an
address or to a software entity contactable at that address. Second, it is
ambiguous in the <em>granularity</em> of what it refers to: a heavyweight
versus lightweight software entity, or physical address versus logical address.
It is useful to understand that different people use the term <em>endpoint</em>
in slightly different (and hence ambiguous) ways because Camel's usage of this
term might be different to whatever meaning you had previously associated with
the term.<br clear="none">
+Camel provides out-of-the-box support for endpoints implemented with many
different communication technologies. Here are some examples of the
Camel-supported endpoint technologies.</p>
+<ul><li>A JMS queue.</li><li>A web service.</li><li>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, another application
might read that file.</li><li>An FTP server.</li><li>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.</li><li>A POJO (plain old Java object).</li></ul>
+
+
+<p>In a Camel-based application, you create (Camel wrappers around) some
endpoints and connect these endpoints with <em>routes</em>, which I will
discuss later in <a shape="rect" href="#BookInOnePage-routes">Section 4.8
("Routes, RouteBuilders and Java DSL")</a>. Camel defines a Java interface
called <code>Endpoint</code>. Each Camel-supported endpoint has a class that
implements this <code>Endpoint</code> interface. As I discussed in <a
shape="rect" href="#BookInOnePage-online-javadoc-docs">Section 3.3 ("Online
Javadoc documentation")</a>, Camel provides a separate Javadoc hierarchy for
each communications technology supported by Camel. Because of this, you will
find documentation on, say, the <code>JmsEndpoint</code> class in the <a
shape="rect" class="external-link"
href="http://camel.apache.org/maven/current/camel-jms/apidocs/";>JMS Javadoc
hierarchy</a>, while documentation for, say, the <code>FtpEndpoint</code> class
is in the <a shape="rect" class="external-link" href="http://
camel.apache.org/maven/current/camel-ftp/apidocs/">FTP Javadoc
hierarchy</a>.</p>
+
+<h3 id="BookInOnePage-CamelContext">CamelContext</h3>
+<p>A <code>CamelContext</code> object represents the Camel runtime system. You
typically have one <code>CamelContext</code> object in an application. A
typical application executes the following steps.</p>
+<ol><li>Create a <code>CamelContext</code> object.</li><li>Add endpoints
– and possibly Components, which are discussed in <a shape="rect"
href="#BookInOnePage-components-and-uris">Section 4.5 ("Components")</a>
– to the <code>CamelContext</code> object.</li><li>Add routes to the
<code>CamelContext</code> object to connect the endpoints.</li><li>Invoke the
<code>start()</code> operation on the <code>CamelContext</code> object. This
starts Camel-internal threads that are used to process the sending, receiving
and processing of messages in the endpoints.</li><li>Eventually invoke the
<code>stop()</code> operation on the <code>CamelContext</code> object. Doing
this gracefully stops all the endpoints and Camel-internal threads.</li></ol>
+
+
+<p>Note that the <code>CamelContext.start()</code> operation does not block
indefinitely. Rather, it starts threads internal to each <code>Component</code>
and <code>Endpoint</code> and then <code>start()</code> returns. Conversely,
<code>CamelContext.stop()</code> waits for all the threads internal to each
<code>Endpoint</code> and <code>Component</code> to terminate and then
<code>stop()</code> returns.<br clear="none">
+If you neglect to call <code>CamelContext.start()</code> in your application
then messages will not be processed because internal threads will not have been
created.<br clear="none">
+If you neglect to call <code>CamelContext.stop()</code> before terminating
your application then the application may terminate in an inconsistent state.
If you neglect to call <code>CamelContext.stop()</code> in a JUnit test then
the test may fail due to messages not having had a chance to be fully
processed.</p>
+
+<h3 id="BookInOnePage-CamelTemplate">CamelTemplate</h3>
+<p>Camel used to have a class called <code>CamelClient</code>, but this was
renamed to be <code>CamelTemplate</code> to be similar to a naming convention
used in some other open-source projects, such as the
<code>TransactionTemplate</code> and <code>JmsTemplate</code> classes in <a
shape="rect" class="external-link" href="http://www.springframework.org/";
rel="nofollow">Spring</a>.<br clear="none">
+The <code>CamelTemplate</code> class is a thin wrapper around the
<code>CamelContext</code> class. It has methods that send a
<code>Message</code> or <code>Exchange</code> – both discussed in <a
shape="rect" href="#BookInOnePage-message-and-exchange">Section 4.6 ("Message
and Exchange")</a>) – to an <code>Endpoint</code> – discussed in <a
shape="rect" href="#BookInOnePage-endpoint">Section 4.1 ("Endpoint")</a>. This
provides a way to enter messages into source endpoints, so that the messages
will move along routes – discussed in <a shape="rect"
href="#BookInOnePage-routes">Section 4.8 ("Routes, RouteBuilders and Java
DSL")</a> – to destination endpoints.</p>
+
+<p><span class="confluence-anchor-link"
id="BookInOnePage-url-uri-urn-iri"></span></p>
+<h3 id="BookInOnePage-TheMeaningofURL,URI,URNandIRI">The Meaning of URL, URI,
URN and IRI </h3>
+<p>Some Camel methods take a parameter that is a <em>URI</em> 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.<br clear="none">
+Most people are familiar with <em>URLs</em> (uniform resource locators), such
as "http://...";, "ftp://...";, "mailto:...";. Put simply, a URL specifies the
<em>location</em> of a resource.<br clear="none">
+A <em>URI</em> (uniform resource identifier) is a URL <em>or</em> a URN. So,
to fully understand what URI means, you need to first understand what is a
URN.<br clear="none">
+<em>URN</em> is an acronym for <em>uniform resource name</em>. There are may
"unique identifier" schemes in the world, for example, ISBNs (globally unique
for books), social security numbers (unique within a country), customer numbers
(unique within a company's customers database) and telephone numbers. Each
"unique identifier" scheme has its own notation. A URN is a wrapper for
different "unique identifier" schemes. The syntax of a URN is
"urn:<scheme-name>:<unique-identifier>". A URN uniquely identifies
a <em>resource</em>, such as a book, person or piece of equipment. By itself, a
URN does not specify the <em>location</em> of the resource. Instead, it is
assumed that a <em>registry</em> provides a mapping from a resource's URN to
its location. The URN specification does not state what form a registry takes,
but it might be a database, a server application, a wall chart or 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
<scheme-name> ("employee", "customer" and "foo" in these examples) part
of a URN implicitly defines how to parse and interpret the
<unique-identifier> that follows it. An arbitrary URN is meaningless
unless: (1) you know the semantics implied by the <scheme-name>, and (2)
you have access to the registry appropriate for the <scheme-name>. A
registry does not have to be public or globally accessible. For example,
"urn:employee:08765245" might be meaningful only within a specific company.<br
clear="none">
+To date, URNs are not (yet) as popular as URLs. For this reason, URI is widely
misused as a synonym for URL.<br clear="none">
+<em>IRI</em> is an acronym for <em>internationalized resource identifier</em>.
An IRI is simply an internationalized version of a URI. In particular, a URI
can contain letters and digits in the US-ASCII character set, while a IRI can
contain those same letters and digits, and <em>also</em> European accented
characters, Greek letters, Chinese ideograms and so on.</p>
+
+<h3 id="BookInOnePage-Components">Components</h3>
+<p><em>Component</em> is confusing terminology; <em>EndpointFactory</em> would
have been more appropriate because a <code>Component</code> is a factory for
creating <code>Endpoint</code> instances. For example, if a Camel-based
application uses several JMS queues then the application will create one
instance of the <code>JmsComponent</code> class (which implements the
<code>Component</code> interface), and then the application invokes the
<code>createEndpoint()</code> operation on this <code>JmsComponent</code>
object several times. Each invocation of
<code>JmsComponent.createEndpoint()</code> creates an instance of the
<code>JmsEndpoint</code> class (which implements the <code>Endpoint</code>
interface). Actually, application-level code does not invoke
<code>Component.createEndpoint()</code> directly. Instead, application-level
code normally invokes <code>CamelContext.getEndpoint()</code>; internally, the
<code>CamelContext</code> object finds the desired <code>Component</code> obj
ect (as I will discuss shortly) and then invokes <code>createEndpoint()</code>
on it.<br clear="none">
+Consider the following code.</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+myCamelContext.getEndpoint("pop3://john.sm...@mailserv.example.com?password=myPassword");
+]]></script>
+</div></div>
+<p>The parameter to <code>getEndpoint()</code> is a URI. The URI
<em>prefix</em> (that is, the part before ":") specifies the name of a
component. Internally, the <code>CamelContext</code> object maintains a mapping
from names of components to <code>Component</code> objects. For the URI given
in the above example, the <code>CamelContext</code> object would probably map
the <code>pop3</code> prefix to an instance of the <code>MailComponent</code>
class. Then the <code>CamelContext</code> object invokes
<code>createEndpoint("pop3://john.sm...@mailserv.example.com?password=myPassword")</code>
on that <code>MailComponent</code> object. The <code>createEndpoint()</code>
operation splits the URI into its component parts and uses these parts to
create and configure an <code>Endpoint</code> object.<br clear="none">
+In the previous paragraph, I mentioned that a <code>CamelContext</code> object
maintains a mapping from component names to <code>Component</code> objects.
This raises the question of how this map is populated with named
<code>Component</code> objects. There are two ways of populating the map. The
first way is for application-level code to invoke
<code>CamelContext.addComponent(String componentName, Component
component)</code>. The example below shows a single <code>MailComponent</code>
object being registered in the map under 3 different names.</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+Component mailComponent = new org.apache.camel.component.mail.MailComponent();
+myCamelContext.addComponent("pop3", mailComponent);
+myCamelContext.addComponent("imap", mailComponent);
+myCamelContext.addComponent("smtp", mailComponent);
+]]></script>
+</div></div>
+<p>The second (and preferred) way to populate the map of named
<code>Component</code> objects in the <code>CamelContext</code> object is to
let the <code>CamelContext</code> object perform lazy initialization. This
approach relies on developers following a convention when they write a class
that implements the <code>Component</code> interface. I illustrate the
convention by an example. Let's assume you write a class called
<code>com.example.myproject.FooComponent</code> and you want Camel to
automatically recognize this by the name "foo". To do this, you have to write a
properties file called "META-INF/services/org/apache/camel/component/foo"
(without a ".properties" file extension) that has a single entry in it called
<code>class</code>, the value of which is the fully-scoped name of your class.
This is shown below.</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeHeader
panelHeader pdl" style="border-bottom-width:
1px;"><b>META-INF/services/org/apache/camel/component/foo</b></div><div
class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+class=com.example.myproject.FooComponent
+]]></script>
+</div></div>
+<p>If you want Camel to also recognize the class by the name "bar" then you
write another properties file in the same directory called "bar" that has the
same contents. Once you have written the properties file(s), you create a jar
file that contains the <code>com.example.myproject.FooComponent</code> class
and the properties file(s), and you add this jar file to your CLASSPATH. Then,
when application-level code invokes <code>createEndpoint("foo:...")</code> on a
<code>CamelContext</code> object, Camel will find the "foo"" properties file on
the CLASSPATH, get the value of the <code>class</code> property from that
properties file, and use reflection APIs to create an instance of the specified
class.<br clear="none">
+As I said in <a shape="rect" href="#BookInOnePage-endpoint">Section 4.1
("Endpoint")</a>, Camel provides out-of-the-box support for numerous
communication technologies. The out-of-the-box support consists of classes that
implement the <code>Component</code> interface plus properties files that
enable a <code>CamelContext</code> object to populate its map of named
<code>Component</code> objects.<br clear="none">
+Earlier in this section I gave the following example of calling
<code>CamelContext.getEndpoint()</code>.</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+myCamelContext.getEndpoint("pop3://john.sm...@mailserv.example.com?password=myPassword");
+]]></script>
+</div></div>
+<p>When I originally gave that example, I said that the parameter to
<code>getEndpoint()</code> was a URI. I said that because the online Camel
documentation and the Camel source code both claim the parameter is a URI. In
reality, the parameter is restricted to being a URL. This is because when Camel
extracts the component name from the parameter, it looks for the first ":",
which is a simplistic algorithm. To understand why, recall from <a shape="rect"
href="#BookInOnePage-url-uri-urn-iri">Section 4.4 ("The Meaning of URL, URI,
URN and IRI")</a> that a URI can be a URL <em>or</em> a URN. Now consider the
following calls to <code>getEndpoint</code>.</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+myCamelContext.getEndpoint("pop3:...");
+myCamelContext.getEndpoint("jms:...");
+myCamelContext.getEndpoint("urn:foo:...");
+myCamelContext.getEndpoint("urn:bar:...");
+]]></script>
+</div></div>
+<p>Camel identifies the components in the above example as "pop3", "jms",
"urn" and "urn". It would 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 you must
identify an endpoint with a URL (a string of the form "<scheme>:...")
rather than with a URN (a string of the form "urn:<scheme>:..."). This
lack of proper support for URNs means the you should consider the parameter to
<code>getEndpoint()</code> as being a URL rather than (as claimed) a URI.</p>
+
+<p><span class="confluence-anchor-link"
id="BookInOnePage-message-and-exchange"></span></p>
+<h3 id="BookInOnePage-MessageandExchange">Message and Exchange</h3>
+<p>The <code>Message</code> interface provides an abstraction for a single
message, such as a request, reply or exception message.<br clear="none">
+There are concrete classes that implement the <code>Message</code> interface
for each Camel-supported communications technology. For example, the
<code>JmsMessage</code> class provides a JMS-specific implementation of the
<code>Message</code> interface. The public API of the <code>Message</code>
interface provides get- and set-style methods to access the <em>message
id</em>, <em>body</em> and individual <em>header</em> fields of a messge.<br
clear="none">
+The <code>Exchange</code> interface provides an abstraction for an exchange of
messages, that is, a request message and its corresponding reply or exception
message. In Camel terminology, the request, reply and exception messages are
called <em>in</em>, <em>out</em> and <em>fault</em> messages.<br clear="none">
+There are concrete classes that implement the <code>Exchange</code> interface
for each Camel-supported communications technology. For example, the
<code>JmsExchange</code> class provides a JMS-specific implementation of the
<code>Exchange</code> interface. The public API of the <code>Exchange</code>
interface is quite limited. This is intentional, and it is expected that each
class that implements this interface will provide its own technology-specific
operations.<br clear="none">
+Application-level programmers rarely access the <code>Exchange</code>
interface (or classes that implement it) directly. However, many classes in
Camel are generic types that are instantiated on (a class that implements)
<code>Exchange</code>. Because of this, the <code>Exchange</code> interface
appears a lot in the generic signatures of classes and methods.</p>
+
+<h3 id="BookInOnePage-Processor">Processor</h3>
+<p>The <code>Processor</code> interface represents a class that processes a
message. The signature of this interface is shown below.</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeHeader
panelHeader pdl" style="border-bottom-width: 1px;"><b>Processor</b></div><div
class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+package org.apache.camel;
+public interface Processor {
+ void process(Exchange exchange) throws Exception;
+}
+]]></script>
+</div></div>
+<p>Notice that the parameter to the <code>process()</code> method is an
<code>Exchange</code> rather than a <code>Message</code>. This provides
flexibility. For example, an implementation of this method initially might call
<code>exchange.getIn()</code> to get the input message and process it. If an
error occurs during processing then the method can call
<code>exchange.setException()</code>.<br clear="none">
+An application-level developer might implement the <code>Processor</code>
interface with a class that executes some business logic. However, there are
many classes in the Camel library that implement the <code>Processor</code>
interface in a way that provides support for a design pattern in the <a
shape="rect" href="#BookInOnePage-eip-book">EIP book</a>. For example,
<code>ChoiceProcessor</code> implements the message router pattern, that is, it
uses a cascading if-then-else statement to route a message from an input queue
to one of several output queues. Another example is the
<code>FilterProcessor</code> class which discards messages that do not satisfy
a stated <em>predicate</em> (that is, condition).</p>
+
+<p><span class="confluence-anchor-link" id="BookInOnePage-routes"></span></p>
+<h3 id="BookInOnePage-Routes,RouteBuildersandJavaDSL">Routes, RouteBuilders
and Java DSL</h3>
+<p>A <em>route</em> is the step-by-step movement of a <code>Message</code>
from an input queue, through arbitrary types of decision making (such as
filters and routers) to a destination queue (if any). Camel provides two ways
for an application developer to specify routes. One way is to specify route
information 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 <em>DSL</em>
(domain-specific language).</p>
+
+<h4 id="BookInOnePage-IntroductiontoJavaDSL">Introduction to Java DSL</h4>
+<p>For many people, the term "domain-specific language" implies a compiler or
interpreter that can process an input file containing keywords and syntax
specific to a particular domain. This is <em>not</em> the approach taken by
Camel. Camel documentation consistently uses the term "Java DSL" instead of
"DSL", but this does not entirely avoid potential confusion. The Camel "Java
DSL" is a class library that can be used in a way that looks almost like a DSL,
except that it has a bit of Java syntactic baggage. You can see this in the
example below. Comments afterwards explain some of the constructs used in the
example.</p>
+<div class="code panel pdl" style="border-width: 1px;"><div class="codeHeader
panelHeader pdl" style="border-bottom-width: 1px;"><b>Example of Camel's "Java
DSL"</b></div><div class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
+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);
+]]></script>
+</div></div>
+<p>The first line in the above example creates an object which is an instance
of an anonymous subclass of <code>RouteBuilder</code> with the specified
<code>configure()</code> method.<br clear="none">
+The <code>CamelContext.addRoutes(RouterBuilder builder)</code> method invokes
<code>builder.setContext(this)</code> – so the <code>RouteBuilder</code>
object knows which <code>CamelContext</code> object it is associated with
– and then invokes <code>builder.configure()</code>. The body of
<code>configure()</code> invokes methods such as <code>from()</code>,
<code>filter()</code>, <code>choice()</code>, <code>when()</code>,
<code>isEqualTo()</code>, <code>otherwise()</code> and <code>to()</code>.<br
clear="none">
+The <code>RouteBuilder.from(String uri)</code> method invokes
<code>getEndpoint(uri)</code> on the <code>CamelContext</code> associated with
the <code>RouteBuilder</code> object to get the specified <code>Endpoint</code>
and then puts a <code>FromBuilder</code> "wrapper" around this
<code>Endpoint</code>. The <code>FromBuilder.filter(Predicate predicate)</code>
method creates a <code>FilterProcessor</code> object for the
<code>Predicate</code> (that is, condition) object built from the
<code>header("foo").isEqualTo("bar")</code> expression. In this way, these
operations incrementally build up a <code>Route</code> object (with a
<code>RouteBuilder</code> wrapper around it) and add it to the
<code>CamelContext</code> object associated with the
<code>RouteBuilder</code>.</p>
+
+<h4 id="BookInOnePage-CritiqueofJavaDSL">Critique of Java DSL</h4>
+<p>The online Camel documentation compares Java DSL favourably against the
alternative of configuring routes and endpoints in a XML-based Spring
configuration file. In particular, Java DSL is less verbose than its XML
counterpart. In addition, many integrated development environments (IDEs)
provide an auto-completion feature in their editors. This auto-completion
feature works with Java DSL, thereby making it easier for developers to write
Java DSL.<br clear="none">
+However, there is another option that the Camel documentation neglects to
consider: that of writing a parser that can process DSL stored in, say, an
external file. Currently, Camel does not provide such a DSL parser, and I do
not know if it is on the "to do" list of the Camel maintainers. I think that a
DSL parser would offer a significant benefit over the current Java DSL. In
particular, the DSL would have a syntactic definition that could be expressed
in a relatively short BNF form. The effort required by a Camel user to learn
how to use DSL by reading this BNF would almost certainly be significantly less
than the effort currently required to study the API of the
<code>RouterBuilder</code> classes.</p>
+
+
+<h3 id="BookInOnePage-ContinueLearningaboutCamel">Continue Learning about
Camel</h3>
+
+<p>Return to the main <a shape="rect" href="getting-started.html">Getting
Started</a> page for additional introductory reference information.</p>
+<div class="chapter" id="chapter-architecture">
+<h1 id="BookInOnePage-Architecture">Architecture</h1>
+
+Camel uses a Java based <a shape="rect" href="dsl.html">Routing Domain
Specific Language (DSL)</a> or an <a shape="rect"
href="xml-configuration.html">Xml Configuration</a> to configure <a
shape="rect" href="routes.html">routing and mediation rules</a> which are added
to a <a shape="rect" class="external-link"
href="http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/CamelContext.html";>CamelContext</a>
to implement the various <a shape="rect"
href="enterprise-integration-patterns.html">Enterprise Integration
Patterns</a>.
+
+<p>At a high level Camel consists of a <a shape="rect" class="external-link"
href="http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/CamelContext.html";>CamelContext</a>
which contains a collection of <a shape="rect"
href="component.html">Component</a> instances. A <a shape="rect"
href="component.html">Component</a> is essentially a factory of <a shape="rect"
href="endpoint.html">Endpoint</a> instances. You can explicitly configure <a
shape="rect" href="component.html">Component</a> instances in Java code or an
IoC container like Spring or Guice, or they can be auto-discovered using <a
shape="rect" href="uris.html">URIs</a>. </p>
+
+<p>An <a shape="rect" href="endpoint.html">Endpoint</a> acts rather like a URI
or URL in a web application or a Destination in a JMS system; you can
communicate with an endpoint; either sending messages to it or consuming
messages from it. You can then create a <a shape="rect" class="external-link"
href="http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Producer.html";>Producer</a>
or <a shape="rect" class="external-link"
href="http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/Consumer.html";>Consumer</a>
on an <a shape="rect" href="endpoint.html">Endpoint</a> to exchange messages
with it.</p>
+
+<p>The <a shape="rect" href="dsl.html">DSL</a> makes heavy use of pluggable <a
shape="rect" href="languages.html">Languages</a> to create an <a shape="rect"
href="expression.html">Expression</a> or <a shape="rect"
href="predicate.html">Predicate</a> to make a truly powerful DSL which is
extensible to the most suitable language depending on your needs. The following
languages are supported</p>
+
+<ul><li><a shape="rect" href="bean-language.html">Bean Language</a> for using
Java for expressions</li><li><a shape="rect"
href="constant.html">Constant</a></li><li>the unified <a shape="rect"
href="el.html">EL</a> from JSP and JSF</li><li><a shape="rect"
href="header.html">Header</a></li><li><a shape="rect"
href="jsonpath.html">JSonPath</a></li><li><a shape="rect"
href="jxpath.html">JXPath</a></li><li><a shape="rect"
href="mvel.html">Mvel</a></li><li><a shape="rect"
href="ognl.html">OGNL</a></li><li><a shape="rect" href="ref-language.html">Ref
Language</a></li><li><a shape="rect"
href="exchangeproperty.html">ExchangeProperty</a> / <a shape="rect"
href="property.html">Property</a></li><li><a shape="rect"
href="scripting-languages.html">Scripting Languages</a> such as<ul><li><a
shape="rect" href="beanshell.html">BeanShell</a></li><li><a shape="rect"
href="javascript.html">JavaScript</a></li><li><a shape="rect"
href="groovy.html">Groovy</a></li><li><a shape="rect" href="python.ht
ml">Python</a></li><li><a shape="rect" href="php.html">PHP</a></li><li><a
shape="rect" href="ruby.html">Ruby</a></li></ul></li><li><a shape="rect"
href="simple.html">Simple</a><ul><li><a shape="rect"
href="file-language.html">File Language</a></li></ul></li><li><a shape="rect"
href="spel.html">Spring Expression Language</a></li><li><a shape="rect"
href="sql.html">SQL</a></li><li><a shape="rect"
href="tokenizer.html">Tokenizer</a></li><li><a shape="rect"
href="xpath.html">XPath</a></li><li><a shape="rect"
href="xquery.html">XQuery</a></li><li><a shape="rect"
href="vtd-xml.html">VTD-XML</a></li></ul><p>Most of these languages is also
supported used as <a shape="rect"
href="annotation-based-expression-language.html">Annotation Based Expression
Language</a>.</p>
+
+<p>For a full details of the individual languages see the <a shape="rect"
href="book-languages-appendix.html">Language Appendix</a></p>
+
+<h2 id="BookInOnePage-URIs">URIs</h2>
+
+<p>Camel makes extensive use of URIs to allow you to refer to endpoints which
are lazily created by a <a shape="rect" href="component.html">Component</a> if
you refer to them within <a shape="rect" href="routes.html">Routes</a>.</p>
+
+<div class="confluence-information-macro confluence-information-macro-tip"><p
class="title">important</p><span class="aui-icon aui-icon-small
aui-iconfont-approve confluence-information-macro-icon"></span><div
class="confluence-information-macro-body">
+<p>Make sure to read <a shape="rect"
href="how-do-i-configure-endpoints.html">How do I configure endpoints</a> to
learn more about configuring endpoints. For example how to refer to beans in
the <a shape="rect" href="registry.html">Registry</a> or how to use raw values
for password options, and using <a shape="rect"
href="using-propertyplaceholder.html">property placeholders</a>
etc.</p></div></div>
+
+<h3 id="BookInOnePage-CurrentSupportedURIs">Current Supported URIs</h3>
+
+<div class="table-wrap"><table class="confluenceTable"><tbody><tr><th
colspan="1" rowspan="1" class="confluenceTh"><p>Component / ArtifactId /
URI</p></th><th colspan="1" rowspan="1"
class="confluenceTh"><p>Description</p></th></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p><a shape="rect" href="ahc.html">AHC</a> /
camel-ahc</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[ahc:http[s]://hostName[:port][/resourceUri][?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>To call
external HTTP services using <a shape="rect" class="external-link"
href="http://github.com/sonatype/async-http-client"; rel="nofollow">Async Http
Client</a></p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="ahc-ws.html">AHC-WS</a><span> /
camel-ahc-ws</span></p><div class="code panel pdl" style="border-width:
1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[ahc-ws[s]://hostName[:port][/resourceUri][?options]
+]]></script>
+</div></div><p><span><br clear="none"></span></p></td><td colspan="1"
rowspan="1" class="confluenceTd"> To exchange data with external Websocket
servers using <a shape="rect" class="external-link"
href="http://github.com/sonatype/async-http-client"; rel="nofollow">Async Http
Client</a></td></tr><tr><td colspan="1" rowspan="1" class="confluenceTd"><p><a
shape="rect" href="amqp.html">AMQP</a> / camel-amqp</p><div class="code panel
pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[amqp:[queue:|topic:]destinationName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
Messaging with <a shape="rect" class="external-link"
href="http://www.amqp.org/"; rel="nofollow">AMQP
protocol</a></p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="apns.html">APNS</a> /
camel-apns</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[apns:<notify|consumer>[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
sending notifications to Apple iOS devices</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p><a shape="rect"
href="atmosphere-websocket.html">Atmosphere-Websocket</a><span> </span><span>
/ camel-atmosphere-websocket</span></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[atmosphere-websocket:///relative
path[?options]
+]]></script>
+</div></div><p><span><br clear="none"></span></p></td><td colspan="1"
rowspan="1" class="confluenceTd"> <span>To exchange data with external
Websocket clients using </span><a shape="rect" class="external-link"
href="https://github.com/Atmosphere/atmosphere";
rel="nofollow">Atmosphere</a></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="atom.html">Atom</a> /
camel-atom</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[atom:atomUri[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Working
with <a shape="rect" class="external-link"
href="http://incubator.apache.org/abdera/";>Apache Abdera</a> for atom
integration, such as consuming an atom feed.</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p><a shape="rect" href="avro.html">Avro</a> /
camel-avro</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[avro:[transport]:[host]:[port][/messageName][?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Working
with <a shape="rect" class="external-link"
href="http://avro.apache.org/";>Apache Avro</a> for data
serialization.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="aws-cw.html">AWS-CW</a> / <a
shape="rect" href="aws.html">camel-aws</a></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[aws-cw://namespace[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
working with <a shape="rect" class="external-link"
href="http://aws.amazon.com/cloudwatch/"; rel="nofollow">Amazon's CloudWatch
(CW)</a>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="aws-ddb.html">AWS-DDB</a> / <a
shape="rect" href="aws.html">camel-aws</a></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[aws-ddb://tableName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
working with <a shape="rect" class="external-link"
href="http://aws.amazon.com/dynamodb/"; rel="nofollow">Amazon's DynamoDB
(DDB)</a>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="aws-ec2.html">AWS-EC2</a> / <a
shape="rect" href="aws.html">camel-aws</a></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[aws-ec2://label[?options]]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
working with <a shape="rect" class="external-link"
href="http://aws.amazon.com/ec2/"; rel="nofollow">Amazon's Elastic Compute Cloud
(EC2)</a>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="aws-sdb.html">AWS-SDB</a> / <a
shape="rect" href="aws.html">camel-aws</a></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[aws-sdb://domainName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
working with <a shape="rect" class="external-link"
href="http://aws.amazon.com/simpledb/"; rel="nofollow">Amazon's SimpleDB
(SDB)</a>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="aws-ses.html">AWS-SES</a> / <a
shape="rect" href="aws.html">camel-aws</a></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[aws-ses://from[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
working with <a shape="rect" class="external-link"
href="http://aws.amazon.com/ses/"; rel="nofollow">Amazon's Simple Email Service
(SES)</a>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="aws-sns.html">AWS-SNS</a> / <a
shape="rect" href="aws.html">camel-aws</a></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[aws-sns://topicName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
Messaging with <a shape="rect" class="external-link"
href="http://aws.amazon.com/sns/"; rel="nofollow">Amazon's Simple Notification
Service (SNS)</a>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="aws-sqs.html">AWS-SQS</a> / <a
shape="rect" href="aws.html">camel-aws</a></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[aws-sqs://queueName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
Messaging with <a shape="rect" class="external-link"
href="http://aws.amazon.com/sqs/"; rel="nofollow">Amazon's Simple Queue Service
(SQS)</a>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="aws-swf.html">AWS-SWF</a> / <a
shape="rect" href="aws.html">camel-aws</a></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[aws-swf://<worfklow|activity>[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
Messaging with <a shape="rect" class="external-link"
href="http://aws.amazon.com/swf/"; rel="nofollow">Amazon's Simple Workflow
Service (SWF)</a>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="aws-s3.html">AWS-S3</a> / <a
shape="rect" href="aws.html">camel-aws</a></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[aws-s3://bucketName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
working with <a shape="rect" class="external-link"
href="http://aws.amazon.com/s3/"; rel="nofollow">Amazon's Simple Storage Service
(S3)</a>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="bean.html">Bean</a> /
camel-core</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[bean:beanName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Uses the
<a shape="rect" href="bean-binding.html">Bean Binding</a> to bind message
exchanges to beans in the <a shape="rect" href="registry.html">Registry</a>. Is
also used for exposing and invoking POJO (Plain Old Java
Objects).</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect"
href="beanstalk.html">Beanstalk</a><span> / camel-beanstalk</span></p><div
class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[beanstalk:hostname:port/tube[?options]
+]]></script>
+</div></div><p><span><br clear="none"></span></p></td><td colspan="1"
rowspan="1" class="confluenceTd">For working with <a shape="rect"
class="external-link" href="http://aws.amazon.com/elasticbeanstalk/";
rel="nofollow">Amazon's Beanstalk</a>.</td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="bean-validator.html">Bean
Validator</a> / camel-bean-validator</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[bean-validator:label[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Validates
the payload of a message using the Java Validation API (<a shape="rect"
class="external-link" href="http://jcp.org/en/jsr/detail?id=303";
rel="nofollow">JSR 303</a> and JAXP Validation) and its reference
implementation <a shape="rect" class="external-link"
href="http://docs.jboss.org/hibernate/stable/validator/reference/en/html_single/";
rel="nofollow">Hibernate Validator</a></p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p><a shape="rect" href="box.html">Box</a> /
camel-box</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[box://endpoint-prefix/endpoint?[options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For
uploading, downloading and managing files, managing files, folders, groups,
collaborations, etc. on Box.com.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="browse.html">Browse</a> /
camel-core</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[browse:someName
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Provides
a simple <a shape="rect" href="browsableendpoint.html">BrowsableEndpoint</a>
which can be useful for testing, visualisation tools or debugging. The
exchanges sent to the endpoint are all available to be
browsed.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="cache.html">Cache</a> /
camel-cache</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[cache://cacheName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>The cache
component facilitates creation of caching endpoints and processors using <a
shape="rect" class="external-link" href="http://ehcache.org/";
rel="nofollow">EHCache</a> as the cache implementation.</p></td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p><a shape="rect"
href="cassandra.html">Cassandra</a> / <span style="color:
rgb(0,0,0);">camel-cassandraql</span></p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[cql:localhost/keyspace]]></script>
+</div></div><p><span style="color: rgb(0,0,0);"><br
clear="none"></span></p></td><td colspan="1" rowspan="1"
class="confluenceTd">For integrating with <a shape="rect" class="external-link"
href="http://cassandra.apache.org/";>Apache Cassandra</a>.</td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p><a shape="rect"
href="class.html">Class</a> / camel-core</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[class:className[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Uses the
<a shape="rect" href="bean-binding.html">Bean Binding</a> to bind message
exchanges to beans in the <a shape="rect" href="registry.html">Registry</a>. Is
also used for exposing and invoking POJO (Plain Old Java
Objects).</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="chunk.html">Chunk</a> /
camel-chunk</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[chunk:templateName[?options]]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Generates
a response using a <a shape="rect" class="external-link"
href="http://www.x5software.com/chunk/examples/ChunkExample";
rel="nofollow">Chunk</a> template</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="cmis.html">CMIS</a> /
camel-cmis</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[cmis://cmisServerUrl[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Uses the
<a shape="rect" class="external-link"
href="http://chemistry.apache.org/java/opencmis.html";>Apache Chemistry</a>
client API to interface with CMIS supporting CMS</p></td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p><a shape="rect"
href="cometd.html">Cometd</a> / camel-cometd</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[cometd://hostName:port/channelName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Used to
deliver messages using the <a shape="rect" class="external-link"
href="http://docs.codehaus.org/display/JETTY/Cometd+(aka+Bayeux)"
rel="nofollow">jetty cometd implementation</a> of the <a shape="rect"
class="external-link"
href="http://svn.xantus.org/shortbus/trunk/bayeux/bayeux.html";
rel="nofollow">bayeux protocol</a></p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="context.html">Context</a> /
camel-context</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[context:camelContextId:localEndpointName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Used to
refer to endpoints within a separate CamelContext to provide a simple <a
shape="rect" href="context.html">black box composition</a> approach so that
routes can be combined into a CamelContext and then used as a black box
component inside other routes in other CamelContexts</p></td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p><a shape="rect"
href="controlbus-component.html">ControlBus</a> / camel-core</p><div
class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[controlbus:command[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p><a
shape="rect" href="controlbus.html">ControlBus</a> EIP that allows to send
messages to <a shape="rect" href="endpoint.html">Endpoint</a>s for managing and
monitoring your Camel applications.</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p><a shape="rect"
href="couchdb.html">CouchDB</a> / camel-couchdb</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[couchdb:hostName[:port]/database[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>To
integrate with <a shape="rect" class="external-link"
href="http://couchdb.apache.org/";>Apache CouchDB</a>.</p></td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p><a shape="rect"
href="crypto-digital-signatures.html">Crypto (Digital Signatures)</a> /
camel-crypto</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[crypto:<sign|verify>:name[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Used to
sign and verify exchanges using the Signature Service of the Java Cryptographic
Extension.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="cxf.html">CXF</a> /
camel-cxf</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[cxf:<bean:cxfEndpoint|//someAddress>[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Working
with <a shape="rect" class="external-link" href="http://apache.org/cxf/";>Apache
CXF</a> for web services integration</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p><a shape="rect"
href="cxf-bean-component.html">CXF Bean </a> / camel-cxf</p><div class="code
panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[cxfbean:serviceBeanRef[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Proceess
the exchange using a JAX WS or JAX RS annotated bean from the registry.
Requires less configuration than the above CXF Component</p></td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p><a shape="rect"
href="cxfrs.html">CXFRS</a> / camel-cxf</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[cxfrs:<bean:rsEndpoint|//address>[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>Working
with <a shape="rect" class="external-link" href="http://apache.org/cxf/";>Apache
CXF</a> for REST services integration</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p><a shape="rect"
href="dataformat-component.html">DataFormat</a> / camel-core</p><div
class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[dataformat:name:<marshal|unmarshal>[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>for
working with <a shape="rect" href="data-format.html">Data Format</a>s as if it
was a regular Component supporting Endpoints and URIs.</p></td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p><a shape="rect"
href="dataset.html">DataSet</a> / camel-core</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[dataset:name[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>For load
& soak testing the <a shape="rect" class="external-link"
href="http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/component/dataset/DataSet.html";>DataSet</a>
provides a way to create huge numbers of messages for sending to <a
shape="rect" href="components.html">Components</a> or asserting that they are
consumed correctly</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="direct.html">Direct</a> /
camel-core</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[direct:someName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Synchronous call to another endpoint from
<strong>same</strong> CamelContext.</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p><a shape="rect"
href="direct-vm.html">Direct-VM</a> / camel-core</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[direct-vm:someName[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Synchronous call to another endpoint in another
CamelContext running in the same JVM.</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p><a shape="rect" href="dns.html">DNS</a> /
camel-dns</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: plain; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[dns:operation[?options]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>To lookup
domain information and run DNS queries using <a shape="rect"
class="external-link" href="http://www.xbill.org/dnsjava/";
rel="nofollow">DNSJava</a></p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="disruptor.html">Disruptor</a> /
camel-disruptor</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[disruptor:someName[?<option>]
+disruptor-vm:someName[?<option>]
+]]></script>
+</div></div></td><td colspan="1" rowspan="1" class="confluenceTd"><p>To
provide the implementation of <a shape="rect" href="seda.html">SEDA</a> which
is based on <a shape="rect" class="external-link"
href="https://github.com/LMAX-Exchange/disruptor";
rel="nofollow">disruptor</a></p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><span><a shape="rect" href="docker.html">Docker</a> /
camel-docker</span></p><div class="code panel pdl" style="border-width:
1px;"><div class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[docker://[operation]?[options]]]></script>
+</div></div><p><span><br clear="none"></span></p></td><td colspan="1"
rowspan="1" class="confluenceTd"> To communicate with <a shape="rect"
class="external-link" href="https://www.docker.com/";
rel="nofollow">Docker</a></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><a shape="rect" href="dozer.html">Dozer</a> /
camel-dozer</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
+<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[dozer://name?[options]]]></script>
[... 26650 lines stripped ...]
![https://cwiki.apache.org/confluence/s/en_GB/5982/f2b47fb3d636c8bc9fd0b11c0ec6d0ae18646be7.1/_/images/icons/emoticons/smile.png"](https://cwiki.apache.org/confluence/s/en_GB/5982/f2b47fb3d636c8bc9fd0b11c0ec6d0ae18646be7.1/_/images/icons/emoticons/smile.png"){kind=link}
![https://cwiki.apache.org/confluence/s/en_GB/5982/f2b47fb3d636c8bc9fd0b11c0ec6d0ae18646be7.1/_/images/icons/emoticons/wink.png"](https://cwiki.apache.org/confluence/s/en_GB/5982/f2b47fb3d636c8bc9fd0b11c0ec6d0ae18646be7.1/_/images/icons/emoticons/wink.png"){kind=link}