The Apache Camel project has been designed to work easily with ActiveMQ - and comes embedded in both the clients and the broker from ActiveMQ 5.0 onwards.

Apache Camel supports an extensive range of integration patterns to make integration very simple! :

Enterprise Integration Patterns

Camel supports most of the Enterprise Integration Patterns from the excellent book by Gregor Hohpe and Bobby Woolf.

If you are new to Camel you might want to try the Getting Started in the User Guide before attempting to implement these patterns.

The EIP icons library is available as a Visio stencil file adapted to render the icons with the Camel color : sand. Download it here for your presentation, functional and technical analysis documents. The original EIP stencil is also available in OpenOffice 3.x Draw (thanks to Marco Garbelini) , Microsoft Visio, or Omnigraffle.

Messaging Systems

Message Channel How does one application communicate with another using messaging?
Message How can two applications connected by a message channel exchange a piece of information?
Pipes and Filters How can we perform complex processing on a message while maintaining independence and flexibility?
Message Router How can you decouple individual processing steps so that messages can be passed to different filters depending on a set of conditions?
Message Translator How can systems using different data formats communicate with each other using messaging?
Message Endpoint How does an application connect to a messaging channel to send and receive messages?

Messaging Channels

Point to Point Channel How can the caller be sure that exactly one receiver will receive the document or perform the call?
Publish Subscribe Channel How can the sender broadcast an event to all interested receivers?
Dead Letter Channel What will the messaging system do with a message it cannot deliver?
Guaranteed Delivery How can the sender make sure that a message will be delivered, even if the messaging system fails?
Message Bus What is an architecture that enables separate applications to work together, but in a de-coupled fashion such that applications can be easily added or removed without affecting the others?

Message Construction

Event Message How can messaging be used to transmit events from one application to another?
Request Reply When an application sends a message, how can it get a response from the receiver?
Correlation Identifier How does a requestor that has received a reply know which request this is the reply for?
Return Address How does a replier know where to send the reply?

Message Routing

Content Based Router How do we handle a situation where the implementation of a single logical function (e.g., inventory check) is spread across multiple physical systems?
Message Filter How can a component avoid receiving uninteresting messages?
Dynamic Router How can you avoid the dependency of the router on all possible destinations while maintaining its efficiency?
Recipient List How do we route a message to a list of (static or dynamically) specified recipients?
Splitter How can we process a message if it contains multiple elements, each of which may have to be processed in a different way?
Aggregator How do we combine the results of individual, but related messages so that they can be processed as a whole?
Resequencer How can we get a stream of related but out-of-sequence messages back into the correct order?
Composed Message Processor How can you maintain the overall message flow when processing a message consisting of multiple elements, each of which may require different processing?
Scatter-Gather How do you maintain the overall message flow when a message needs to be sent to multiple recipients, each of which may send a reply?
Routing Slip How do we route a message consecutively through a series of processing steps when the sequence of steps is not known at design-time and may vary for each message?
Throttler How can I throttle messages to ensure that a specific endpoint does not get overloaded, or we don't exceed an agreed SLA with some external service?
Sampling How can I sample one message out of many in a given period to avoid downstream route does not get overloaded?
Delayer How can I delay the sending of a message?
Load Balancer How can I balance load across a number of endpoints?
Multicast How can I route a message to a number of endpoints at the same time?
Loop How can I repeat processing a message in a loop?

Message Transformation

Content Enricher How do we communicate with another system if the message originator does not have all the required data items available?
Content Filter How do you simplify dealing with a large message, when you are interested only in a few data items?
Claim Check How can we reduce the data volume of message sent across the system without sacrificing information content?
Normalizer How 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

