Components

A Component is essentially a factory of Endpoint instances.

You can explicitly configure Component instances and add them to a CamelContext in an IoC container like Spring or Guice, or they can be auto-discovered using URIs.

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.
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).
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
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
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.
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
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.
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.
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
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
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
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
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
SpringIntegration / camel-spring-integration
spring-integration:defaultChannelName
The bridge component of Camel and Spring Integration
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
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
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
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

See Also

© 2004-2011 The Apache Software Foundation.
Apache Camel, Camel, Apache, the Apache feather logo, and the Apache Camel 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