Messaging Mapper How do you move data between domain objects and the messaging infrastructure while keeping the two independent of each other?
Event Driven Consumer How can an application automatically consume messages as they become available?
Polling Consumer How can an application consume a message when the application is ready?
Competing Consumers How can a messaging client process multiple messages concurrently?
Message Dispatcher How can multiple consumers on a single channel coordinate their message processing?
Selective Consumer How can a message consumer select which messages it wishes to receive?
Durable Subscriber How can a subscriber avoid missing messages while it's not listening for them?
Idempotent Consumer How can a message receiver deal with duplicate messages?
Transactional Client How can a client control its transactions with the messaging system?
Messaging Gateway How do you encapsulate access to the messaging system from the rest of the application?
Service Activator How can an application design a service to be invoked both via various messaging technologies and via non-messaging techniques?

System Management

ControlBus How can we effectively administer a messaging system that is distributed across multiple platforms and a wide geographic area?
Detour How can you route a message through intermediate steps to perform validation, testing or debugging functions?
Wire Tap How do you inspect messages that travel on a point-to-point channel?
Message History How can we effectively analyze and debug the flow of messages in a loosely coupled system?
Log How can I log processing a message?

It also supports a wide range of transport binding components:

Components Included

Camel includes the following Component implementations via URIs.

Component / ArtifactId / URI Description
AHC / camel-ahc 
ahc:hostname:[port]
To call external HTTP services using Async Http Client
AMQP / camel-amqp 
amqp:[topic:]destinationName
For Messaging with AMQP protocol
APNS / camel-apns 
apns:notify[?options]
For sending notifications to Apple iOS devices
Atom / camel-atom 
atom:uri
Working with Apache Abdera for atom integration, such as consuming an atom feed.
Avro / camel-avro 
avro:http://hostname[:port][?options]
Working with Apache Avro for data serialization.
AWS-CW / camel-aws 
aws-cw://namespace[?options]
For working with Amazon's CloudWatch (CW).
AWS-DDB / camel-aws 
aws-ddb://tableName[?options]
For working with Amazon's DynamoDB (DDB).
AWS-SDB / camel-aws 
aws-sdb://domainName[?options]
For working with Amazon's SimpleDB (SDB).
AWS-SES / camel-aws 
aws-ses://from[?options]
For working with Amazon's Simple Email Service (SES).
AWS-SNS / camel-aws 
aws-sns://topicname[?options]
For Messaging with Amazon's Simple Notification Service (SNS).
AWS-SQS / camel-aws 
aws-sqs://queuename[?options]
For Messaging with Amazon's Simple Queue Service (SQS).
AWS-S3 / camel-aws 
aws-s3://bucketname[?options]
For working with Amazon's Simple Storage Service (S3).
Bean / camel-core 
bean:beanName[?method=someMethod]
Uses the Bean Binding to bind message exchanges to beans in the Registry. Is also used for exposing and invoking POJO (Plain Old Java Objects).
Bean Validation / camel-bean-validator 
bean-validator:something
Validates the payload of a message using the Java Validation API (JSR 303 and JAXP Validation) and its reference implementation Hibernate Validator
Browse / camel-core 
browse:someName
Provides a simple BrowsableEndpoint which can be useful for testing, visualisation tools or debugging. The exchanges sent to the endpoint are all available to be browsed.
Cache / camel-cache 
cache://cachename[?options]
The cache component facilitates creation of caching endpoints and processors using EHCache as the cache implementation.
Class / camel-core 
class:className[?method=someMethod]
Uses the Bean Binding to bind message exchanges to beans in the Registry. Is also used for exposing and invoking POJO (Plain Old Java Objects).
CMIS / camel-cmis 
cmis://cmisServerUrl[?options]
Uses the Apache Chemistry client API to interface with CMIS supporting CMS
Cometd / camel-cometd 
cometd://host:port/channelname
Used to deliver messages using the jetty cometd implementation of the bayeux protocol
Context / camel-context 
context:camelContextId:localEndpointName
Used to refer to endpoints within a separate CamelContext to provide a simple black box composition approach so that routes can be combined into a CamelContext and then used as a black box component inside other routes in other CamelContexts
ControlBus / camel-core 
controlbus:command[?options]
ControlBus EIP that allows to send messages to Endpoints for managing and monitoring your Camel applications.
Crypto (Digital Signatures) / camel-crypto 
crypto:sign:name[?options]
crypto:verify:name[?options]
Used to sign and verify exchanges using the Signature Service of the Java Cryptographic Extension.
CXF / camel-cxf 
cxf:address[?serviceClass=...]
Working with Apache CXF for web services integration
CXF Bean / camel-cxf 
cxf:bean name
Proceess the exchange using a JAX WS or JAX RS annotated bean from the registry. Requires less configuration than the above CXF Component
CXFRS / camel-cxf 
cxfrs:address[?resourcesClasses=...]
Working with Apache CXF for REST services integration
DataSet / camel-core 
dataset:name
For load & soak testing the DataSet provides a way to create huge numbers of messages for sending to Components or asserting that they are consumed correctly
Direct / camel-core 
direct:name
Synchronous call to another endpoint from same CamelContext.
Direct-VM / camel-core 
direct-vm:name
Synchronous call to another endpoint in another CamelContext running in the same JVM.
DNS / camel-dns 
dns:operation
To lookup domain information and run DNS queries using DNSJava
EJB / camel-ejb 
ejb:ejbName[?method=someMethod]
Uses the Bean Binding to bind message exchanges to EJBs. It works like the Bean component but just for accessing EJBs. Supports EJB 3.0 onwards.
ElasticSearch / camel-elasticsearch 
elasticsearch://clusterName
For interfacing with an ElasticSearch server.
Event / camel-spring 
event://default
spring-event://default
Working with Spring ApplicationEvents
EventAdmin / camel-eventadmin 
eventadmin:topic
Receiving OSGi EventAdmin events
Exec / camel-exec 
exec://executable[?options]
For executing system commands
File / camel-core 
file://nameOfFileOrDirectory
Sending messages to a file or polling a file or directory.
Flatpack / camel-flatpack 
flatpack:[fixed|delim]:configFile
Processing fixed width or delimited files or messages using the FlatPack library
FOP / camel-fop 
fop:outputFormat
Renders the message into different output formats using Apache FOP
FreeMarker / camel-freemarker 
freemarker:someTemplateResource
Generates a response using a FreeMarker template
FTP / camel-ftp 
ftp://host[:port]/fileName
Sending and receiving files over FTP.
FTPS / camel-ftp 
ftps://host[:port]/fileName
Sending and receiving files over FTP Secure (TLS and SSL).
GAuth / camel-gae 
gauth://name[?options]
Used by web applications to implement an OAuth consumer. See also Camel Components for Google App Engine.
GHttp / camel-gae 
ghttp://hostname[:port][/path][?options]
ghttp:///path[?options]
Provides connectivity to the URL fetch service of Google App Engine but can also be used to receive messages from servlets. See also Camel Components for Google App Engine.
GLogin / camel-gae 
glogin://hostname[:port][?options]
Used by Camel applications outside Google App Engine (GAE) for programmatic login to GAE applications. See also Camel Components for Google App Engine.
GTask / camel-gae 
gtask://queue-name
Supports asynchronous message processing on Google App Engine by using the task queueing service as message queue. See also Camel Components for Google App Engine.
GMail / camel-gae 
gmail://user@gmail.com[?options]
gmail://user@googlemail.com[?options]
Supports sending of emails via the mail service of Google App Engine. See also Camel Components for Google App Engine.
Google Guava EventBus / camel-guava-eventbus 
guava-eventbus:busName[?eventClass=className]
The Google Guava EventBus allows publish-subscribe-style communication between components without requiring the components to explicitly register with one another (and thus be aware of each other). This component provides integration bridge between Camel and Google Guava EventBus infrastructure.
Hazelcast / camel-hazelcast 
hazelcast://[type]:cachename[?options]
Hazelcast is a data grid entirely implemented in Java (single jar). This component supports map, multimap, seda, queue, set, atomic number and simple cluster support.
HBase / camel-hbase 
hbase://table[?options]
For reading/writing from/to an HBase store (Hadoop database)
HDFS / camel-hdfs 
hdfs://path[?options]
For reading/writing from/to an HDFS filesystem
HL7 / camel-hl7 
mina:tcp://hostname[:port]
For working with the HL7 MLLP protocol and the HL7 model using the HAPI library
HTTP / camel-http 
http://hostname[:port]
For calling out to external HTTP servers using Apache HTTP Client 3.x
HTTP4 / camel-http4 
http4://hostname[:port]
For calling out to external HTTP servers using Apache HTTP Client 4.x
iBATIS / camel-ibatis 
ibatis://statementName
Performs a query, poll, insert, update or delete in a relational database 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 messages through JavaSpace
JBI / servicemix-camel 
jbi:serviceName
For JBI integration such as working with Apache ServiceMix
jclouds / jclouds 
jclouds:[blobstore|computservice]:provider
For interacting with cloud compute & blobstore service via jclouds
JCR / camel-jcr 
jcr://user:password@repository/path/to/node
Storing a message in a JCR compliant repository like Apache Jackrabbit
JDBC / camel-jdbc 
jdbc:dataSourceName?options
For performing JDBC queries and operations
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?options
For working with JMX notification listeners
JPA / camel-jpa 
jpa://entityName
For using a database as a queue via the JPA specification for working with OpenJPA, Hibernate or TopLink
Jsch / camel-jsch 
scp://localhost/destination
Support for the scp protocol
JT/400 / camel-jt400 
jt400://user:pwd@system/<path_to_dtaq>
For integrating with data queues on an AS/400 (aka System i, IBM i, i5, ...) system
Kestrel / camel-kestrel 
kestrel://[addresslist/]queuename[?options]
For producing to or consuming from Kestrel queues
Krati / camel-krati 
krati://[path to datastore/][?options]
For producing to or consuming to Krati datastores
Language / camel-core 
language://languageName[:script][?options]
Executes Languages scripts
LDAP / camel-ldap 
ldap:host[:port]?base=...[&scope=<scope>]
Performing searches on LDAP servers (<scope> must be one of object|onelevel|subtree)
Log / camel-core 
log:loggingCategory[?level=ERROR]
Uses Jakarta Commons Logging to log the message exchange to some underlying logging system like log4j
Lucene / camel-lucene 
lucene:searcherName:insert[?analyzer=<analyzer>]
lucene:searcherName:query[?analyzer=<analyzer>]
Uses Apache Lucene to perform Java-based indexing and full text based searches using advanced analysis/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:name
For testing routes and mediation rules using mocks
MongoDB / camel-mongodb 
mongodb:connection?options
Interacts with MongoDB databases and collections. Offers producer endpoints to perform CRUD-style operations and more against databases and collections, as well as consumer endpoints to listen on collections and dispatch objects to Camel routes
MQTT / camel-mqtt 
mqtt:name
Component for communicating with MQTT M2M message brokers
MSV / camel-msv 
msv:someLocalOrRemoteResource
Validates the payload of a message using the MSV Library
MyBatis / camel-mybatis 
mybatis://statementName
Performs a query, poll, insert, update or delete in a relational database using MyBatis
Nagios / camel-nagios 
nagios://host[:port]?options
Sending passive checks to Nagios using JSendNSCA
Netty / camel-netty 
netty:tcp//host[:port]?options
netty:udp//host[:port]?options
Working with TCP and UDP protocols using Java NIO based capabilities offered by the JBoss Netty community project
Pax-Logging / camel-paxlogging 
paxlogging:appender
Receiving Pax-Logging events in OSGi
POP / camel-mail 
pop3://user-info@host:port
Receiving email using POP3 and JavaMail
Printer / camel-printer 
lpr://host:port/path/to/printer[?options]
The printer component facilitates creation of printer endpoints to local, remote and wireless printers. The endpoints provide the ability to print camel directed payloads when utilized on camel routes.
Properties / camel-core 
properties://key[?options]
The properties component facilitates using property placeholders directly in endpoint uri definitions.
Quartz / camel-quartz 
quartz://groupName/timerName
Provides a scheduled delivery of messages using the Quartz scheduler
Quickfix / camel-quickfix 
quickfix-server:config file
quickfix-client:config-file
Implementation of the QuickFix for Java engine which allow to send/receive FIX messages
Redis / camel-redis 
redis:restletUrl[?options]
Component for consuming and producing from Redis key-value store Redis
Ref / camel-core 
ref:name
Component for lookup of existing endpoints bound in the Registry.
Restlet / camel-restlet 
restlet:restletUrl[?options]
Component for consuming and producing Restful resources using Restlet
RMI / camel-rmi 
rmi://host[:port]
Working with RMI
RNC / camel-jing 
rnc:/relativeOrAbsoluteUri
Validates the payload of a message using RelaxNG Compact Syntax
RNG / camel-jing 
rng:/relativeOrAbsoluteUri
Validates the payload of a message using RelaxNG
Routebox / camel-routebox 
routebox:routeboxName[?options]
Facilitates the creation of specialized endpoints that offer encapsulation and a strategy/map based indirection service to a collection of camel routes hosted in an automatically created or user injected camel context
RSS / camel-rss 
rss:uri
Working with ROME for RSS integration, such as consuming an RSS feed.
SEDA / camel-core 
seda:name
Asynchronous call to another endpoint in the same Camel Context
SERVLET / camel-servlet 
servlet:uri
For exposing services over HTTP through the servlet which is deployed into the Web container.
SFTP / camel-ftp 
sftp://host[:port]/fileName
Sending and receiving files over SFTP (FTP over SSH).
Sip / camel-sip 
sip://user@host[:port]?[options]
sips://user@host[:port]?[options]
Publish/Subscribe communication capability using the Telecom SIP protocol. RFC3903 - Session Initiation Protocol (SIP) Extension for Event
SJMS / camel-sjms 
sjms:[topic:]destinationName?[options]
A ground up implementation of a JMS client
SMTP / camel-mail 
smtp://user-info@host[:port]
Sending email using SMTP and JavaMail
SMPP / camel-smpp 
smpp://user-info@host[:port]?options
To send and receive SMS using Short Messaging Service Center using the JSMPP library
SNMP / camel-snmp 
snmp://host[:port]?options
Polling OID values and receiving traps using SNMP via SNMP4J library
Solr / camel-solr 
solr://host[:port]/solr?[options]
Uses the Solrj client API to interface with an Apache Lucene Solr server
SpringBatch / camel-spring-batch 
spring-batch:job[?options]
To bridge Camel and Spring Batch
SpringIntegration / camel-spring-integration 
spring-integration:defaultChannelName
The bridge component of Camel and Spring Integration
Spring LDAP / camel-spring-ldap 
spring-ldap:spring-ldap-template-bean?options
Camel wrapper for Spring LDAP
Spring Web Services / camel-spring-ws 
spring-ws:[mapping-type:]address[?options]
Client-side support for accessing web services, and server-side support for creating your own contract-first web services using Spring Web Services
SQL / camel-sql 
sql:select * from table where id=#
Performing SQL queries using JDBC
SSH component / camel-ssh 
ssh:[username[:password]@]host[:port][?options]
For sending commands to a SSH server
StAX / camel-stax 
stax:contentHandlerClassName
Process messages through a SAX ContentHandler.
Stream / camel-stream 
stream:[in|out|err|file]
Read or write to an input/output/error/file stream rather like unix pipes
StringTemplate / camel-stringtemplate 
string-template:someTemplateResource
Generates a response using a String Template
Stub / camel-core 
stub:someOtherCamelUri
Allows you to stub out some physical middleware endpoint for easier testing or debugging
TCP / camel-mina 
mina:tcp://host:port
Working with TCP protocols using Apache MINA
Test / camel-spring 
test:expectedMessagesEndpointUri
Creates a Mock endpoint which expects to receive all the message bodies that could be polled from the given underlying endpoint
Timer / camel-core 
timer://name
A timer endpoint
Twitter / camel-twitter 
twitter://[endpoint]?[options]
A twitter endpoint
UDP / camel-mina 
mina:udp://host:port
Working with UDP protocols using Apache MINA
Validation / camel-core (camel-spring for Camel 2.8 or older) 
validation:someLocalOrRemoteResource
Validates the payload of a message using XML Schema and JAXP Validation
Velocity / camel-velocity 
velocity:someTemplateResource
Generates a response using an Apache Velocity template
VM / camel-core 
vm:name
Asynchronous call to another endpoint in the same JVM
Websocket / camel-websocket 
websocket://host:port/path
Communicating with Websocket clients
XMPP / camel-xmpp 
xmpp://host:port/room
Working with XMPP and Jabber
XQuery / camel-saxon 
xquery:someXQueryResource
Generates a response using an XQuery template
XSLT / camel-core (camel-spring for Camel 2.8 or older) 
xslt:someTemplateResource
Generates a response using an XSLT template
Zookeeper / camel-zookeeper 
zookeeper://host:port/path
Working with ZooKeeper cluster(s)

External Components

The following components are not part of the standard Apache Camel distribution and are available under a variety of licenses but can be used to extend Camel's functionality.

Component / ArtifactId / URI License Description
ActiveMQ / activemq-camel 
activemq:[topic:]destinationName
Apache For JMS Messaging with Apache ActiveMQ
ActiveMQ Journal / activemq-core 
activemq.journal:directory-on-filesystem
Apache Uses ActiveMQ's fast disk journaling implementation to store message bodies in a rolling log file
Activiti / activiti-camel 
activiti:camelProcess:serviceTask
Apache For working with Activiti, a light-weight workflow and Business Process Management (BPM) platform which supports BPMN 2
Db4o / camel-db4o in camel-extra 
db4o://className
GPL For using a db4o datastore as a queue via the db4o library
Esper / camel-esper in camel-extra 
esper:name
GPL Working with the Esper Library for Event Stream Processing
Hibernate / camel-hibernate in camel-extra 
hibernate://entityName
GPL For using a database as a queue via the Hibernate library
JGroups / camel-jgroups in camel-extra 
jgroups://clusterName
LGPL The jgroups: component provides exchange of messages between Camel infrastructure and JGroups clusters.
NMR / servicemix-nmr 
nmr://serviceName
Apache Integration with the Normalized Message Router BUS in ServiceMix 4.x
Scalate / scalate-camel 
 
scalate:templateName
Apache Uses the given Scalate template to transform the message
Smooks / camel-smooks in camel-extra. 
unmarshal(edi)
GPL For working with EDI parsing using the Smooks library. This component is deprecated as Smooks now provides Camel integration out of the box
ZeroMQ / camel-zeromq in camel-extra. 
zeromq:(tcp|ipc)://hostname:port
LGPL The ZeroMQ component allows you to consumer or produce messages using ZeroMQ.

See Also

Overview

Search


Sub Projects

Community

Features

Connectivity

Using ActiveMQ 5

Using ActiveMQ 4

Tools

External Tools

Support

Related Projects

Developers

Tests

Project Reports
© 2004-2011 The Apache Software Foundation.
Apache ActiveMQ, ActiveMQ, Apache, the Apache feather logo, and the Apache ActiveMQ project logo are trademarks of The Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners.
Graphic Design By Hiram