LibraryPrintFeedback

Component Reference

Version 2.1

March 2012
Trademark Disclaimer
Third Party Acknowledgements

Updated: 09 Oct 2012

Table of Contents

1. Table of Components
2. Apache CXF Endpoints
CXF — uses Apache CXF to interact with JAX-WS Web services
CXF Bean — allows other Apache Camel endpoints to send exchanges and invoke Web service bean objects
CXF REST — provides integration for linking with JAX-RS based RESTful services
3. File Endpoints
ActiveMQ Journal — stores messages in rolling log file for later processing
File — provides access to file systems
FTP/SFTP — provides access to remote file systems over the FTP and SFTP protocols
HDFS — enables you to read and write messages from/to an HDFS file system
4. Google App Engine Endpoints
GAuth — implement a Google-specific OAuth consumer
GHTTP — provides connectivity to the GAE URL fetch service but can also be used to receive messages from servlets
GLogin — allows for programmatic login to GAE applications
GMail — supports sending of emails via the GAE mail service
GTask — supports asynchronous message processing on GAE by using the task queueing service as message queue
5. HTTP Endpoints
HTTP — provides endpoints for consuming external HTTP resources
HTTP4 — provides endpoints for consuming external HTTP resources using Apache HttpClient 4.x
Jetty — provides endpoints for consuming HTTP requests
Restlet — provides Restlet-based endpoints for consuming and producing RESTful resources
Servlet — provides support for HTTP endpoints that are published as servlets
6. Internal Endpoints
Direct — provides a synchronous connection to any consumer in the same camelContext element
Seda — provides an asynchronous connection to any consumer in the same camelContext element
VM — provides an asynchronous connection to consumers in other camelContext elements
7. Messaging Endpoints
ActiveMQ — allows messages to be sent to or consumed from a JMS destination using Fuse MQ Enterprise
AMQP — supports the AMQP protocol
IRC — sends and receives messages using the IRC protocol
JMS — allows message to be sent to or consumed from JMS destinations
Mail — provides access to e-mail systems
MSMQ — works with Microsoft Message Queuing
SIP — supports the SIP Publish and Subscribe capability as described in the [RFC3903 - Session Initiation Protocol (SIP) Extension for Event]
SMPP — provides access to an SMSC (Short Message Service Center) over the SMPP protocol
XMPP — allows for sending and receiving messages over the XMPP transport
8. Scheduling Endpoints
Quartz — provides a scheduled delivery of messages using the Quartz scheduler
Timer — generates message exchanges when a timer fires
9. Testing Endpoints
Mock — provides a declarative framework for testing routes
Test — a mock endpoint that tests messages based on a set of expected messages
10. Atom Component
11. Bean
12. Bean Validation
13. Browse
14. Cache
15. Class
16. Cometd
17. Context
18. Crypto (Digital Signatures)
19. DataSet
20. Db4o
21. DNS
22. EJB
23. Esper
24. Event
25. Exec
26. FIX
27. Flatpack
28. Freemarker
29. Hazelcast Component
30. Hibernate
31. iBATIS
32. JavaSpace
33. JBI
34. JCR
35. JDBC
36. Jing
37. JMX
38. JPA
39. JT400
40. Language
41. LDAP
42. List
43. Log
44. Lucene
45. MINA Component
46. MSV
47. MyBatis
48. Nagios
49. Netty
50. NMR
51. Printer
52. Properties
53. Quickfix
54. Ref
55. Routebox
56. RMI
57. RSS
58. Scalate
59. SNMP
60. Spring Integration
61. Spring Web Services
62. SQL Component
63. Stream
64. StringTemplate
65. Validation
66. Velocity
67. XQuery Endpoint
68. XSLT

List of Tables

1.1. Apache Camel Endpoints
2.1. Apache CXF options
2.2. CXF Bean options
2.3. CXF Bean headers
2.4. CXF REST options
3.1. ActiveMQ Journal optionss
3.2. Common file options
3.3. File consumer options
3.4. File producer options
3.5. File producer headers
3.6. File consumer headers
3.7. Exchange properties used by a file consumer
3.8. FTP options
3.9. FTP message headers
3.10. HDFS options
4.1. GAuth options
4.2. GHTTP options
4.3. GLogin options
4.4. GMail options
4.5. GTask options
5.1. HTTP endpoint options
5.2. HTTP authentication options
5.3. HTTP Exchange properties
5.4. HTTP4 endpoint options
5.5. HTTP Exchange properties
5.6. Jetty options
5.7. Restlet endpoint options
5.8. Servlet endpoint options
6.1. Seda component options
7.1. IRC options
7.2. JMS options
7.3. Mapping from Apache Camel to JMS
7.4. Mapping from JMS to Apache Camel
7.5. Mail URI Formats
7.6. Default mail port numbers
7.7. Mail endpoint options
7.8. MSMQ options
7.9. SIP Options
7.10. SIP registry based options
7.11. SMPP Options
7.12. SMPP producer headers
7.13. SMPP headers for the SMSC
7.14. SMMP consumer headers
7.15. XMPP options
8.1. Quartz options
8.2. Quartz properties options
8.3. Quartz scheduler start up options
8.4. Timer options
9.1. Mock options
10.1. Atom Component Options
52.1. Properties options

List of Examples

2.1. Apache CXF dependency
2.2. Apache CXF dependency
2.3. Apache CXF dependency
3.1. Configuring the FTP client in XML
4.1. GAuth dependency
4.2. GHTTP dependency
4.3. GLogin dependency
4.4. GMail dependency
4.5. GTask dependency
5.1. Adding the servlet dependency
6.1. Seda URI format
7.1. Fuse MQ Enterprise dependencies
7.2. AMQP dependency
7.3. SIP dependency
8.1. Quartz dependency
8.2. Setting the Quartz properties
8.3. Setting the Quartz scheduler delay
9.1. Mock dependency
9.2. Test dependency
10.1. Atom dependency

Table 1.1 summarizes the Apache Camel endpoints available when using Fuse IDE.

Table 1.1. Apache Camel Endpoints

ComponentEndpoint URIDescription
ActiveMQactivemq:[queue:|topic:]DestinationNameConnects to JMS destinations using Apache ActiveMQ.
ActiveMQ Journalactivemq.journal:DirectoryName[?Options]Uses ActiveMQ's fast disk journaling implementation to store message bodies in a rolling log file.
AMQPamqp:[queue:|topic:]DestinationName[?Options]]Connects to messaging systems using the AMQP protocol.
Atomatom://AtomUri[?Options]Connects to or publishes Atom feeds using Apache Abdera.
Beanbean:BeanID[?methodName=Method]Uses the Bean Binding to bind message exchanges to beans in the Registry. Can also be used for exposing and invoking POJOs.
Bean Validationbean-validator:Something[?Options]Validates the payload of a message using the Java Validation API (JSR 303 and JAXP Validation) and its reference implementation Hibernate Validator.
Browsebrowse:NameProvides 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.
Cachecache://CacheName[?Options]Enables you to perform caching operations using EHCache as the cache implementation.
Classclass:className[?method=someMethod]Uses the Bean Binding to bind message exchanges to beans in the Registry. Is also used for exposing and invoking POJOs.
Cometdcometd://Hostname[:Port]/ChannelName[?Options]Supports the Jetty implementation of the cometd/bayeux protocol.
Crypto

crypto:sign:Name[?Options]

crypto:verify:Name[?Options]

Signs and verifies exchanges using the Signature Service of the Java Cryptographic Extension.
CXFcxf://Address[?Options]Uses Apache CXF for Web services integration.
CXF Beancxf:beanName[?Options]Proceess the exchange using a JAX-WS or JAX-RS annotated bean from the registry.
CXFRScxfrs:bean:RsEndpoint[?Options]Uses Apache CXF to connect to JAX-RS services hosted in Apache CXF.
DataSetdataset:Name[?Options]Provides a way to create large numbers of messages for sending to components or asserting that they are consumed correctly.
Db4odb4o://classNameFor using a db4o datastore as a queue via the db4o library.
Directdirect:EndpointID[?Options]Ensures direct invocation of the consumer from the producer so that single threaded in-VM invocation is performed.
Esperesper:nameSupports using the Esper Library for Event Stream Processing.
Event

event://default

spring-event://default

Works with Spring ApplicationEvents.
Execexec://Executable[?Options]Executes system commands.
Filefile://DirectoryName[?Options]Sends messages to a file or polls a file or directory.
FIXfix://ConfigurationResourceSends or receives messages using the FIX protocol.
Flatpackflatpack:[fixed|delim]:ConfigFileProcesses fixed width or delimited files or messages using the FlatPack library.
Freemarkerfreemarker:TemplateResourceGenerates a response using a Freemarker template.
FTP2ftp://[Username@]Hostname[:Port]/Directoryname[?Options]Sends and receives files over FTP.
GAuthgauth://Name[?Options]Implements a Google-specific OAuth consumer for Web applications.
GHTTP

ghttp:///Path[?Options]

ghttp://Hostname[:Port]/Path[?Options]

ghttps://Hostname[:Port]/Path[?Options]

Provides connectivity to the GAE URL fetch service and can also be used to receive messages from servlets.
GLoginglogin://Hostname[:Port][?Options]Allows Apache Camel applications outside Google App Engine (GAE) to programmatically login to GAE applications.
GMail

gmail://Username@gmail.com[?Options]

gmail://Username@googlemail.com[?Options]

Sends e-mails via the GAE mail service.
GTaskgtask://QueueNameSupports asynchronous message processing on GAE using the task queueing service as a message queue.
HDFShdfs://Path[?Options]Reads from and writes to HDFS file systems.
Hibernatehibernate://EntityName Uses a database as a queue via the Hibernate library.
HTTPhttp://Hostname[:Port][/ResourceUri]Calls out to external HTTP servers.
HTTP4http4://Hostname[:Port][/ResourceUri]Calls out to external HTTP servers using the Apache HttpClient 4.x.
iBATISibatis:OperationName[?Options]Performs a query, poll, insert, update or delete in a relational database using Apache iBATIS.
IMapimap://[UserName@]Host[:Port][?Options]Receives e-mail using IMAP.
IRCirc:Host[:Port]/#RoomUses IRC communication.
JavaSpacejavaspace:jini://Host[?Options]Sends and receives messages through JavaSpace.
JBI

jbi:service:serviceNamespace[sep]serviceName

jbi:endpoint:serviceNamespace[sep]serviceName[sep]endpointName

jbi:name:endpointName

Integrates with JBI endpoints.
JCRjcr://UserName:Password@Repository/path/to/nodeStores messages in a JCR (JSR-170) compliant repository like Apache Jackrabbit.
JDBCjdbc:DataSourceName[?Options]Performs JDBC queries and operations.
Jettyjetty:http://Host[:Port][/ResourceUri]Exposes services over HTTP.
Jing

rng:LocalOrRemoteResource

rnc:LocalOrRemoteResource

Validates the payload of a message using RelaxNG or RelaxNG compact syntax.
JMSjms:[temp:][queue:|topic:]DestinationName[?Options]Connects to generic JMS providers.
JPAjpa:[EntityClassName][?Options]Uses a database as a queue via the JPA specification for working with OpenJPA, Hibernate or TopLink.
JT400jt400://User:Pwd@System/PathToDTAQIntegrates with data queues on an AS/400 (aka System i, IBM i, i5, ...) system.
Languagelanguage://languageName[:script][?options]Executes Languages scripts.
LDAPldap:Host[:Port]?base=...[&scope=Scope]Performs searches on LDAP servers.
Listlist:ListIDProvides 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.
Loglog:LoggingCategory[?level=LoggingLevel]Uses Jakarta Commons Logging to log the message exchange to some underlying logging system like log4j.
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.
MINA

mina:tcp://Hostname[:Port][?Options]

mina:udp://Hostname[:Port][?Options]

mina:multicast://Hostname[:Port][?Options]

mina:vm://Hostname[:Port][?Options]

Works with Apache MINA.
Mockmock:EndpointIDCreates mock endpoints for testing routes and mediation rules.
MSMQmsmq:MsmqQueueName[?Options]Sends and receives messages with Microsoft Message Queuing.
MSVmsv:LocalOrRemoteResourceValidates the payload of a message using the MSV Library.
Nagiosnagios://Host[:Port][?Options]Sends passive checks to Nagios using JSendNSCA.
Netty

netty:tcp://localhost:99999[?Options]

netty:udp://Remotehost:99999/[?Options]

Works with TCP and UDP protocols using Java NIO based capabilities offered by the JBoss Netty community project.
NMRnmr:serviceMixURISupports OSGi integration when working with Fuse ESB Enterprise. Enables you to specify the URI of a ServiceMix endpoint.
POPpop3://[UserName@]Host[:Port][?Options]Receives e-mail using POP3 and JavaMail.
Printer

lpr://localhost[:Port]/default[?Options]

lpr://RemoteHost[:Port]/path/to/printer[?Options]

Directs payloads on a route to a printer.
Propertiesproperties://Key[?Options] Facilitates using property placeholders directly in endpoint URI definitions.
Quartz

quartz://[GroupName/]TimerName[?Options]

quartz://GroupName/TimerName/CronExpression

Provides for scheduled delivery of messages using the Quartz scheduler.
Quickfix

quickfix-server:ConfigFile

quickfix-client:ConfigFile

Sends and receives FIX messages.
Refref:EndpointIDLooks up existing endpoints bound in the Registry.
Restletrestlet:RestletUrl[?Options]Consumes and produces RESTful resources using Restlet.
RMIrmi://RmiRegistryHost:RmiRegistryPort/RegistryPathWorks with RMI.
RSSrss:UriConsumes RSS feeds using ROME.
RNCrnc:LocalOrRemoteResourceValidates the payload of a message using RelaxNG Compact Syntax.
RNGrng:LocalOrRemoteResourceValidates the payload of a message using RelaxNG.
Scalatescalate:TemplateName[?Options]Transforms message using Scalate templates.
SEDAseda:EndpointIDDelivers messages to a java.util.concurrent.BlockingQueue. This is useful when creating SEDA style processing pipelines within the same CamelContext.
SERVLETservlet://RelativePath[?Options]Provides HTTP based endpoints for consuming HTTP requests that arrive at a HTTP endpoint and this endpoint is bound to a published Servlet.
SFTPsftp://[Username@]Hostname[:Port]/Directoryname[?Options]Sends and receives files over SFTP.
SIPsmpp://UserInfo@Host[:Port][?Options]Sends and receives SMS through Short Messaging Service Center using the JSMPP library.
SMPP

sip://user@host[:port]?[options]

sips://user@host[:port]?[options]

Publish/Subscribe communication capability using the Telecom SIP protocol.
SMTPsmtp://[UserName@]Host[:Port][?Options]Sends e-mail using SMTP and JavaMail.
SNMPsnmp://Hostname[:Port][?Options]Polls SNMP capable devices or receive traps.
Spring Integrationspring-integration:DefaultChannelName[?Options]Bridges Camel and Spring Integration.
Spring Web Servicesspring-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.
SQLsql:SqlQueryString[?Options]Performs SQL queries using JDBC.
Streamstream:[in|out|err|header][?Options]Reads or writes to an input/output/error/file stream.
String Templatestring-template:TemplateURI[?Options]Generates a response using a String Template.
Testtest:RouterEndpointUriCreates a Mock endpoint which expects to receive all the message bodies that could be polled from the given underlying endpoint.
Timertimer:EndpointID[?Options]Creates a timer endpoint.
Validationvalidator:LocalOrRemoteResourceValidates the payload of a message using XML Schema and JAXP Validation.
Velocityvelocity:TemplateURI[?Options]Generates a response using an Apache Velocity template.
VMvm:EndpointIDDeliver messages to a java.util.concurrent.BlockingQueue, useful when creating SEDA style processing pipelines within the same JVM.
XMPPxmpp:Hostname[:Port][/Room]Works with XMPP and Jabber.
XQueryxquery:TemplateURIGenerates a response using an XQuery template.
XSLTxslt:TemplateURI[?Options]Transforms a message using an XSLT script.

CXF — uses Apache CXF to interact with JAX-WS Web services
CXF Bean — allows other Apache Camel endpoints to send exchanges and invoke Web service bean objects
CXF REST — provides integration for linking with JAX-RS based RESTful services

Name

CXF — uses Apache CXF to interact with JAX-WS Web services

Overview

The CXF component provides integration with Apache CXF for connecting to JAX-WS services hosted in Apache CXF.

Options

Table 2.1 lists the options for a CXF endpoint.

Table 2.1. Apache CXF options

NameDefault ValueDescription
wsdlURLdetermined from endpoint addressSpecifies the location of the WSDL.
serviceClass 

Specifies the name of the SEI (Service Endpoint Interface) class. The SEI class can have, but does not require, JSR181 annotations.

This option is required when dataFormat is set to POJO. When dataFormat is set to PAYLOAD or MESSAGE, this option is not required if the wsdlURL option is provided.

It is possible to use # notation to reference a serviceClass object instance from the registry.

When a Apache CXF endpoint is used in a to the SEI must be a Java interface.

serviceName Specifies the QName of the service being implemented. It maps to wsdl:service@name.
portName Specifies the QName of the port for the service being implemented. It maps to wsdl:port@name.
dataFormatPOJO

Specifies the message data format the CXF endpoint supports. Valid values are:

  • POJO

  • PAYLOAD

  • MESSAGE

relayHeaderstrueSpecifies whether the endpoint relays headers along the route. This option is only valid when dataFormat is set to POJO.
wrappedfalseSpecifies whether the endpoint producer invokes wrapped operations.
wrappedStylefalseSpecifies if the endpoint uses the document-literal wrapped style.
setDefaultBusfalseSpecifies whether to use the default Apache CXF bus for this endpoint.
bus Specifies a reference to a bus object in the registry using the # notation. The referenced bus is used in place of the default bus.
cxfBinding Specifies a reference to a binding object in the registry using the # notation. The referenced binding is used in place of the default binding.
headerFilterStrategy Specifies a reference to an instance of org.apache.camel.spi.HeaderFilterStrategy in the registry using the # notation. The referenced instance is used in place of the default header filter strategy.
loggingFeatureEnabledfalseSpecifies if the Apache CXF logging feature is enabled.
defaultOperationName Specifies the default operationName that will be used by the CxfProducer which invokes the remote service.
defaultOperationNameSpace Specifies the default operationNamespace that will be used by the CxfProducer which invokes the remote service.
synchronousfalseSpecifies if the endpoint will use Apache Camel's synchronous APIs.
publishedEndpointUrl Override the endpointUrl that is published from the WSDL accessed with service's URL plus ?wsdl.

Name

CXF Bean — allows other Apache Camel endpoints to send exchanges and invoke Web service bean objects

ActiveMQ Journal — stores messages in rolling log file for later processing
File — provides access to file systems
FTP/SFTP — provides access to remote file systems over the FTP and SFTP protocols
HDFS — enables you to read and write messages from/to an HDFS file system

Name

ActiveMQ Journal — stores messages in rolling log file for later processing

Name

File — provides access to file systems

Common options

Table 3.2 list the options that can be set on any file endpoint.

Table 3.2. Common file options

NameDefault ValueDescription
autoCreate true Automatically create missing directories in the file's pathname. For the file consumer, that means creating the starting directory. For the file producer, it means the directory to where the files should be written.
bufferSize 128kb Write buffer sized in bytes.
fileName null Use an expression language to dynamically set the filename. For consumers, it's used as a filename filter. For producers, it's used to evaluate the filename to write. If an expression is set, it take precedence over the CamelFileName header. (Note: The header itself can also be an expression). The expression options support both String and Expression types. If the expression is a String type, it is always evaluated using the file language. If the expression is an Expression type, the specified Expression type is used - this allows you, for instance, to use OGNL expressions. For the consumer, you can use it to filter filenames, so you can for instance consume today's file using the file language syntax: mydata-${date:now:yyyyMMdd}.txt.
flatten false Flatten is used to flatten the file name path to strip any leading paths, so it's just the file name. This allows you to consume recursively into sub-directories, but when you eg write the files to another directory they will be written in a single directory. Setting this to true on the producer enforces that any file name recived in CamelFileName header will be stripped for any leading paths.
charset null Specifies the encoding of the file, and camel will set the Exchange.CHARSET_NAME property with the value.

Consumer options

Table 3.3 list the options that can be set on a file consuming endpoint.

Table 3.3. File consumer options

NameDefault ValueDescription
initialDelay 1000 Milliseconds before polling the file/directory starts.
delay 500 Milliseconds before the next poll of the file/directory.
useFixedDelay false Set to true to use fixed delay between pools, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
recursive false If a directory, will look for files in all the sub-directories as well.
delete false If true, the file will be deleted after it is processed
noop false If true, the file is not moved or deleted in any way. This option is good for readonly data, or for ETL type requirements. If noop=true, Apache Camel will set idempotent=true as well, to avoid consuming the same files over and over again.
preMove null Use an expression to dynamically set the filename when moving it before processing. For example, to move in-progress files into the order directory set this value to order.
move .camel Use an expression to dynamically set the filename when moving it after processing. To move files into a .done subdirectory just enter .done.
moveFailed null Use an expression to dynamically set the filename when moving failed files after processing. To move files into a error subdirectory just enter error. Note: When moving the files to another location it can/will handle the error when you move it to another location so Apache Camel cannot pick up the file again.
include null Is used to include files, if filename matches the regex pattern.
exclude null Is used to exclude files, if filename matches the regex pattern.
idempotent false Option to use the Idempotent Consumer EIP pattern to let Apache Camel skip already processed files. Will by default use a memory based LRUCache that holds 1000 entries. If noop=true then idempotent will be enabled as well to avoid consuming the same files over and over again.
idempotentRepository null Pluggable repository as a org.apache.camel.processor.idempotent.MessageIdRepository class. Will by default use MemoryMessageIdRepository if none is specified and idempotent is true.
inProgressRepository memory Pluggable in-progress repository as a org.apache.camel.processor.idempotent.MessageIdRepository class. The in-progress repository is used to account the current in progress files being consumed. By default a memory based repository is used.
filter null Pluggable filter as a GenericFileFilter class. Will skip files if filter returns false in its accept() method. Apache Camel also ships with an ANT path matcher filter in the camel-spring component. More details in section below.
sorter null Pluggable sorter as a java.util.Comparator<org.apache.camel.component.file.GenericFile> class.
sortBy null Built-in sort using the File Language. Supports nested sorts, so you can have a sort by file name and as a 2nd group sort by modified date. See sorting section below for details.
readLock markerFile

Used by consumer, to only poll the files if it has exclusive read-lock on the file (i.e. the file is not in-progress or being written). Apache Camel will wait until the file lock is granted.

The readLock option supports the following built-in strategies:

  • markerFile forces Apache Camel will create a marker file and hold a lock on the marker file. This option is not available for the FTP component.

  • changed uses a length/modification timestamp to detect whether the file is currently being copied or not. Will wait at least 1 second to determine this, so this option cannot consume files as fast as the others, but can be more reliable as the JDK IO API cannot always determine whether a file is currently being used by another process. This option is not available for the FTP component.

  • fileLock uses java.nio.channels.FileLock. This option is not available for the FTP component.

  • rename attempts to rename the file, in order to test whether we can get an exclusive read-lock.

  • none is for no read locks at all.

readLockTimeout 0 Optional timeout in milliseconds for the read-lock, if supported by the read-lock. If the read-lock could not be granted and the timeout triggered, then Apache Camel will skip the file. At next poll Apache Camel, will try the file again, and this time maybe the read-lock could be granted. Currently fileLock, changed and rename support the timeout.
exclusiveReadLockStrategy null Pluggable read-lock as an implementation of the GenericFileExclusiveReadLockStrategy interface.
processStrategy null A pluggable GenericFileProcessStrategy allowing you to implement your own readLock option or similar. Can also be used when special conditions must be met before a file can be consumed, such as a special ready file exists. If this option is set then the readLock option does not apply.
maxMessagesPerPoll 0 An integer that defines the maximum number of messages to gather per poll. By default, no maximum is set. Can be used to set a limit of e.g. 1000 to avoid having the server read thousands of files as it starts up. Set a value of 0 or negative to disabled it.
startingDirectoryMustExist false Whether the starting directory must exist. Mind that the autoCreate option is default enabled, which means the starting directory is normally auto-created if it doesn't exist. You can disable autoCreate and enable this to ensure the starting directory must exist. Will throw an exception, if the directory doesn't exist.
directoryMustExist false Similar to startingDirectoryMustExist but this applies during polling recursive sub-directories.

Message Headers

The following headers are supported by this component:



Name

FTP/SFTP — provides access to remote file systems over the FTP and SFTP protocols

Options

Table 3.8 lists the options for the FTP component.

Table 3.8. FTP options

NameSupported ProtocolDefault ValueDescription
passwordFTP, FTPS, SFTPnull Specifies the password to use to log in to the remote file system.
binaryFTP, FTPS, SFTPfalseSpecifies the if the files should be treated as binary data.
disconnectFTP, FTPS, SFTPfalseWhether or not to disconnect from remote FTP server right after use. Can be used for both consumer and producer. Disconnect will only disconnect the current connection to the FTP server. If you have a consumer which you want to stop, then you need to stop the consumer/route instead.
localWorkDirectoryFTP, FTPS, SFTPnull When consuming, a local work directory can be used to store the remote file content directly in local files, to avoid loading the content into memory. This is beneficial, if you consume a very big remote file and thus can conserve memory. See below for more details.
passiveModeFTPfalseSpecifies whether to use passive mode connections.
securityProtocolFTPSTLS

Sets the underlying security protocol. The following values are defined: TLS: Transport Layer Security SSL: Secure Sockets Layer

disableSecureDataChannelDefaultsFTPSfalseWhether or not to disable using default values for execPbsz and execProt when using secure data transfer. You can set this option to true if you want to be in absolute full control what the options execPbsz and execProt should be used.
execProtFTPSnull

Will by default use option P if secure data channel defaults hasn't been disabled. Possible values are: C: Clear S: Safe (SSL protocol only) E: Confidential (SSL protocol only) P: Private

execPbszFTPSnullThis option specifies the buffer size of the secure data channel. If option useSecureDataChannel has been enabled and this option has not been explicit set, then value 0 is used.
isImplicitFTPSfalse Specifies if the security mode is implicit.
knownHostsFileSFTPnull Sets the known_hosts file, so that the SFTP endpoint can do host key verification.
privateKeyFilePassphraseSFTPnull Set the private key file passphrase to that the SFTP endpoint can do private key verification.
privateKeyFilePassphraseSFTPnull Set the private key file passphrase to that the SFTP endpoint can do private key verification.
strictHostKeyCheckingSFTPno Sets whether to use strict host key checking. Possible values are: no, yes and ask. ask does not make sense to use as Camel cannot answer the question for you as its meant for human intervention.
maximumReconnectAttemptsFTP, FTPS, SFTP3 Specifies the maximum reconnect attempts Apache Camel performs when it tries to connect to the remote FTP server. Use 0 to disable this behavior.
reconnectDelayFTP, FTPS, SFTP 1000 Delay in milliseconds Apache Camel will wait before performing a reconnect attempt.
connectTimeoutFTP, FTPS, SFTP10000Specifies the connect timeout in milliseconds.
soTimeoutFTP, FTPSnullSpecifies the SocketOptions.SO_TIMEOUT value in milliseconds.
timeoutFTP, FTPS30000Specifies the data timeout in milliseconds.
throwExceptionOnConnectFailedFTP, FTPS, SFTPfalseSpecifies whether or not to thrown an exception if a successful connection and login could not be establish. This allows a custom pollStrategy to deal with the exception, for example to stop the consumer or the likes.
siteCommandFTP, FTPSnull To execute site commands after successful login. Multiple site commands can be separated using a new line character (\n). Use help site to see which site commands your FTP server supports.
stepwiseFTP, FTPS, SFTPtrueWhen consuming directories, specifies whether or not to use stepwise mode for traversing the directory tree. Stepwise means that it will CD one directory at a time.
ftpClientFTP, FTPSnullAllows you to use a custom org.apache.commons.net.ftp.FTPClient instance.
ftpClientConfigFTP, FTPSnullAllows you to use a custom org.apache.commons.net.ftp.FTPClientConfig instance.
ftpClient.trustStore.fileFTPSnullSets the trust store file, so that the FTPS client can look up for trusted certificates.
ftpClient.trustStore.typeFTPSJKSSets the trust store type.
ftpClient.trustStore.algorithmFTPSSunX509Sets the trust store algorithm.
ftpClient.trustStore.passwordFTPSnullSets the trust store password.
ftpClient.keyStore.fileFTPSnull Sets the key store file, so that the FTPS client can look up for the private certificate.
ftpClient.keyStore.type FTPSJKS Sets the key store type.
ftpClient.keyStore.algorithm FTPSSunX509 Sets the key store algorithm.
ftpClient.keyStore.password FTPSnull Sets the key store password.
ftpClient.keyStore.keyPassword FTPSnull Sets the private key password.

Name

HDFS — enables you to read and write messages from/to an HDFS file system

Overview

HDFS is the distributed file system at the heart of Hadoop. It can only be built using JDK1.6 or later because this is a strict requirement for Hadoop itself. This component is hosted at http://github.com/dgreco/camel-hdfs. We decided to put it temporarily on this github because currently Apache Camel is being built and tested using JDK1.5 and for this reason we couldn't put that component into the Apache Camel official distribution.

GAuth — implement a Google-specific OAuth consumer
GHTTP — provides connectivity to the GAE URL fetch service but can also be used to receive messages from servlets
GLogin — allows for programmatic login to GAE applications
GMail — supports sending of emails via the GAE mail service
GTask — supports asynchronous message processing on GAE by using the task queueing service as message queue

Name

GAuth — implement a Google-specific OAuth consumer

Overview

The GAuth component is used by web applications to implement a Google-specific OAuth consumer. Although this component belongs to the Camel Components for Google App Engine (GAE), it can also be used to OAuth-enable non-GAE web applications. For a detailed description of Google's OAuth implementation refer to the Google OAuth API reference.

Options

Table 4.1 lists the options for a GAuth endpoint.

Table 4.1. GAuth options

NameRequiredDescription
callbacktrue [a]Specifies the URL to where users are redirected after having granted or denied access.
scopetrue [b] Specifies the URL identifying the service(s) to be accessed. To specify more than one scope, list each one separated with a comma.
consumerKeytrue [c] Specifies the domain identifying the web application. This is the domain used when registering the application with Google. For a non-registered application use anonymous.
consumerSecretif keyLoaderRef is not specified[c]Specifies the consumer secret of the web application. The consumer secret is generated when registering the application with Google. It is needed if the HMAC-SHA1 signature method shall be used. For a non-registered application use anonymous.
keyLoaderRefif consumerSecret is not specified[c]

Specifies a reference to a private key loader in the registry.

The camel-gae module contains two key loaders:

  • GAuthPk8Loader—loads a private key from a PKCS#8 file

  • GAuthJksLoader—loads a private key from a Java key store. It is needed if the RSA-SHA1 signature method shall be used.

These classes are defined in the org.apache.camel.component.gae.auth package.

authorizeBindingReffalseSpecifies a reference to a OutboundBinding<GAuthEndpoint, GoogleOAuthParameters, GoogleOAuthParameters> in the registry for customizing how an exchange is bound to GoogleOAuthParameters. This binding is used for the authorization phase.
upgradeBindingReffalseSpecifies a reference to a OutboundBinding<GAuthEndpoint, GoogleOAuthParameters, GoogleOAuthParameters> in the registry for customizing how an exchange is bound to GoogleOAuthParameters. This binding is used for the token upgrade phase.

[a] can alternatively be set via the GAuthAuthorizeBinding.GAUTH_CALLBACK message header

[b] can alternatively be set via GAuthAuthorizeBinding.GAUTH_SCOPE message header

[c] can alternatively be set on component-level


Name

GHTTP — provides connectivity to the GAE URL fetch service but can also be used to receive messages from servlets

Overview

The ghttp component provides connectivity to the GAE URL fetch service but can also be used to receive messages from servlets. This is achieved by extending the Servlet component. As a consequence, GHTTP URI formats and options sets differ on the consumer-side (from) and producer-side (to).

Message headers

On the producer side, the following headers of the HTTP endpoint are supported.

NameTypeDescription
Content-TypeStringSpecifies the HTTP content type. This header is populated on both the IN and OUT message to provide a content type.
Content-EncodingStringSpecifies the HTTP content encoding. This header is populated on both the IN and OUT message to provide a content encoding.
CamelHttpMethodStringSpecifies the HTTP method to execute. Can be one of GET, POST, PUT or DELETE. If not set, POST will be used if the message body is not null, GET otherwise.
CamelHttpQueryStringOverrides the query part of the endpoint URI or HTTP_URI. The query string must be in decoded form.
CamelHttpUriStringOverrides the default endpoint URI if the bridgeEndpoint option is set to false. The URI string must be in decoded form.
CamelHttpResponseCodeintSpecifies the HTTP response code from URL fetch service responses.

On the consumer-side all headers of the Servlet component headers are supported.

Name

GLogin — allows for programmatic login to GAE applications

Name

GMail — supports sending of emails via the GAE mail service

Name

GTask — supports asynchronous message processing on GAE by using the task queueing service as message queue

Overview

GTask endpoints support asynchronous message processing on GAE by using the task queueing service as message queue. For adding messages to a queue it uses the task queue API. For receiving messages from a queue, it installs an HTTP callback handler. The handler is called by an HTTP POST callback (a web hook) initiated by the task queueing service. Whenever a new task is added to a queue a callback will be sent. The GTask component abstracts from these details and supports endpoint URIs that make message queueing on GAE as easy as message queueing with JMS or SEDA.

Message headers

On the consumer-side all headers of the Servlet component component are supported.

In addition the following GTaskBinding headers are used by on the consumer-side.

NameTypeDescription
GTASK_QUEUE_NAME String Name of the task queue.
GTASK_TASK_NAME String Name of the task.
GTASK_RETRY_COUNT int Number of callback retries.
HTTP — provides endpoints for consuming external HTTP resources
HTTP4 — provides endpoints for consuming external HTTP resources using Apache HttpClient 4.x
Jetty — provides endpoints for consuming HTTP requests
Restlet — provides Restlet-based endpoints for consuming and producing RESTful resources
Servlet — provides support for HTTP endpoints that are published as servlets

Name

HTTP — provides endpoints for consuming external HTTP resources

Name

HTTP4 — provides endpoints for consuming external HTTP resources using Apache HttpClient 4.x

HttpEndpoint options

Table 5.4 lists the options for an HTTP4 endpoint.

Table 5.4. HTTP4 endpoint options

NameDefaultDescription
x509HostnameVerifierBrowserCompatHostnameVerifier [a] Specifies an X509HostnameVerifier[a] instance in the registry.
throwExceptionOnFailuretrueSpecifies if you want to disable throwing the HttpOperationFailedException in case of failed responses from the remote server. This allows you to get all responses regardless of the HTTP status code.
bridgeEndpointfalseSpecifies if the HttpProducer ignores the Exchange.HTTP_URI header, and use the endpoint's URI for request. If the option is true, HttpProducer and CamelServlet will skip the gzip processing if the content-encoding is gzip.
disableStreamCachefalseSpecifies if the DefaultHttpBinding copies the request input stream directly into the message body. The default setting is to copy the request input stream into a stream cache and into the message body to support reading the message twice.
httpBindingnullSpecifies a reference to a HttpBinding[b] in the registry.
httpClientConfigurernullSpecifies a reference to a HttpClientConfigurer [b] in the registry.
httpClient.XXX Specifies options to set on the BasicHttpParams. For instance, httpClient.soTimeout=5000 will set the SO_TIMEOUT to 5 seconds.
clientConnectionManagernullSpecifies a custom ClientConnectionManager [c].
transferExceptionfalseSpecifies if a producer will throw the received exception if the received exception was serialized in the response as a application/x-java-serialized-object content type.
maxTotalConnections200Specifies the maximum number of connections.
connectionsPerRoute20Specifies the maximum number of connections per route.

[a] In the package org.apache.http.conn.ssl.

[b] In the org.apache.camel.component.http package.

[c] In the org.apache.http.conn package.


Name

Jetty — provides endpoints for consuming HTTP requests

Overview

The Jetty component provides HTTP-based endpoints for consuming HTTP requests. That is, the Jetty component behaves as a simple Web server.

The Jetty component only supports consumer endpoints. Therefore a Jetty endpoint URI should be used only as the input for a Apache Camel route. To issue HTTP requests against other HTTP endpoints, use the HTTP Component.

Jetty is stream based, which means the input it receives is submitted to Camel as a stream. That means you will only be able to read the content of the stream once. If you find a situation where the message body appears to be empty or you need to access the data multiple times (eg: doing multicasting, or redelivery error handling) you should use Stream Caching or convert the message body to a String which is safe to be re-read multiple times.

Options

Table 5.6 lists the options for a Jetty endpoint.

Table 5.6. Jetty options

NameDefaultDescription
sessionSupportfalseSpecifies whether to enable the session manager on the server side of Jetty.
httpClient.XXX Specifies options to set on Jetty's HttpClient. For example, setting httpClient.idleTimeout=30000 sets the idle timeout to 30 seconds.
httpBindingRef Specifies a reference to an org.apache.camel.component.http.HttpBinding in the registry.
jettyHttpBindingRef Specifies a reference to an org.apache.camel.component.jetty.JettyHttpBinding in the registry.
matchOnUriPrefixfalseSpecifies whether or not the CamelServlet should try to find a target consumer by matching the URI prefix if no exact match is found.
handlers Specifies a comma-delimited set of org.mortbay.jetty.Handler instances in the registry that are added to the Jetty servlet context.
chunkedtrueSpecifies if the Jetty servlet uses HTTP streaming.
enableJmxfalseSpecifies if Jetty JMX support will be enabled for this endpoint.
disableStreamCachefalseSpecifies if the raw input stream from Jetty is cached or not.
bridgeEndpointfalse

Specifies if the HttpProducer and CamelServlet will skip the gzip processing when the content-encoding is gzip.

enableMultipartFiltertrueSpecifies if Jetty org.eclipse.jetty.servlets.MultiPartFilter is enabled. You should set this value to false when bridging endpoints, to ensure multipart requests are proxied/bridged as well.
multipartFilterRef Specifies a reference to a custom multipart filter. Setting multipartFilterRef forces the value of enableMultipartFilter to true.
continuationTimeout30000Specifies a timeout, in milliseconds, when using Jetty as consumer. Zero or a negative value means the endpoint will never timeout. This option is only used when using Jetty with the asynchronous routing engine.
useContinuationtrueSpecifies whether or not to use Jetty continuations for the Jetty server.

Message Headers

Apache Camel uses the same message headers as the HTTP component. It also uses the CamelHttpChunked header to turn on or turn off the chuncked encoding on the consumer.

Apache Camel also populates all request.parameter and request.headers. For example, given a client request with the URL http://myserver/myserver?orderid=123, the exchange will contain a header named orderid with the value 123.

Name

Restlet — provides Restlet-based endpoints for consuming and producing RESTful resources

Name

Servlet — provides support for HTTP endpoints that are published as servlets

Message headers

Apache Camel will apply the same Message Headers as the HTTP component.

Apache Camel will also populate all request.parameter and request.headers. For example, if a client request has the URL, http://myserver/myserver?orderid=123, the exchange will contain a header named orderid with the value 123.

Direct — provides a synchronous connection to any consumer in the same camelContext element
Seda — provides an asynchronous connection to any consumer in the same camelContext element
VM — provides an asynchronous connection to consumers in other camelContext elements

Name

Seda — provides an asynchronous connection to any consumer in the same camelContext element

Overview

Seda endpoints provide asynchronous SEDA behavior, so that messages are exchanged on a BlockingQueue and consumers are invoked in a separate thread from the producer.

Queues are only visible within a single camelContext element. If you want to communicate across camelContext elements, use a vm endpoint.

[Tip]Synchronous

Direct endpoints provide synchronous invocation of any consumers when a producer sends a message exchange.

ActiveMQ — allows messages to be sent to or consumed from a JMS destination using Fuse MQ Enterprise
AMQP — supports the AMQP protocol
IRC — sends and receives messages using the IRC protocol
JMS — allows message to be sent to or consumed from JMS destinations
Mail — provides access to e-mail systems
MSMQ — works with Microsoft Message Queuing
SIP — supports the SIP Publish and Subscribe capability as described in the [RFC3903 - Session Initiation Protocol (SIP) Extension for Event]
SMPP — provides access to an SMSC (Short Message Service Center) over the SMPP protocol
XMPP — allows for sending and receiving messages over the XMPP transport

Name

IRC — sends and receives messages using the IRC protocol

Name

JMS — allows message to be sent to or consumed from JMS destinations

Overview

The JMS component allows messages to be sent to (or consumed from) a JMS destination. The implementation of the JMS Component uses Spring's JMS support for declarative transactions, using Spring's JmsTemplate for sending and a MessageListenerContainer for consuming.

[Tip]Using ActiveMQ

If you are using Fuse MQ Enterprise, you should use the ActiveMQ endpoint. It has been optimized for Fuse MQ Enterprise.

Options

Table 7.2 lists the options for a JMS endpoint.

[Note]Note

Many of these properties map to properties on Spring JMS, which Apache Camel uses for sending and receiving messages. You can get more information about these properties by consulting the relevant Spring documentation.

Table 7.2. JMS options

OptionDefaultDescription
acceptMessagesWhileStoppingfalseSpecifies whether the consumer accept messages while it is stopping.
acknowledgementModeNameAUTO_ACKNOWLEDGE

Specifies the JMS acknowledgement mode. Valid values are:

  • TRANSACTED

  • CLIENT_ACKNOWLEDGE

  • AUTO_ACKNOWLEDGE

  • DUPS_OK_ACKNOWLEDGE

acknowledgementMode-1Specifies the JMS acknowledgement mode defined as an integer. Allows you to set vendor-specific extensions to the acknowledgment mode. For the regular modes, it is preferable to use the acknowledgementModeName instead.
alwaysCopyMessagefalseSpecifies if Apache Camel will make a JMS message copy of the message when it is passed to the producer for sending.
autoStartuptrueSpecifies whether the consumer container should auto-startup.
cacheLevelNameCACHE_CONSUMER

Specifies the cache level by name for the underlying JMS resources. Possible values are:

  • CACHE_AUTO

  • CACHE_CONNECTION

  • CACHE_CONSUMER

  • CACHE_NONE

  • CACHE_SESSION

cacheLevel-1Specifies the cache level by ID for the underlying JMS resources.
clientIdnullSpecifies the JMS client ID to use. This value, if specified, must be unique and can only be used by a single JMS connection instance. It is typically only required for durable topic subscriptions.
consumerTypeDefault

Specifies the consumer type to use. Valid values are one of:

  • Simple

  • Default

  • ServerSessionPool

The consumer type determines which Spring JMS listener to use.

concurrentConsumers 1 Specifies the default number of concurrent consumers.
connectionFactory null Specifies the default JMS connection factory to use for the listenerConnectionFactory and templateConnectionFactory, if neither is specified.
deliveryMode 2 Specifies the delivery mode when sending messages. 1 = non-persistent; 2 = persistent.
deliveryPersistent true Specifies whether persistent delivery is used by default.
destination null Specifies the JMS Destination object to use on this endpoint.
destinationName null Specifies the JMS destination name to use on this endpoint.
destinationResolver null Specifies an implementation of the Spring framework's DestinationResolver to use.
disableReplyTo false Specifies whether to ignore the JMSReplyTo header and treat messages as InOnly by default.
durableSubscriptionName null Specifies the durable subscriber name for specifying durable topic subscriptions. The clientId option must be configured as well.
eagerLoadingOfProperties false Enables eager loading of JMS properties as soon as a message is received.
exceptionListener null Specifies the JMS Exception Listener that is to be notified of any underlying JMS exceptions.
explicitQosEnabledfalseSpecifies whether the deliveryMode, priority or timeToLive qualities of service should be used when sending messages.
exposeListenerSession true Specifies whether the listener session should be exposed when consuming messages.
idleTaskExecutionLimit 1 Specifies the limit for idle executions of a receive task, not having received any message within its execution. If this limit is reached, the task will shut down and leave receiving to other executing tasks.
jmsMessageType null

Forces the use of a specific javax.jms.Message implementation for sending JMS messages. Possible values are:

  • Bytes

  • Map

  • Object

  • Stream

  • Text

jmsKeyFormatStrategy default

Specifies a pluggable strategy for encoding and decoding JMS keys so they can be compliant with the JMS specification. Apache Camel provides two implementations out of the box:

  • default

  • passthrough

jmsOperations null Specifies an implementation of the Spring Framework's JmsOperations interface to use in place of JmsTemplate.
lazyCreateTransactionManager true Specifies if Apache Camel will create a JmsTransactionManager when no transactionManager injected when transacted=true.
listenerConnectionFactory null Specifies the JMS connection factory used for consuming messages.
mapJmsMessagetrueSpecifies whether Apache Camel should auto map the received JMS message to an appropriate payload type, such as javax.jms.TextMessage to a String etc.
maxConcurrentConsumers1 Specifies the maximum number of concurrent consumers.
maxMessagesPerTask-1 (unlimited)Specifies the maximum number of messages per task.
messageConverternullSpecifies a custom implementation of the Spring MessageConverter so you can control how to map to/from a javax.jms.Message.
messageIdEnabled true Specifies whether message IDs should be added to outgoing messages.
messageTimestampEnabledtrue Specifies whether timestamps should be enabled by default on sending messages.
password null Specifies the password for the connector factory.
priority 4 Specifies the priority of outgoing messages. The explicitQosEnabled option must also be enabled in order for this option to have any effect.
pubSubNoLocal false Specifies whether to inhibit the delivery of messages published by its own connection.
receiveTimeout Specifies the timeout for receiving messages (in milliseconds).
recoveryInterval 5000 Specifies the interval between recovery attempts, in milliseconds.
preserveMessageQos false Specifies if you want to send message using the QoS settings specified on the message instead of the QoS settings on the JMS endpoint. The following three headers are considered: JMSPriority, JMSDeliveryMode, and JMSExpiration.
replyTo null Specifies an explicit ReployTo destination, which overrides any incoming value of Message.getJMSReplyTo().
replyToDestinationSelectorName null Specifies the JMS Selector using the fixed name to be used so you can filter out your own replies from the others when using a shared queue (that is, if you are not using a temporary reply queue).
replyToDeliveryPersistent true Specifies whether to use persistent delivery by default for replies.
requestTimeout 20000 Specifies the timeout for waiting for a reply when using the InOut Exchange Pattern in milliseconds.
selector null Specifies the JMS Selector, which is an SQL 92 predicate that is used to filter messages within the broker.
taskExecutor null Specifies a custom task executor for consuming messages.
taskExecutorSpring2 null Specifies a custom task executor for consuming messages when using Spring 2.x.
templateConnectionFactory null Specifies the JMS connection factory used for sending messages.
timeToLive null Specifies the time-to-live of the message in milliseconds. The explicitQosEnabled option must also be enabled in order for this option to have any effect.
transacted false Specifies whether to use transacted mode for sending/receiving messages using the InOnly Exchange Pattern.
transactionManager null Specifies the Spring transaction manager to use.
transactionName null Specifies the name of the transaction to use.
transactionTimeout null Specifies the timeout value of the transaction.
transferException false Specifies if enabled an exception thrown by a client during processing is returned as the response message.
transferExchange false Specifies if the exchange is transmitted over the wire instead of just the body and headers. The following fields are transferred: In body, Out body, Fault body, In headers, Out headers, Fault headers, exchange properties, exchange exception.
username null Specifies the username for the connector factory.
useMessageIDAsCorrelationID false Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages.

Name

Mail — provides access to e-mail systems

Options

Table 7.7 describes the options for Mail endpoints.

Table 7.7. Mail endpoint options

PropertyDefaultDescription
host   The host name or IP address to connect to.
port See Table 7.6 The TCP port number to connect on.
username  The user name on the email server.
password  The password on the email server.
ignoreUriScheme false If false, Apache Camel uses the scheme to determine the transport protocol (POP, IMAP, SMTP etc.)
defaultEncoding   The default encoding to use for Mime Messages.
contentType text/plain The mail message content type. Use text/html for HTML mails.
folderName INBOX The folder to poll.
to username@host The recipients. Separate multiple email addresses with a comma.
CC  The CC recipients. Separate multiple email addresses with a comma.
BCC The BCC recipients. Separate multiple email addresses with a comma.
from camel@localhost The FROM email address.
subject  The Subject of the message being sent. Note: Setting the subject in the header takes precedence over this option.
delete false Deletes the messages after they have been processed. This is done by setting the DELETED flag on the mail message. If false, the SEEN flag is set instead.
unseen true Is used to only fetch unseen(new) messages. POP3 does not support the SEEN flag.
fetchSize -1 Specifies the maximum number of messages to consume during a poll.The default value of -1 means all available messages will be consumed. Setting the value to 0 means Apache Camel will not consume any messages.
alternativeBodyHeader CamelMailAlternativeBody Specifies the key to an IN message header that contains an alternative email body. For example, if you send emails in text/html format and want to provide an alternative mail body for non-HTML email clients, set the alternative mail body with this key as a header.
debugMode false Specifies if debug mode is enabled on the underlying mail framework. The SUN Mail framework logs the debug messages to System.out by default.
connectionTimeout 30000 The connection timeout can be configured in milliseconds.
consumer.initialDelay 1000 Milliseconds before the polling starts.
consumer.delay 60000 Specifies the consumer delay in milliseconds.
consumer.useFixedDelay false Set to true to use a fixed delay between polls, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
mail.XXX  You can set any additional java mail properties.
maxMessagesPerPoll 0 Specifies the maximum number of messages to gather per poll. The default value of 0 (or a negative value) disables this option.
javaMailSender  Specifies a custom implementation of the Spring JavaMailSender interface in order to use a custom email implementation. If none provided, Apache Camel uses the default Spring JavaMailSenderImpl implementation.
ignoreUnsupportedCharset false Option to let Apache Camel ignore unsupported charsets in the local JVM when sending mails. If the charset is unsupported then charset=XXX is removed from the content-type and it relies on the platform default instead.

SUN JavaMail

SUN JavaMail is used under the hood for consuming and producing mails. We encourage end-users to consult these references when using either POP3 or IMAP protocol. Note particularly that POP3 has a much more limited set of features than IMAP.

Name

SIP — supports the SIP Publish and Subscribe capability as described in the [RFC3903 - Session Initiation Protocol (SIP) Extension for Event]

Options

Table 7.9 lists the options for a SIP endpoint.

Table 7.9. SIP Options

Name Default Value Description
stackName NAME_NOT_SET Name of the SIP Stack instance associated with an SIP Endpoint.
transport tcp Setting for choice of transport potocol. Valid choices are "tcp" or "udp".
fromUser   Username of the message originator. Mandatory setting unless a registry based custom FromHeader is specified.
fromHost   Hostname of the message originator. Mandatory setting unless a registry based FromHeader is specified
fromPort   Port of the message originator. Mandatory setting unless a registry based FromHeader is specified
toUser   Username of the message receiver. Mandatory setting unless a registry based custom ToHeader is specified.
toHost   Hostname of the message receiver. Mandatory setting unless a registry based ToHeader is specified
toPort   Portname of the message receiver. Mandatory setting unless a registry based ToHeader is specified
maxforwards 0 the number of intermediaries that may forward the message to the message receiver. Optional setting. May alternatively be set using as registry based MaxForwardsHeader
eventId   Setting for a String based event Id. Mandatory setting unless a registry based FromHeader is specified
eventHeaderName   Setting for a String based event Id. Mandatory setting unless a registry based FromHeader is specified
maxMessageSize 1048576 Setting for maximum allowed Message size in bytes.
cacheConnections false Should connections be cached by the SipStack to reduce cost of connection creation. This is useful if the connection is used for long running conversations.
consumer false This setting is used to determine whether the kind of header (FromHeader,ToHeader etc) that needs to be created for this endpoint
automaticDialogSupport off Setting to specify whether every communication should be associated with a dialog.
contentType text Setting for contentType can be set to any valid MimeType.
contentSubType xml Setting for contentSubType can be set to any valid MimeSubType.
receiveTimeoutMillis 10000 Setting for specifying amount of time to wait for a Response and/or Acknowledgement can be received from another SIP stack
useRouterForAllUris false This setting is used when requests are sent to the Presence Agent via a proxy.
msgExpiration 3600 The amount of time a message received at an endpoint is considered valid
presenceAgent false This setting is used to distingish between a Presence Agent & a consumer. This is due to the fact that the SIP Camel component ships with a basic Presence Agent (for testing purposes only). Consumers have to set this flag to true.

Registry based options

SIP requires a number of headers to be sent/received as part of a request. These SIP header can be enlisted in the Registry, such as in the Spring XML file.

Table 7.10 describes the values.

Table 7.10. SIP registry based options

Name Description
fromHeader a custom Header object containing message originator settings. Must implement the type javax.sip.header.FromHeader
toHeader a custom Header object containing message receiver settings. Must implement the type javax.sip.header.ToHeader
viaHeaders List of custom Header objects of the type javax.sip.header.ViaHeader. Each ViaHeader containing a proxy address for request forwarding. (Note this header is automatically updated by each proxy when the request arrives at its listener)
contentTypeHeader a custom Header object containing message content details. Must implement the type javax.sip.header.ContentTypeHeader
callIdHeader a custom Header object containing call details. Must implement the type javax.sip.header.CallIdHeader
maxForwardsHeader a custom Header object containing details on maximum proxy forwards. This header places a limit on the viaHeaders possible. Must implement the type javax.sip.header.MaxForwardsHeader
eventHeader a custom Header object containing event details. Must implement the type javax.sip.header.EventHeader
contactHeader an optional custom Header object containing verbose contact details (email, phone number etc). Must implement the type javax.sip.header.ContactHeader
expiresHeader a custom Header object containing message expiration details. Must implement the type javax.sip.header.ExpiresHeader
extensionHeader a custom Header object containing user/application specific details. Must implement the type javax.sip.header.ExtensionHeader

Name

SMPP — provides access to an SMSC (Short Message Service Center) over the SMPP protocol

Overview

This component provides access to an SMSC (Short Message Service Center) over the SMPP protocol to send and receive SMS. The JSMPP library is used to implement the connections.

Options

Table 7.11 lists the options for a SMPP endpoint.

Table 7.11. SMPP Options

NameDefault ValueDescription
password password Specifies the password to use to log in to the SMSC.
systemType cp This parameter is used to categorize the type of ESME (External Short Message Entity) that is binding to the SMSC (max. 13 characters).
dataCoding 0

Defines encoding of data according the SMPP 3.4 specification, section 5.2.19. Example data encodings are: 0: SMSC Default Alphabet 4: 8 bit Alphabet 8: UCS2 Alphabet

encoding ISO-8859-1 Defines the encoding scheme of the short message user data.
enquireLinkTimer 5000 Defines the interval in milliseconds between the confidence checks. The confidence check is used to test the communication path between an ESME and an SMSC.
transactionTimer 10000 Defines the maximum period of inactivity allowed after a transaction, after which an SMPP entity may assume that the session is no longer active. This timer may be active on either communicating SMPP entity (i.e. SMSC or ESME).
initialReconnectDelay 5000 Defines the initial delay in milliseconds after the consumer/producer tries to reconnect to the SMSC, after the connection was lost.
reconnectDelay 5000 Defines the interval in milliseconds between the reconnect attempts, if the connection to the SMSC was lost and the previous was not succeed.
registeredDelivery 1

Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined: 0: No SMSC delivery receipt requested. 1: SMSC delivery receipt requested where final delivery outcome is success or failure. 2: SMSC delivery receipt requested where the final delivery outcome is delivery failure.

serviceType CMT

The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined:

  • CMT: Cellular Messaging

  • CPT: Cellular Paging

  • VMN: Voice Mail Notification

  • VMA: Voice Mail Alerting

  • WAP: Wireless Application Protocol

  • USSD: Unstructured Supplementary Services Data

sourceAddr 1616 Defines the address of SME (Short Message Entity) which originated this message.
destAddr 1717 Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS.
sourceAddrTon 0

Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined:

  • 0: Unknown

  • 1: International

  • 2: National

  • 3: Network Specific

  • 4: Subscriber Number

  • 5: Alphanumeric

  • 6: Abbreviated

destAddrTon 0

Defines the type of number (TON) to be used in the SME destination address parameters. The following TON values are defined:

  • 0: Unknown

  • 1: International

  • 2: National

  • 3: Network Specific

  • 4: Subscriber Number

  • 5: Alphanumeric

  • 6: Abbreviated

sourceAddrNpi 0

Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined:

  • 0: Unknown

  • 1: ISDN (E163/E164)

  • 2: Data (X.121)

  • 3: Telex (F.69)

  • 6: Land Mobile (E.212)

  • 8: National

  • 9: Private

  • 10: ERMES

  • 13: Internet (IP)

  • 18: WAP Client Id (to be defined by WAP Forum)

destAddrNpi 0

Defines the numeric plan indicator (NPI) to be used in the SME destination address parameters. The following NPI values are defined:

  • 0: Unknown

  • 1: ISDN (E163/E164)

  • 2: Data (X.121)

  • 3: Telex (F.69)

  • 6: Land Mobile (E.212)

  • 8: National

  • 9: Private

  • 10: ERMES

  • 13: Internet (IP)

  • 18: WAP Client Id (to be defined by WAP Forum)

priorityFlag 1

Allows the originating SME to assign a priority level to the short message. Four Priority Levels are supported:

  • 0: Level 0 (lowest) priority

  • 1: Level 1 priority

  • 2: Level 2 priority

  • 3: Level 3 (highest) priority

replaceIfPresentFlag 0

Used to request the SMSC to replace a previously submitted message, that is still pending delivery. The SMSC will replace an existing message provided that the source address, destination address and service type match the same fields in the new message. The following replace if present flag values are defined:

  • 0: Don't replace

  • 1: Replace

dataCoding 0

Defines encoding of data according the SMPP 3.4 specification, section 5.2.19. Example data encodings are: 0: SMSC Default Alphabet 4: 8 bit Alphabet 8: UCS2 Alphabet

typeOfNumber 0

Defines the type of number (TON) to be used in the SME. The following TON values are defined:

  • 0: Unknown

  • 1: International

  • 2: National

  • 3: Network Specific

  • 4: Subscriber Number

  • 5: Alphanumeric

  • 6: Abbreviated

numberingPlanIndicator 0

Defines the numeric plan indicator (NPI) to be used in the SME. The following NPI values are defined:

  • 0: Unknown

  • 1: ISDN (E163/E164)

  • 2: Data (X.121)

  • 3: Telex (F.69)

  • 6: Land Mobile (E.212)

  • 8: National

  • 9: Private

  • 10: ERMES

  • 13: Internet (IP)

  • 18: WAP Client Id (to be defined by WAP Forum)


Message headers

Table 7.12 describes the message headers that affect the behavior of the SMPP producer.

Table 7.12. SMPP producer headers

Header Description
CamelSmppDestAddr Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS.
CamelSmppDestAddrTon

Defines the type of number (TON) to be used in the SME destination address parameters. The following TON values are defined:

  • 0: Unknown

  • 1: International

  • 2: National

  • 3: Network Specific

  • 4: Subscriber Number

  • 5: Alphanumeric

  • 6: Abbreviated

CamelSmppDestAddrNpi

Defines the numeric plan indicator (NPI) to be used in the SME destination address parameters. The following NPI values are defined:

  • 0: Unknown

  • 1: ISDN (E163/E164)

  • 2: Data (X.121)

  • 3: Telex (F.69)

  • 6: Land Mobile (E.212)

  • 8: National

  • 9: Private

  • 10: ERMES

  • 13: Internet (IP)

  • 18: WAP Client Id (to be defined by WAP Forum)

CamelSmppSourceAddr Defines the address of SME (Short Message Entity) which originated this message.
CamelSmppSourceAddrTon

Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined:

  • 0: Unknown

  • 1: International

  • 2: National

  • 3: Network Specific

  • 4: Subscriber Number

  • 5: Alphanumeric

  • 6: Abbreviated

CamelSmppSourceAddrNpi

Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined:

  • 0: Unknown

  • 1: ISDN (E163/E164)

  • 2: Data (X.121)

  • 3: Telex (F.69)

  • 6: Land Mobile (E.212)

  • 8: National

  • 9: Private

  • 10: ERMES

  • 13: Internet (IP)

  • 18: WAP Client Id (to be defined by WAP Forum)

CamelSmppServiceType

The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined:

  • CMT: Cellular Messaging

  • CPT: Cellular Paging

  • VMN: Voice Mail Notification

  • VMA: Voice Mail Alerting

  • WAP: Wireless Application Protocol

  • USSD: Unstructured Supplementary Services Data

CamelSmppRegisteredDelivery

Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined:

  • 0: No SMSC delivery receipt requested.

  • 1: SMSC delivery receipt requested where final delivery outcome is success or failure.

  • 2: SMSC delivery receipt requested where the final delivery outcome is delivery failure.

CamelSmppPriorityFlag

Allows the originating SME to assign a priority level to the short message. Four Priority Levels are supported:

  • 0: Level 0 (lowest) priority

  • 1: Level 1 priority

  • 2: Level 2 priority

  • 3: Level 3 (highest) priority

CamelSmppScheduleDeliveryTime This parameter specifies the scheduled time at which the message delivery should be first attempted. It defines either the absolute date and time or relative time from the current SMSC time at which delivery of this message will be attempted by the SMSC. It can be specified in either absolute time format or relative time format. The encoding of a time format is specified in chapter 7.1.1. in the smpp specification v3.4.
CamelSmppValidityPeriod The validity period parameter indicates the SMSC expiration time, after which the message should be discarded if not delivered to the destination. It can be defined in absolute time format or relative time format. The encoding of absolute and relative time format is specified in chapter 7.1.1 in the smpp specification v3.4.
CamelSmppReplaceIfPresentFlag

The replace if present flag parameter is used to request the SMSC to replace a previously submitted message, that is still pending delivery. The SMSC will replace an existing message provided that the source address, destination address and service type match the same fields in the new message. The following values are defined:

  • 0: Don't replace

  • 1: Replace

CamelSmppDataCoding

The data coding according to the SMPP 3.4 specification, section 5.2.19: 0: SMSC Default Alphabet 4: 8 bit Alphabet 8: UCS2 Alphabet


The following message headers are used by the SMPP producer to set the response from the SMSC in the message header


The following message headers are used by the SMPP consumer to set the request data from the SMSC in the message header.

Table 7.14. SMMP consumer headers

Header Description
CamelSmppSequenceNumber only for alert notification, deliver sm and data sm: A sequence number allows a response PDU to be correlated with a request PDU. The associated SMPP response PDU must preserve this field.
CamelSmppCommandId only for alert notification, deliver sm and data sm: The command id field identifies the particular SMPP PDU. For the complete list of defined values see chapter 5.1.2.1 in the smpp specification v3.4.
CamelSmppSourceAddr only for alert notification, deliver sm and data sm: Defines the address of SME (Short Message Entity) which originated this message.
CamelSmppSourceAddrNpi

only for alert notification and data sm: Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined:

  • 0: Unknown

  • 1: ISDN (E163/E164)

  • 2: Data (X.121)

  • 3: Telex (F.69)

  • 6: Land Mobile (E.212)

  • 8: National

  • 9: Private

  • 10: ERMES

  • 13: Internet (IP)

  • 18: WAP Client Id (to be defined by WAP Forum)

CamelSmppSourceAddrTon

only for alert notification and data sm: Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined:

  • 0: Unknown

  • 1: International

  • 2: National

  • 3: Network Specific

  • 4: Subscriber Number

  • 5: Alphanumeric

  • 6: Abbreviated

CamelSmppEsmeAddr only for alert notification: Defines the destination ESME address. For mobile terminated messages, this is the directory number of the recipient MS.
CamelSmppEsmeAddrNpi

only for alert notification: Defines the numeric plan indicator (NPI) to be used in the ESME originator address parameters. The following NPI values are defined:

  • 0: Unknown

  • 1: ISDN (E163/E164)

  • 2: Data (X.121)

  • 3: Telex (F.69)

  • 6: Land Mobile (E.212)

  • 8: National

  • 9: Private

  • 10: ERMES

  • 13: Internet (IP)

  • 18: WAP Client Id (to be defined by WAP Forum)

CamelSmppEsmeAddrTon

only for alert notification: Defines the type of number (TON) to be used in the ESME originator address parameters. The following TON values are defined:

  • 0: Unknown

  • 1: International

  • 2: National

  • 3: Network Specific

  • 4: Subscriber Number

  • 5: Alphanumeric

  • 6: Abbreviated

CamelSmppId only for smsc delivery receipt and data sm: The message ID allocated to the message by the SMSC when originally submitted.
CamelSmppDelivered only for smsc delivery receipt: Number of short messages delivered. This is only relevant where the original message was submitted to a distribution list.The value is padded with leading zeros if necessary.
CamelSmppDoneDate only for smsc delivery receipt: The time and date at which the short message reached it's final state. The format is as follows: YYMMDDhhmm.
CamelSmppStatus

only for smsc delivery receipt and data sm: The final status of the message. The following values are defined:

  • DELIVRD: Message is delivered to destination

  • EXPIRED: Message validity period has expired.

  • DELETED: Message has been deleted.

  • UNDELIV: Message is undeliverable

  • ACCEPTD: Message is in accepted state (i.e. has been manually read on behalf of the subscriber by customer service)

  • UNKNOWN: Message is in invalid state

  • REJECTD: Message is in a rejected state

CamelSmppError only for smsc delivery receipt: Where appropriate this may hold a Network specific error code or an SMSC error code for the attempted delivery of the message. These errors are Network or SMSC specific and are not included here.
CamelSmppSubmitDate only for smsc delivery receipt: The time and date at which the short message was submitted. In the case of a message which has been replaced, this is the date that the original message was replaced. The format is as follows: YYMMDDhhmm.
CamelSmppSubmitted only for smsc delivery receipt: Number of short messages originally submitted. This is only relevant when the original message was submitted to a distribution list.The value is padded with leading zeros if necessary.
CamelSmppDestAddr only for deliver sm and data sm: Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS.
CamelSmppScheduleDeliveryTime only for deliver sm and data sm: This parameter specifies the scheduled time at which the message delivery should be first attempted. It defines either the absolute date and time or relative time from the current SMSC time at which delivery of this message will be attempted by the SMSC. It can be specified in either absolute time format or relative time format. The encoding of a time format is specified in Section 7.1.1. in the smpp specification v3.4.
CamelSmppValidityPeriod only for deliver sm: The validity period parameter indicates the SMSC expiration time, after which the message should be discarded if not delivered to the destination. It can be defined in absolute time format or relative time format. The encoding of absolute and relative time format is specified in Section 7.1.1 in the smpp specification v3.4.
CamelSmppServiceType only for deliver sm and data sm: The service type parameter indicates the SMS Application service associated with the message.
CamelSmppRegisteredDelivery

only for data sm: Is used to request an delivery receipt and/or SME originated acknowledgements. The following values are defined: 0: No SMSC delivery receipt requested. 1: SMSC delivery receipt requested where final delivery outcome is success or failure. 2: SMSC delivery receipt requested where the final delivery outcome is delivery failure.

CamelSmppDestAddrNpi

only for data sm: Defines the numeric plan indicator (NPI) in the destination address parameters. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum)

CamelSmppDestAddrTon

only for data sm: Defines the type of number (TON) in the destination address parameters. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated


Quartz — provides a scheduled delivery of messages using the Quartz scheduler
Timer — generates message exchanges when a timer fires

Name

Quartz — provides a scheduled delivery of messages using the Quartz scheduler

Name

Timer — generates message exchanges when a timer fires

Mock — provides a declarative framework for testing routes
Test — a mock endpoint that tests messages based on a set of expected messages

Name

Mock — provides a declarative framework for testing routes

Overview

Mock endpoints provide a powerful declarative testing mechanism similar to jMock. It allows declarative expectations to be created on any Mock endpoint before a test begins. When the test is run, which typically fires messages to one or more endpoints, the expectations can be asserted in a test case to ensure the system worked as expected.

This allows you to test things like:

  • The correct number of messages are received on each endpoint

  • The correct payloads are received

  • The messages arrive on an endpoint in the right order

[Note]Note

The Test endpoint is a mock endpoint that uses a second endpoint to provide the list of expected message bodies and automatically sets up the mock endpoint assertions.

Table 10.1 list the options for the Atom endpoint.

Table 10.1. Atom Component Options

Property Default Description
splitEntriestrue If true Apache Camel will poll the feed and for the subsequent polls return each entry poll by poll. If the feed contains 7 entries then Apache Camel will return the first entry on the first poll, the 2nd entry on the next poll, until no more entries where as Apache Camel will do a new update on the feed. If false then Apache Camel will poll a fresh feed on every invocation.
filter true Is only used by the split entries to filter the entries to return. Apache Camel will default use the UpdateDateFilter that only return new entries from the feed. So the client consuming from the feed never receives the same entry more than once. The filter will return the entries ordered by the newest last.
lastUpdate null Is only used by the filter, as the starting timestamp for selection never entries (uses the entry.updated timestamp). Syntax format is: yyyy-MM-ddTHH:MM:ss. Example: 2007-12-24T17:45:59.
throttleEntries true Sets whether all entries identified in a single feed poll should be delivered immediately. If true, only one entry is processed per consumer.delay. Only applicable when splitEntries is set to true.
feedHeader true Sets whether to add the Abdera Feed object as a header.
sortEntries false If splitEntries is true, this sets whether to sort those entries by updated date.
consumer.delay 60000 Delay in milliseconds between each poll.
consumer.initialDelay 1000Specifies the number of milliseconds before polling starts.
consumer.userFixedDelay false If true, use fixed delay between pools, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.

Apache Camel will set the In body on the returned Exchange with the entries. Depending on the splitEntries flag Apache Camel will either return one Entry or a List<Entry>.

Option Value Behavior
splitEntries true Only a single entry from the currently being processed feed is set: exchange.in.body(Entry)
splitEntries false The entire list of entries from the feed is set: exchange.in.body(List<Entry>)

Apache Camel can set the Feed object on the in header (see feedHeader option to disable this):

Apache Camel atom uses these headers.

Header Description
org.apache.camel.component.atom.feed Apache Camel 1.x: When consuming the org.apache.abdera.model.Feed object is set to this header.
CamelAtomFeed Apache Camel 2.0: When consuming the org.apache.abdera.model.Feed object is set to this header.

In the following sample we poll James Strachan's blog:

from("atom://http://macstrac.blogspot.com/feeds/posts/default").to("seda:feeds");

In this sample we want to filter only good blogs we like to a SEDA queue. The sample also shows how to set up Apache Camel standalone, not running in any container or using Spring.

@Override
protected CamelContext createCamelContext() throws Exception {
    // We initialize Camel

    SimpleRegistry registry = new SimpleRegistry();
    // First we register a blog service in our bean registry
    registry.put("blogService", new BlogService());

    // Then we create the camel context with our bean registry
    context = new DefaultCamelContext(registry);

    // Then we add all the routes we need using the route builder DSL syntax
    context.addRoutes(createRouteBuilder());

    // And finally we must start Camel to let the magic routing begins
    context.start();

    return context;
}

/**
 * This is the route builder where we create our routes in the advanced Camel DSL syntax
 */
protected RouteBuilder createRouteBuilder() throws Exception {
    return new RouteBuilder() {
        public void configure() throws Exception {
            // We pool the atom feeds from the source for further processing in the seda queue
            // we set the delay to 1 second for each pool as this is a unit test also and we can
            // not wait the default poll interval of 60 seconds.
            // Using splitEntries=true will during polling only fetch one Atom Entry at any given time.
            // As the feed.atom file contains 7 entries, using this will require 7 polls to fetch the entire
            // content. When Camel have reach the end of entries it will refresh the atom feed from URI source
            // and restart - but as Camel by default uses the UpdatedDateFilter it will only deliver new
            // blog entries to "seda:feeds". So only when James Straham updates his blog with a new entry
            // Camel will create an exchange for the seda:feeds.
            from("atom:file:src/test/data/feed.atom?splitEntries=true&consumer.delay=1000").to("seda:feeds");

            // From the feeds we filter each blot entry by using our blog service class
            from("seda:feeds").filter().method("blogService", "isGoodBlog").to("seda:goodBlogs");

            // And the good blogs is moved to a mock queue as this sample is also used for unit testing
            // this is one of the strengths in Camel that you can also use the mock endpoint for your
            // unit tests
            from("seda:goodBlogs").to("mock:result");
        }
    };
}

/**
 * This is the actual junit test method that does the assertion that our routes is working
 * as expected
 */
@Test
public void testFiltering() throws Exception {
    // Get the mock endpoint
    MockEndpoint mock = context.getEndpoint("mock:result", MockEndpoint.class);

    // There should be two good blog entries from the feed
    mock.expectedMinimumMessageCount(2);

    // Asserts that the above expectations is true, will throw assertions exception if it failed
    // Camel will default wait max 20 seconds for the assertions to be true, if the conditions
    // is true sooner Camel will continue
    mock.assertIsSatisfied();
}

/**
 * Services for blogs
 */
public class BlogService {

    /**
     * Tests the blogs if its a good blog entry or not
     */
    public boolean isGoodBlog(Exchange exchange) {
        Entry entry = exchange.getIn().getBody(Entry.class);
        String title = entry.getTitle();            

        // We like blogs about Camel
        boolean good = title.toLowerCase().contains("camel");
        return good;
    }

}

Name Type Default Description
method String null The method name that bean will be invoked. If not provided, Apache Camel will try to pick the method itself. In case of ambiguity an exception is thrown. See Bean Binding for more details.
cache boolean false If enabled, Apache Camel will cache the result of the first Registry look-up. Cache can be enabled if the bean in the Registry is defined as a singleton scope.
multiParameterArray boolean false Apache Camel 1.5: How to treat the parameters which are passed from the message body; if it is true, the In message body should be an array of parameters.

You can append query options to the URI in the following format, ?option=value&option=value&...

The object instance that is used to consume messages must be explicitly registered with the Registry. For example, if you are using Spring you must define the bean in the Spring configuration, spring.xml; or if you don't use Spring, put the bean in JNDI.

// lets populate the context with the services we need
// note that we could just use a spring.xml file to avoid this step
JndiContext context = new JndiContext();
context.bind("bye", new SayService("Good Bye!"));

CamelContext camelContext = new DefaultCamelContext(context);

Once an endpoint has been registered, you can build routes that use it to process exchanges.

// lets add simple route
camelContext.addRoutes(new RouteBuilder() {
    public void configure() {
        from("direct:hello").to("bean:bye");
    }
});

A bean: endpoint cannot be defined as the input to the route; i.e. you cannot consume from it, you can only route from some inbound message Endpoint to the bean endpoint as output. So consider using a direct: or queue: endpoint as the input.

You can use the createProxy() methods on ProxyHelper to create a proxy that will generate BeanExchanges and send them to any endpoint:

Endpoint endpoint = camelContext.getEndpoint("direct:hello");
ISay proxy = ProxyHelper.createProxy(endpoint, ISay.class);
String rc = proxy.say();
assertEquals("Good Bye!", rc);

And the same route using XML DSL:

    <route>
       <from uri="direct:hello">
       <to uri="bean:bye"/>
    </route>

Apache Camel also supports invoking Bean as an Endpoint. In the route below:

<camelContext xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="direct:start"/>
    <to uri="myBean"/>
    <to uri="mock:results"/>
  </route>
</camelContext>

<bean id="myBean" class="org.apache.camel.spring.bind.ExampleBean"/>

What happens is that when the exchange is routed to the myBean Apache Camel will use the Bean Binding to invoke the bean. The source for the bean is just a plain POJO:

public class ExampleBean {

    public String sayHello(String name) {
        return "Hello " + name + "!";
    }
}

Apache Camel will use Bean Binding to invoke the sayHello method, by converting the Exchange's In body to the String type and storing the output of the method on the Exchange Out body.

Available as of Apache Camel 2.3

The Validation component performs bean validation of the message body using the Java Bean Validation API (JSR 303). Apache Camel uses the reference implementation, which is Hibernate Validator.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-bean-validator</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

The following URI options are supported:

Option Default Description
group javax.validation.groups.Default The custom validation group to use.
messageInterpolator org.hibernate.validator.engine. ResourceBundleMessageInterpolator Reference to a custom javax.validation.MessageInterpolator in the Registry.
traversableResolver org.hibernate.validator.engine.resolver. DefaultTraversableResolver Reference to a custom javax.validation.TraversableResolver in the Registry.
constraintValidatorFactory org.hibernate.validator.engine. ConstraintValidatorFactoryImpl Reference to a custom javax.validation.ConstraintValidatorFactory in the Registry.

Assumed we have a java bean with the following annotations

[Note]Car.java
// Java
public class Car {

    @NotNull
    private String manufacturer;

    @NotNull
    @Size(min = 5, max = 14, groups = OptionalChecks.class)
    private String licensePlate;
    
    // getter and setter
}

and an interface definition for our custom validation group

[Note]OptionalChecks.java
public interface OptionalChecks {
}

with the following Apache Camel route, only the @NotNull constraints on the attributes manufacturer and licensePlate will be validated (Apache Camel uses the default group javax.validation.groups.Default).

from("direct:start")
.to("bean-validator://x")
.to("mock:end")

If you want to check the constraints from the group OptionalChecks, you have to define the route like this

from("direct:start")
.to("bean-validator://x?group=OptionalChecks")
.to("mock:end")

If you want to check the constraints from both groups, you have to define a new interface first

[Note]AllChecks.java
@GroupSequence({Default.class, OptionalChecks.class})
public interface AllChecks {
}

and then your route definition should looks like this

from("direct:start")
.to("bean-validator://x?group=AllChecks")
.to("mock:end")

And if you have to provide your own message interpolator, traversable resolver and constraint validator factory, you have to write a route like this

<bean id="myMessageInterpolator" class="my.ConstraintValidatorFactory" />
<bean id="myTraversableResolver" class="my.TraversableResolver" />
<bean id="myConstraintValidatorFactory" class="my.ConstraintValidatorFactory" />

from("direct:start")
.to("bean-validator://x?group=AllChecks&messageInterpolator=#myMessageInterpolator&traversableResolver=#myTraversableResolver&constraintValidatorFactory=#myConstraintValidatorFactory")
.to("mock:end")

It's also possible to describe your constraints as XML and not as Java annotations. In this case, you have to provide the file META-INF/validation.xml which could looks like this

[Note]validation.xml
<?xml version="1.0" encoding="UTF-8"?>
<validation-config
	xmlns="http://jboss.org/xml/ns/javax/validation/configuration"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://jboss.org/xml/ns/javax/validation/configuration">
	<default-provider>org.hibernate.validator.HibernateValidator</default-provider>
	<message-interpolator>org.hibernate.validator.engine.ResourceBundleMessageInterpolator</message-interpolator>
	<traversable-resolver>org.hibernate.validator.engine.resolver.DefaultTraversableResolver</traversable-resolver>
	<constraint-validator-factory>org.hibernate.validator.engine.ConstraintValidatorFactoryImpl</constraint-validator-factory>
	
	<constraint-mapping>/constraints-car.xml</constraint-mapping>
</validation-config>

and the constraints-car.xml file

[Note]constraints-car.xml
<?xml version="1.0" encoding="UTF-8"?>
<constraint-mappings xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://jboss.org/xml/ns/javax/validation/mapping validation-mapping-1.0.xsd"
	xmlns="http://jboss.org/xml/ns/javax/validation/mapping">
	<default-package>org.apache.camel.component.bean.validator</default-package>
	
	<bean class="CarWithoutAnnotations" ignore-annotations="true">
		<field name="manufacturer">
			<constraint annotation="javax.validation.constraints.NotNull" />
		</field>
		
		<field name="licensePlate">
			<constraint annotation="javax.validation.constraints.NotNull" />
			
			<constraint annotation="javax.validation.constraints.Size">
				<groups>
					<value>org.apache.camel.component.bean.validator.OptionalChecks</value>
				</groups>
				<element name="min">5</element>
				<element name="max">14</element>
			</constraint>
		</field>
	</bean>
</constraint-mappings>

Name Default Value Description
maxElementsInMemory 1000 The numer of elements that may be stored in the defined cache
memoryStoreEvictionPolicy MemoryStoreEvictionPolicy.LFU

The number of elements that may be stored in the defined cache. The policy options include:

  • MemoryStoreEvictionPolicy.LFU—Least frequently used.

  • MemoryStoreEvictionPolicy.LRU—Least recently used.

  • MemoryStoreEvictionPolicy.FIFO—First in first out, ordered by creation time.

overflowToDisk true Specifies whether cache may overflow to disk.
eternal false Sets whether elements are eternal. If eternal, timeouts are ignored and the element is never expired.
timeToLiveSeconds 300 The maximum time between creation time and when an element expires. Is only used if the element is not eternal.
timeToIdleSeconds 300 The maximum amount of time between accesses before an element expires.
diskPersistent true Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
diskExpiryThreadIntervalSeconds 120 The number of seconds between runs of the disk expiry thread. The default value is 120 seconds.
cacheManagerFactory null Camel 2.3: If you want to use a custom factory which instantiates and creates the EHCache net.sf.ehcache.CacheManager.
Header Description
CACHE_OPERATION

The operation to be performed on the cache. The valid options are:

  • ADD

  • UPDATE

  • DELETE

  • DELETEALL

CACHE_KEY The cache key used to store the message in the cache. The cache key is optional, if the CACHE_OPERATION is DELETEALL.

EHCache has its own statistics and management from JMX.

Here's a snippet on how to expose them via JMX in a Spring application context:

      <bean id="ehCacheManagementService" class="net.sf.ehcache.management.ManagementService" init-method="init" lazy-init="false">
      <constructor-arg>
      <bean class="net.sf.ehcache.CacheManager" factory-method="getInstance"/>
      </constructor-arg>
      <constructor-arg>
      <bean class="org.springframework.jmx.support.JmxUtils" factory-method="locateMBeanServer"/>
      </constructor-arg>
      <constructor-arg value="true"/>
      <constructor-arg value="true"/>
      <constructor-arg value="true"/>
      <constructor-arg value="true"/>
      </bean>
      
    

Of course you can do the same thing in straight Java:

      ManagementService.registerMBeans(CacheManager.getInstance(), mbeanServer, true, true, true, true);
      
    

You can get cache hits, misses, in-memory hits, disk hits, size stats this way. You can also change CacheConfiguration parameters on the fly.

The class: component binds beans to message exchanges. It works in the same way as the Bean component but instead of looking up beans from a Registry it creates the bean based on the class name.

Name Type Default Description
method String null The method name that bean will be invoked. If not provided, Apache Camel will try to pick the method itself. In case of ambiguity an exception is thrown. See Bean Binding for more details.
multiParameterArray boolean false How to treat the parameters which are passed from the message body; if it is true, the In message body should be an array of parameters.

You can append query options to the URI in the following format, ?option=value&option=value&...

You simply use the class component just as the Bean component but by specifying the fully qualified classname instead. For example to use the MyFooBean you have to do as follows:

    from("direct:start").to("class:org.apache.camel.component.bean.MyFooBean").to("mock:result");

You can also specify which method to invoke on the MyFooBean, for example hello:

    from("direct:start").to("class:org.apache.camel.component.bean.MyFooBean?method=hello").to("mock:result");

In the endpoint uri you can specify properties to set on the created instance, for example if it has a setPrefix method:

    from("direct:start")
        .to("class:org.apache.camel.component.bean.MyPrefixBean?prefix=Bye")
        .to("mock:result");

And you can also use the # syntax to refer to properties to be looked up in the Registry.

    from("direct:start")
        .to("class:org.apache.camel.component.bean.MyPrefixBean?cool=#foo")
        .to("mock:result");

Which will lookup a bean from the Registry with the id foo and invoke the setCool method on the created instance of the MyPrefixBean class.

[Tip]See more

See more details at the Bean component as the class component works in much the same way.

The cometd: component is a transport for working with the jetty implementation of the cometd/bayeux protocol. Using this component in combination with the dojo toolkit library it's possible to push Apache Camel messages directly into the browser using an AJAX based mechanism.

Name Default Value Description
resourceBase The root directory for the web resources or classpath. Use the protocol file: or classpath: depending if you want that the component loads the resource from file system or classpath. Classpath is required for OSGI deployment where the resources are packaged in the jar
timeout 240000 The server side poll timeout in milliseconds. This is how long the server will hold a reconnect request before responding.
interval 0 The client side poll timeout in milliseconds. How long a client will wait between reconnects
maxInterval 30000 The max client side poll timeout in milliseconds. A client will be removed if a connection is not received in this time.
multiFrameInterval 1500 The client side poll timeout, if multiple connections are detected from the same browser.
jsonCommented true If true, the server will accept JSON wrapped in a comment and will generate JSON wrapped in a comment. This is a defence against Ajax Hijacking.
logLevel 1 0=none, 1=info, 2=debug.

You can append query options to the URI in the following format, ?option=value&option=value&...

Here is some examples of how to pass the parameters.

For file (when the Webapp resources are located in the Web Application directory) cometd://localhost:8080?resourceBase=file./webapp. For classpath (when the web resources are packaged inside the Webapp folder) cometd://localhost:8080?resourceBase=classpath:webapp.

Available as of Camel 2.7

The context component allows you to create new Camel Components from a CamelContext with a number of routes which is then treated as a black box, allowing you to refer to the local endpoints within the component from other CamelContexts.

It is similar to the Routebox component in idea, though the Context component tries to be really simple for end users; just a simple convention over configuration approach to refer to local endpoints inside the CamelContext Component.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-context</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

context:camelContextId:localEndpointName[?options]

Or you can omit the "context:" prefix.

camelContextId:localEndpointName[?options]

  • camelContextId is the ID you used to register the CamelContext into the Registry.

  • localEndpointName can be a valid Camel URI evaluated within the black box CamelContext. Or it can be a logical name which is mapped to any local endpoints. For example if you locally have endpoints like direct:invoices and seda:purchaseOrders inside a CamelContext of id supplyChain, then you can just use the URIs supplyChain:invoices or supplyChain:purchaseOrders to omit the physical endpoint kind and use pure logical URIs.

You can append query options to the URI in the following format, ?option=value&option=value&...

First you need to create a CamelContext, add some routes in it, start it and then register the CamelContext into the Registry (JNDI, Spring, Guice or OSGi etc).

This can be done in the usual Camel way from this test case (see the createRegistry() method); this example shows Java and JNDI being used...

// lets create our black box as a camel context and a set of routes
DefaultCamelContext blackBox = new DefaultCamelContext(registry);
blackBox.setName("blackBox");
blackBox.addRoutes(new RouteBuilder() {
    @Override
    public void configure() throws Exception {
        // receive purchase orders, lets process it in some way then send an invoice
        // to our invoice endpoint
        from("direct:purchaseOrder").
          setHeader("received").constant("true").
          to("direct:invoice");
    }
});
blackBox.start();

registry.bind("accounts", blackBox);

Notice in the above route we are using pure local endpoints (direct and seda). Also note we expose this CamelContext using the accounts ID. We can do the same thing in XML via

<camelContext id="accounts" xmlns="http://camel.apache.org/schema/spring">
  <route> 
    <from uri="direct:purchaseOrder"/>
    ...
    <to uri="direct:invoice"/>
  </route>
</camelContext>

Using Apache Camel cryptographic endpoints and Java's Cryptographic extension it is easy to create Digital Signatures for Exchanges. Apache Camel provides a pair of flexible endpoints which get used in concert to create a signature for an exchange in one part of the exchange's workflow and then verify the signature in a later part of the workflow.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-crypto</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

Name Type Default Description
algorithm String DSA The name of the JCE Signature algorithm that will be used.
alias String null An alias name that will be used to select a key from the keystore.
bufferSize Integer 2048 the size of the buffer used in the signature process.
certificate Certificate null A Certificate used to verify the signature of the exchange's payload. Either this or a Public Key is required.
keystore KeyStore null A reference to a JCE Keystore that stores keys and certificates used to sign and verify.
provider String null The name of the JCE Security Provider that should be used.
privateKey PrivatKey null The private key used to sign the exchange's payload.
publicKey PublicKey null The public key used to verify the signature of the exchange's payload.
secureRandom secureRandom null A reference to a SecureRandom object that wil lbe used to initialize the Signature service.
password char[] null The password for the keystore.

The most basic way to way to sign an verify an exchange is with a KeyPair as follows.

from("direct:keypair").to("crypto:sign://basic?privateKey=#myPrivateKey", "crypto:verify://basic?publicKey=#myPublicKey", "mock:result");

The same can be achieved with the Spring XML Extensions using references to keys

<route>
    <from uri="direct:keypair"/>
    <to uri="crypto:sign://basic?privateKey=#myPrivateKey" />
    <to uri="crypto:verify://basic?publicKey=#myPublicKey" />
    <to uri="mock:result"/>
</route>

The JCE provides a very versatile KeyStore for housing pairs of PrivateKeys and Certificates keeping them encrypted and password protected. They can be retrieved from it by applying an alias to the retrieval apis. There are a number of ways to get keys and Certificates into a keystore most often this is done with the external 'keytool' application. This is a good example of using keytool to create a KeyStore with a self signed Cert and Private key.

The examples use a Keystore with a key and cert aliased by 'bob'. The password for the keystore and the key is 'letmein'

The following shows how to use a Keystore via the Fluent builders, it also shows how to load and initialize the keystore.

from("direct:keystore").to("crypto:sign://keystore?keystore=#keystore&alias=bob&password=letmein", "crypto:verify://keystore?keystore=#keystore&alias=bob", "mock:result");

Again in Spring a ref is used to lookup an actual keystore instance.

<route>
    <from uri="direct:keystore"/>
    <to uri="crypto:sign://keystore?keystore=#keystore&lias=bob&assword=letmein" />
    <to uri="crypto:verify://keystore?keystore=#keystore&lias=bob" />
    <to uri="mock:result"/>
</route>        

Changing the Signature algorithm or the Security provider is a simple matter of specifying their names. You will need to also use Keys that are compatible with the algorithm you choose.

KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(512, new SecureRandom());
keyPair = keyGen.generateKeyPair();
PrivateKey privateKey = keyPair.getPrivate();
PublicKey publicKey = keyPair.getPublic();

// we can set the keys explicitly on the endpoint instances.
context.getEndpoint("crypto:sign://rsa?algorithm=MD5withRSA", DigitalSignatureEndpoint.class).setPrivateKey(privateKey);
context.getEndpoint("crypto:verify://rsa?algorithm=MD5withRSA", DigitalSignatureEndpoint.class).setPublicKey(publicKey);
from("direct:algorithm").to("crypto:sign://rsa?algorithm=MD5withRSA", "crypto:verify://rsa?algorithm=MD5withRSA", "mock:result");
from("direct:provider").to("crypto:sign://provider?privateKey=#myPrivateKey&provider=SUN", "crypto:verify://provider?publicKey=#myPublicKey&provider=SUN", "mock:result");

or

<route>
    <from uri="direct:algorithm"/>
    <to uri="crypto:sign://rsa?algorithm=MD5withRSA&rivateKey=#rsaPrivateKey" />
    <to uri="crypto:verify://rsa?algorithm=MD5withRSA&ublicKey=#rsaPublicKey" />
    <to uri="mock:result"/>
</route>        
<route>
    <from uri="direct:provider"/>
    <to uri="crypto:sign://provider?privateKey=#myPrivateKey&rovider=SUN" />
    <to uri="crypto:verify://provider?publicKey=#myPublicKey&rovider=SUN" />
    <to uri="mock:result"/>
</route>        

When using a Recipient list or similar EIP the recipient of an exchange can vary dynamically. Using the same key across all recipients may neither be feasible or desirable. It would be useful to be able to specify the signature keys dynamically on a per exchange basis. The exchange could then be dynamically enriched with the key of its target recipient prior to signing. To facilitate this the signature mechanisms allow for keys to be supplied dynamically via the message headers below

from("direct:headerkey-sign").to("crypto:sign://alias");
from("direct:headerkey-verify").to("crypto:verify://alias", "mock:result");

or

<route>
    <from uri="direct:headerkey-sign"/>
    <to uri="crypto:sign://headerkey" />
</route>       
<route>
    <from uri="direct:headerkey-verify"/>
    <to uri="crypto:verify://headerkey" />
    <to uri="mock:result"/>
</route>    

Better again would be to dynamically supply a keystore alias. Again the alias can be supplied in a message header

from("direct:alias-sign").to("crypto:sign://alias?keystore=#keystore");
from("direct:alias-verify").to("crypto:verify://alias?keystore=#keystore", "mock:result");

or

<route>
    <from uri="direct:alias-sign"/>
    <to uri="crypto:sign://alias?keystore=#keystore" />
</route>       
<route>
    <from uri="direct:alias-verify"/>
    <to uri="crypto:verify://alias?keystore=#keystore" />
    <to uri="mock:result"/>
</route>    

The header would be set as follows

Exchange unsigned = getMandatoryEndpoint("direct:alias-sign").createExchange();
unsigned.getIn().setBody(payload);
unsigned.getIn().setHeader(DigitalSignatureConstants.KEYSTORE_ALIAS, "bob");
unsigned.getIn().setHeader(DigitalSignatureConstants.KEYSTORE_PASSWORD, "letmein".toCharArray());
template.send("direct:alias-sign", unsigned);
Exchange signed = getMandatoryEndpoint("direct:alias-sign").createExchange();
signed.getIn().copyFrom(unsigned.getOut());
signed.getIn().setHeader(KEYSTORE_ALIAS, "bob");
template.send("direct:alias-verify", signed);

See also:

dataset:name[?options]

Where name is used to find the DataSet instance in the Registry

Apache Camel ships with a support implementation of org.apache.camel.component.dataset.DataSet, the org.apache.camel.component.dataset.DataSetSupport class, that can be used as a base for implementing your own DataSet. Apache Camel also ships with a default implementation, the org.apache.camel.component.dataset.SimpleDataSet that can be used for testing.

Option Default Description
produceDelay 3 Allows a delay in ms to be specified, which causes producers to pause in order to simulate slow producers. Uses a minimum of 3 ms delay unless you set this option to -1 to force no delay at all.
consumeDelay 0 Allows a delay in ms to be specified, which causes consumers to pause in order to simulate slow consumers.
preloadSize 0 Sets how many messages should be preloaded (sent) before the route completes its initialization.
initialDelay 1000 Camel 2.1: Time period in millis to wait before starting sending messages.
minRate 0 Wait until the DataSet contains at least this number of messages

You can append query options to the URI in the following format, ?option=value&option=value&...

Apache Camel will lookup in the Registry for a bean implementing the DataSet interface. So you can register your own DataSet as:

   <bean id="myDataSet" class="com.mycompany.MyDataSet">
      <property name="size" value="100"/>
   </bean>

For example, to test that a set of messages are sent to a queue and then consumed from the queue without losing any messages:

// send the dataset to a queue
from("dataset:foo").to("activemq:SomeQueue");

// now lets test that the messages are consumed correctly
from("activemq:SomeQueue").to("dataset:foo");

The above would look in the Registry to find the foo DataSet instance which is used to create the messages.

Then you create a DataSet implementation, such as using the SimpleDataSet as described below, configuring things like how big the data set is and what the messages look like etc.

Property Type Description
defaultBody Object Specifies the default message body. For SimpleDataSet it is a constant payload; though if you want to create custom payloads per message, create your own derivation of DataSetSupport.
reportGroup long Specifies the number of messages to be received before reporting progress. Useful for showing progress of a large load test.
size long Specifies how many messages to send/consume.

Available as of Camel 2.5

The db4o: component allows you to work with db4o NoSQL database. The camel-db4o library is provided by the Camel Extra project which hosts all *GPL related components for Camel.

Name Default Value Description
consumeDelete true Option for Db4oConsumer only. Specifies whether or not the entity is deleted after it is consumed.
consumer.delay 500 Option for HibernateConsumer only. Delay in millis between each poll.
consumer.initialDelay 1000 Option for HibernateConsumer only. Millis before polling starts.
consumer.userFixedDelay false Option for HibernateConsumer only. Set to true to use fixed delay between polls, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.

Available as of Camel 2.7

This is an additional component for Camel to run DNS queries, using DNSJava. The component is a thin layer on top of DNSJava. The component offers the following operations:

  • ip, to resolve a domain by its ip

  • lookup, to lookup information about the domain

  • dig, to run DNS queries

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-dns</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

Header Type Operations Description
dns.domain String ip The domain name. Mandatory.
dns.name String lookup The name to lookup. Mandatory.
dns.type - lookup, dig The type of the lookup. Should match the values of org.xbill.dns.Type. Optional.
dns.class - lookup, dig he DNS class of the lookup. Should match the values of org.xbill.dns.DClass. Optional.
dns.query String dig The query itself. Mandatory.
dns.server String dig The server in particular for the query. If none is given, the default one specified by the OS will be used. Optional.

Name Type Default Description
method String null The method name that bean will be invoked. If not provided, Apache Camel will try to pick the method itself. In case of ambiguity an exception is thrown. See Bean Binding for more details.
multiParameterArray boolean false How to treat the parameters which are passed from the message body; if it is true, the In message body should be an array of parameters.

You can append query options to the URI in the following format, ?option=value&option=value&...

The EJB component extends the Bean component in which most of the details from the Bean component applies to this component as well.

In this example we want to invoke the hello method on the EJB. Since this example is based on an unit test using Apache OpenEJB we have to set a JndiContext on the EJB component with the OpenEJB settings.

@Override
protected CamelContext createCamelContext() throws Exception {
    CamelContext answer = new DefaultCamelContext();

    // enlist EJB component using the JndiContext
    EjbComponent ejb = answer.getComponent("ejb", EjbComponent.class);
    ejb.setContext(createEjbContext());

    return answer;
}

private static Context createEjbContext() throws NamingException {
    // here we need to define our context factory to use OpenEJB for our testing
    Properties properties = new Properties();
    properties.setProperty(Context.INITIAL_CONTEXT_FACTORY, "org.apache.openejb.client.LocalInitialContextFactory");

    return new InitialContext(properties);
}

Then we are ready to use the EJB in the Apache Camel route:

from("direct:start")
    // invoke the greeter EJB using the local interface and invoke the hello method
    .to("ejb:GreaterImplLocal?method=hello")
    .to("mock:result");
[Tip]In a real application server

In a real application server you most likely do not have to setup a JndiContext on the EJB component as it will create a default JndiContext on the same JVM as the application server, which usually allows it to access the JNDI registry and lookup the EJBs. However if you need to access a application server on a remote JVM or the likes, you have to prepare the properties beforehand.

And this is the same example using XML instead:

Again since this is based on an unit test we need to setup the EJB component:

<!-- setup Camel EJB component -->
<bean id="ejb" class="org.apache.camel.component.ejb.EjbComponent">
    <property name="properties" ref="jndiProperties"/>
</bean>

<!-- use OpenEJB context factory -->
<p:properties id="jndiProperties">
    <prop key="java.naming.factory.initial">org.apache.openejb.client.LocalInitialContextFactory</prop>
</p:properties>

Before we are ready to use EJB in the Apache Camel routes:

<camelContext xmlns="http://camel.apache.org/schema/spring">
    <route>
        <from uri="direct:start"/>
        <to uri="ejb:GreaterImplLocal?method=hello"/>
        <to uri="mock:result"/>
    </route>
</camelContext>

Name Default value Description
args null

The arguments of the executable. The arguments may be one or many whitespace-separated tokens, that can be quoted with ", e.g. args="arg 1" arg2 will use two arguments arg 1 and arg2. To include the quotes use "", e.g. args=""arg 1"" arg2 will use the arguments "arg 1" and arg2.

workingDir null The directory in which the command should be executed. If null, the working directory of the current process will be used.
timeout Long.MAX_VALUE The timeout, in milliseconds, after which the executable should be terminated. If the executable has has not finished within the timeout, the component will send a termination request.
outFile null The name of a file, created by the executable, that should be considered as output of the executable. If no outFile is set, the standard output (stdout) of the executable will be considered as output.
binding a DefaultExecBinding instance A reference to a org.apache.commons.exec.ExecBinding in the Registry.
commandExecutor a DefaultCommandExecutor instance A reference to a org.apache.commons.exec.ExecCommandExecutor in the Registry, that customizes the command execution. The default command executor utilizes the commons-exec library. It adds a shutdown hook for every executed command.
useStderrOnEmptyStdout false A boolean which dictates when stdin is empty, it should fallback and use stderr in the Message Body. This option is default false.

The supported headers are defined in org.apache.camel.component.exec.ExecBinding.

Name Type Message Description
ExecBinding.EXEC_COMMAND_EXECUTABLE String in The name of the system command that will be executed. Overrides the executable in the URI.
ExecBinding.EXEC_COMMAND_ARGS java.util.List<String> in The arguments of the executable. The arguments are used literally, no quoting is applied. Overrides existing args in the URI.
ExecBinding.EXEC_COMMAND_ARGS String in Camel 2.5: The arguments of the executable as a Single string where each argument is whitespace separated (see args in URI option). The arguments are used literally, no quoting is applied. Overrides existing args in the URI.
ExecBinding.EXEC_COMMAND_OUT_FILE String in The name of a file, created by the executable, that should be considered as output of the executable. Overrides existing outFile in the URI.
ExecBinding.EXEC_COMMAND_TIMEOUT long in The timeout, in milliseconds, after which the executable should be terminated. Overrides existing timeout in the URI.
ExecBinding.EXEC_COMMAND_WORKING_DIR String in The directory in which the command should be executed. Overrides existing workingDir in the URI.
ExecBinding.EXEC_EXIT_VALUE int out The value of this header is the exit value of the executable. Typically not-zero exit values indicates abnormal termination. Note that the exit value is OS-dependent.
ExecBinding.EXEC_STDERR java.io.InputStream out The value of this header points to the standard error stream (stderr) of the executable. If no stderr is written, the value is null.
ExecBinding.EXEC_USE_STDERR_ON_EMPTY_STDOUT boolean in Indicates when the stdin is empty, should we fallback and use stderr as the body of the Message. By default this option is false.

If the in message body, that that the Exec component receives, is convertible to java.io.InputStream, it is used to feed input of the executable via its stdin. After the execution, the message body is the result of the execution, that is org.apache.camel.components.exec.ExecResult instance containing the stdout, stderr, exit value and out file. The component supports the following ExecResult type converters for convenience:

From To
ExecResult java.io.InputStream
ExecResult String
ExecResult byte []
ExecResult org.w3c.dom.Document

If out file is used (the endpoint is configured with outFile, or there is ExecBinding.EXEC_COMMAND_OUT_FILE header) the converters return the content of the out file. If no out file is used, then the converters will use the stdout of the process for conversion to the target type. For example refer to Usage Examples.

Executing word count (Linux)

The example below executes wc (word count, Linux) to count the words in file /usr/share/dict/words. The word count (output) is written in the standart output stream of wc.

from("direct:exec")
.to("exec:wc?args=--words /usr/share/dict/words")
.process(new Processor() {
     public void process(Exchange exchange) throws Exception {
       // By default, the body is ExecResult instance
       assertIsInstanceOf(ExecResult.class, exchange.getIn().getBody());
       // Use the Camel Exec String type converter to convert the ExecResult to String
       // In this case, the stdout is considered as output
       String wordCountOutput = exchange.getIn().getBody(String.class);
       // do something with the word count
     }
});

Executing java

The example below executes java with 2 arguments: -server and -version, provided that java is in the system path.

from("direct:exec")
.to("exec:java?args=-server -version")

The example below executes java in c:/temp with 3 arguments: -server, -version and the sytem property user.name.

from("direct:exec")
.to("exec:c:/program files/jdk/bin/java?args=-server -version -Duser.name=Camel&workingDir=c:/temp")

Executing Ant scripts

The following example executes Apache Ant (Windows only) with the build file CamelExecBuildFile.xml, provided that ant.bat is in the system path, and that CamelExecBuildFile.xml is in the current directory.

from("direct:exec")
.to(exec:ant.bat?args=-f CamelExecBuildFile.xml")

In the next example, the ant.bat command, redirects the ant output to CamelExecOutFile.txt with -l. The file CamelExecOutFile.txt is used as out file with outFile=CamelExecOutFile.txt. The example assumes that ant.bat is in the system path, and that CamelExecBuildFile.xml is in the current directory.

from("direct:exec")
.to("exec:ant.bat?args=-f CamelExecBuildFile.xml -l CamelExecOutFile.txt&outFile=CamelExecOutFile.txt")
.process(new Processor() {
     public void process(Exchange exchange) throws Exception {
        InputStream outFile = exchange.getIn().getBody(InputStream.class);
        assertIsInstanceOf(InputStream.class, outFile);
        // do something with the out file here
     }
  });

The Flatpack component supports fixed width and delimited file parsing using the FlatPack library. Notice: This component only supports consuming from flatpack files to Object model. You can not (yet) write from Object model to flatpack format.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-flatpack</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

Name Default Value Description
delimiter , The default character delimiter for delimited files.
textQualifier " The text qualifier for delimited files.
ignoreFirstRecord true Whether the first line is ignored for delimited files (for the column headers).
splitRows true As of Apache Camel 1.5, the component can either process each row one by one or the entire content at once.

Apache Camel will store the following headers on the IN message:

Header Description
camelFlatpackCounter The current row index. For splitRows=false the counter is the total number of rows.

Available as of Apache Camel 1.6

The freemarker: component allows you to process a message using a Freemarker template. This can be ideal when using Templating to generate responses for requests.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-freemarker</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

Option Default Description
contentCache true Cache for the resource content when its loaded.
encoding null Character encoding of the resource content.

Apache Camel will provide exchange information in the Freemarker context (just a Map). The Exchange is transfered as:

Key Value
exchange The Exchange itself.
headers The headers of the In message.
camelContext The Camel Context.
request The In message.
body The In message body.
response The Out message (only for InOut message exchange pattern).

Available as of Camel 2.1 Camel provides two headers by which you can define a different resource location for a template or the template content itself. If any of these headers is set then Camel uses this over the endpoint configured resource. This allows you to provide a dynamic template at runtime.

Header Type Description
CamelFreemarkerResourceUri String Camel 2.1: A URI for the template resource to use instead of the endpoint configured.
CamelFreemarkerTemplate String Camel 2.1: The template to use instead of the endpoint configured.

Available as of Camel 2.7

The hazelcast: component allows you to work with the Hazelcast distributed data grid / cache. Hazelcast is a in memory data grid, entirely written in Java (single jar). It offers a great palette of different data stores like map, multi map (same key, n values), queue, list and atomic number. The main reason to use Hazelcast is its simple cluster support. If you have enabled multicast on your network you can run a cluster with hundred nodes with no extra configuration. Hazelcast can simply configured to add additional features like n copies between nodes (default is 1), cache persistence, network configuration (if needed), near cache, enviction and so on. For more information consult the Hazelcast documentation on http://www.hazelcast.com/documentation.jsp .

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-hazelcast</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

hazelcast:[ map | multimap | queue | seda | set | atomicvalue | instance]:cachename[?options]

[Warning]Warning

You have to use the second prefix to define which type of data store you want to use.

Hazelcast provides event listeners on their data grid. If you want to be notified if a cache will be manipulated, you can use the map consumer. There're 4 events: put, update, delete and envict. The event type will be stored in the "hazelcast.listener.action" header variable. The map consumer provides some additional information inside these variables:

Header Variables inside the response message:

Name Type Description
hazelcast.listener.time Long time of the event in millis
hazelcast.listener.type String the map consumer sets here "cachelistener"
hazelcast.listener.action String type of event - here added, updated, envicted and removed
hazelcast.objectId String the oid of the object
hazelcast.cache.name String the name of the cache - e.g. "foo"
hazelcast.cache.type String the type of the cache - here map

The object value will be stored within put and update actions inside the message body.

Here's a sample:

fromF("hazelcast:%sfoo", HazelcastConstants.MAP_PREFIX)
.log("object...")
.choice()
    .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ADDED))
         .log("...added")
         .to("mock:added")
    .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.ENVICTED))
         .log("...envicted")
         .to("mock:envicted")
    .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.UPDATED))
         .log("...updated")
         .to("mock:updated")
    .when(header(HazelcastConstants.LISTENER_ACTION).isEqualTo(HazelcastConstants.REMOVED))
         .log("...removed")
         .to("mock:removed")
    .otherwise()
         .log("fail!");

A multimap is a cache where you can store n values to one key. The multimap producer provides 4 operations (put, get, removevalue, delete).

Header Variables for the request message:

Name Type Description
hazelcast.operation.type String valid values are: put, get, removevalue, delete
hazelcast.objectId String the object id to store / find your object inside the cache
hibernate:[entityClassName][?options]

For sending to the endpoint, the entityClassName is optional. If specified it is used to help use the Type Conversion to ensure the body is of the correct type.

For consuming, the entityClassName is mandatory.

You can append query options to the URI in the following format, ?option=value&option=value&...

Name Default Value Description
entityType entityClassName Is the provided entityClassName from the URI.
consumeDelete true Option for HibernateConsumer only. Specifies whether or not the entity is deleted after it is consumed.
consumeLockEntity true Option for HibernateConsumer only. Specifies whether or not to use exclusive locking of each entity while processing the results from the pooling.
flushOnSend true Option for HibernateProducer only. Flushes the EntityManager after the entity bean has been persisted.
maximumResults -1 Option for HibernateConsumer only. Set the maximum number of results to retrieve on the Query.
consumer.delay 500 Option for HibernateConsumer only. Delay in millis between each poll.
consumer.initialDelay 1000 Option for HibernateConsumer only. Millis before polling starts.
consumer.userFixedDelay false Option for HibernateConsumer only. Set to true to use fixed delay between polls, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.

The ibatis: component allows you to query, poll, insert, update and delete data in a relational database using Apache iBATIS.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-ibatis</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

Option Type Default Description
consumer.onConsume String null Statements to run after consuming. Can be used, for example, to update rows after they have been consumed and processed in Apache Camel. See sample later. Multiple statements can be separated with comma.
consumer.useIterator boolean true If true each row returned when polling will be processed individually. If false the entire List of data is set as the IN body.
consumer.routeEmptyResultSet boolean false Apache Camel 2.0: Sets whether empty result set should be routed or not. By default, empty result sets are not routed.
statementType StatementType null Apache Camel 1.6.1/2.0: Mandatory to specify for IbatisProducer to control which iBatis SqlMapClient method to invoke. The enum values are: QueryForObject, QueryForList, Insert, Update, Delete.
maxMessagesPerPoll int 0 Apache Camel 2.0: An integer to define a maximum messages to gather per poll. By default, no maximum is set. Can be used to set a limit of e.g. 1000 to avoid when starting up the server that there are thousands of files. Set a value of 0 or negative to disabled it.

Apache Camel will populate the result message, either IN or OUT with a header with the operationName used:

Header Type Description
org.apache.camel.ibatis.queryName String Apache Camel 1.x: The statementName used (for example: insertAccount).
CamelIBatisStatementName String Apache Camel 2.0: The statementName used (for example: insertAccount).
CamelIBatisResult Object Apache Camel 1.6.2/2.0: The response returned from iBatis in any of the operations. For instance an INSERT could return the auto-generated key, or number of rows etc.

Since this component does not support scheduled polling, you need to use another mechanism for triggering the scheduled polls, such as the Timer or Quartz components.

In the sample below we poll the database, every 30 seconds using the Timer component and send the data to the JMS queue:

from("timer://pollTheDatabase?delay=30000").to("ibatis:selectAllAccounts?statementType=QueryForList").to("activemq:queue:allAccounts");

And the iBatis SQL map file used:

  <!-- Select with no parameters using the result map for Account class. -->
  <select id="selectAllAccounts" resultMap="AccountResult">
    select * from ACCOUNT
  </select>

The javaspace component is a transport for working with any JavaSpace compliant implementation and this component has been tested with both the Blitz implementation and the GigaSpace implementation. This component can be used for sending and receiving any object inheriting from the Jini net.jini.core.entry.Entry class. It is also possible to pass the bean ID of a template that can be used for reading/taking the entries from the space. This component can be used for sending/receiving any serializable object acting as a sort of generic transport. The JavaSpace component contains a special optimization for dealing with the BeanExchange. It can be used to invoke a POJO remotely, using a JavaSpace as a transport. This latter feature can provide a simple implementation of the master/worker pattern, where a POJO provides the business logic for the worker. Look at the test cases for examples of various use cases for this component.

Name Default Value Description
spaceName null Specifies the JavaSpace name.
verb take Specifies the verb for getting JavaSpace entries. The values can be: take or read.
transactional false If true, sending and receiving entries is performed within a transaction.
transactionalTimeout Long.MAX_VALUE Specifies the transaction timeout.
concurrentConsumers 1 Specifies the number of concurrent consumers getting entries from the JavaSpace.
templateId null If present, this option specifies the Spring bean ID of the template to use for reading/taking entries.

To use this module, you need the FUSE Mediation Router distribution. Or you can just add the following dependency to your pom.xml file, substituting the version number of the latest release:

<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-parent</artifactId>
  <version>1.6.1.2-fuse</version>
</dependency>

Make sure that you are pointing at the right Maven repository:

   <repository>
     <id>fuse</id>
     <name>Progress Open Source Community Release Repository</name>
     <url>http://repo.fusesource.com/maven2</url>
     <snapshots>
       <enabled>false</enabled>
     </snapshots>
     <releases>
       <enabled>true</enabled>
     </releases>
   </repository>

The jbi component is implemented by the ServiceMix Camel module and provides integration with a JBI Normalized Message Router, such as the one provided by Apache ServiceMix.

[Important]Important

See below for information about how to use StreamSource types from ServiceMix in Apache Camel.

The following code:

from("jbi:endpoint:http://foo.bar.org/MyService/MyEndpoint")

Automatically exposes a new endpoint to the bus, where the service QName is {http://foo.bar.org}MyService and the endpoint name is MyEndpoint (see URI format).

When a JBI endpoint appears at the end of a route, for example:

to("jbi:endpoint:http://foo.bar.org/MyService/MyEndpoint")

The messages sent by this producer endpoint are sent to the already deployed JBI endpoint.

jbi:service:serviceNamespace[sep]serviceName[?options]
jbi:endpoint:serviceNamespace[sep]serviceName[sep]endpointName[?options]
jbi:name:endpointName[?options]

The separator that should be used in the endpoint URL is:

For more details of valid JBI URIs see the ServiceMix URI Guide.

Using the jbi:service: or jbi:endpoint: URI formats sets the service QName on the JBI endpoint to the one specified. Otherwise, the default Apache Camel JBI Service QName is used, which is:

{http://activemq.apache.org/camel/schema/jbi}endpoint

You can append query options to the URI in the following format, ?option=value&option=value&...

Name Default value Description
mep MEP of the Camel Exchange Allows users to override the MEP set on the Exchange object. Valid values for this option are in-only, in-out, robust-in-out and in-optional-out.
operation Value of the jbi.operation header property Specifies the JBI operation for the MessageExchange. If no value is supplied, the JBI binding will use the value of the jbi.operation header property.
serialization basic Default value (basic) will check if headers are serializable by looking at the type, setting this option to strict will detect objects that can not be serialized although they implement the Serializable interface. Set to nocheck to disable this check altogether, note that this should only be used for in-memory transports like SEDAFlow, otherwise you can expect to get NotSerializableException thrown at runtime.
convertException false false: send any exceptions thrown from the Camel route back unmodified true: convert all exceptions to a JBI FaultException (can be used to avoid non-serializable exceptions or to implement generic error handling

If you have some Apache Camel routes that you want to deploy inside JBI as a Service Unit, you can use the JBI Service Unit Archetype to create a new Maven project for the Service Unit.

If you have an existing Maven project that you need to convert into a JBI Service Unit, you may want to consult ServiceMix Maven JBI Plugins for further help. The key steps are as follows:

  • Create a Spring XML file at src/main/resources/camel-context.xml to bootstrap your routes inside the JBI Service Unit.

  • Change the POM file's packaging to jbi-service-unit.

Your pom.xml should look something like this to enable the jbi-service-unit packaging:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>myGroupId</groupId>
  <artifactId>myArtifactId</artifactId>
  <packaging>jbi-service-unit</packaging>
  <version>1.0-SNAPSHOT</version>

  <name>A Apache Camel based JBI Service Unit</name>

  <url>http://www.myorganization.org</url>

  <properties>
    <camel-version>1.0.0</camel-version>
    <servicemix-version>3.3</servicemix-version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.apache.servicemix</groupId>
      <artifactId>servicemix-camel</artifactId>
      <version>${servicemix-version}</version>
    </dependency>

    <dependency>
      <groupId>org.apache.servicemix</groupId>
      <artifactId>servicemix-core</artifactId>
      <version>${servicemix-version}</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <defaultGoal>install</defaultGoal>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.5</source>
          <target>1.5</target>
        </configuration>
      </plugin>

      <!-- creates the JBI deployment unit -->
      <plugin>
        <groupId>org.apache.servicemix.tooling</groupId>
        <artifactId>jbi-maven-plugin</artifactId>
        <version>${servicemix-version}</version>
        <extensions>true</extensions>
      </plugin>
    </plugins>
  </build>
</project>

For more information, see the following references:

The jdbc component enables you to access databases through JDBC, where SQL queries and operations are sent in the message body. This component uses the standard JDBC API, unlike the SQL Component component, which uses spring-jdbc.

[Warning]Warning

This component can only be used to define producer endpoints, which means that you cannot use the JDBC component in a from() statement.

Name Default Value Description
readSize 0 / 2000 The default maximum number of rows that can be read by a polling query. The default value is 2000 for Apache Camel 1.5.0 or older. In newer releases the default value is 0.
statement.<xxx> null Apache Camel 2.1: Sets additional options on the java.sql.Statement that is used behind the scenes to execute the queries. For instance, statement.maxRows=10. For detailed documentation, see the java.sql.Statement javadoc documentation.
useJDBC4ColumnNameAndLabelSemantics true Apache Camel 1.6.3/2.2: Sets whether to use JDBC 4/3 column label/name semantics. You can use this option to turn it false in case you have issues with your JDBC driver to select data. This only applies when using SQL SELECT using aliases (e.g. SQL SELECT id as identifier, name as given_name from persons).
Header Description
CamelJdbcRowCount If the query is a SELECT, the row count is returned in this OUT header.
CamelJdbcUpdateCount If the query is an UPDATE, the update count is returned in this OUT header.

In the following example, we fetch the rows from the customer table.

First we register our datasource in the Apache Camel registry as testdb:

JndiRegistry reg = super.createRegistry();
reg.bind("testdb", ds);
return reg;

Then we configure a route that routes to the JDBC component, so the SQL will be executed. Note how we refer to the testdb datasource that was bound in the previous step:

// lets add simple route
public void configure() throws Exception {
    from("direct:hello").to("jdbc:testdb?readSize=100");
}

Or you can create a DataSource in Spring like this:

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
  <route>
     <from uri="timer://kickoff?period=10000"/>
     <setBody>
       <constant>select * from customer</constant>
     </setBody>
     <to uri="jdbc:testdb"/>
     <to uri="mock:result"/>
  </route>
</camelContext>
<!-- Just add a demo to show how to bind a date source for camel in Spring-->
<bean id="testdb" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	<property name="driverClassName" value="org.hsqldb.jdbcDriver"/>
	<property name="url" value="jdbc:hsqldb:mem:camel_jdbc" />
	<property name="username" value="sa" />
  <property name="password" value="" />
</bean>	

We create an endpoint, add the SQL query to the body of the IN message, and then send the exchange. The result of the query is returned in the OUT body:

// first we create our exchange using the endpoint
Endpoint endpoint = context.getEndpoint("direct:hello");
Exchange exchange = endpoint.createExchange();
// then we set the SQL on the in body
exchange.getIn().setBody("select * from customer order by ID");

// now we send the exchange to the endpoint, and receives the response from Camel
Exchange out = template.send(endpoint, exchange);

// assertions of the response
assertNotNull(out);
assertNotNull(out.getOut());
ArrayList<HashMap<String, Object>> data = out.getOut().getBody(ArrayList.class);
assertNotNull("out body could not be converted to an ArrayList - was: "
    + out.getOut().getBody(), data);
assertEquals(2, data.size());
HashMap<String, Object> row = data.get(0);
assertEquals("cust1", row.get("ID"));
assertEquals("jstrachan", row.get("NAME"));
row = data.get(1);
assertEquals("cust2", row.get("ID"));
assertEquals("nsandhu", row.get("NAME"));

If you want to work on the rows one by one instead of the entire ResultSet at once you need to use the Splitter EIP such as:

from("direct:hello")
        // here we split the data from the testdb into new messages one by one
        // so the mock endpoint will receive a message per row in the table
    .to("jdbc:testdb").split(body()).to("mock:result");

If we want to poll a database using the JDBC component, we need to combine it with a polling scheduler such as the Timer or Quartz etc. In the following example, we retrieve data from the database every 60 seconds:

from("timer://foo?period=60000").setBody(constant("select * from customer")).to("jdbc:testdb").to("activemq:queue:customers");

See also:

The Jing component uses the Jing Library to perform XML validation of the message body using either:

Note that the MSV component can also support RelaxNG XML syntax.

rng:someLocalOrRemoteResource
rnc:someLocalOrRemoteResource

Where rng means use the RelaxNG XML Syntax whereas rnc means use RelaxNG Compact Syntax. The following examples show possible URI values

Example Description
rng:foo/bar.rng References the XML file foo/bar.rng on the classpath
rnc:http://foo.com/bar.rnc References the RelaxNG Compact Syntax file from the URL, http://foo.com/bar.rnc.

You can append query options to the URI in the following format, ?option=value&option=value&...

Option Default Description
useDom false Apache Camel 2.0: Specifies whether DOMSource/DOMResult or SaxSource/SaxResult should be used by the validator.

The following example shows how to configure a route from the endpoint direct:start which then goes to one of two endpoints, either mock:valid or mock:invalid based on whether or not the XML matches the given RelaxNG Compact Syntax schema (which is supplied on the classpath).

<camelContext xmlns="http://camel.apache.org/schema/spring">
    <route>
        <from uri="direct:start"/>
        <doTry>
            <to uri="rnc:org/apache/camel/component/validator/jing/schema.rnc"/>
            <to uri="mock:valid"/>

            <doCatch>
                <exception>org.apache.camel.ValidationException</exception>
                <to uri="mock:invalid"/>
            </doCatch>
            <doFinally>
                <to uri="mock:finally"/>
            </doFinally>
        </doTry>
    </route>
</camelContext>

Property Required Default Description
format xml Format for the message body. Either "xml" or "raw". If xml, the notification is serialized to xml. If raw, then the raw java object is set as the body.
password Credentials for making a remote connection.
objectDomain yes The domain for the mbean you're connecting to.
objectName The name key for the mbean you're connecting to. This value is mutually exclusive with the object properties that get passed. (see below)
notificationFilter Reference to a bean that implements the NotificationFilter. The #ref syntax should be used to reference the bean via the Registry.
handback Value to handback to the listener when a notification is received. This value will be put in the message header with the key "jmx.handback"

You can store a Java entity bean in a database by sending it to a JPA producer endpoint. The body of the In message is assumed to be an entity bean (that is, a POJO with an @Entity annotation on it) or a collection or an array of entity beans.

If the body does not contain one of the preceding types, put a Message TranslatorMessage Translator in front of the endpoint to perform the necessary conversion first.

jpa:[entityClassName][?options]

For sending to the endpoint, the entityClassName is optional. If specified, it helps the Type Converter to ensure the body is of the correct type.

For consuming, the entityClassName is mandatory.

You can append query options to the URI in the following format, ?option=value&option=value&...

Name Default Value Description
entityType entityClassName Overrides the entityClassName from the URI.
persistenceUnit camel The JPA persistence unit used by default.
consumeDelete true JPA consumer only: If true, the entity is deleted after it is consumed; if false, the entity is not deleted.
consumeLockEntity true JPA consumer only: Specifies whether or not to set an exclusive lock on each entity bean while processing the results from polling.
flushOnSend true JPA producer only: Flushes the EntityManager after the entity bean has been persisted.
maximumResults -1 JPA consumer only: Set the maximum number of results to retrieve on the Query.
transactionManager null Apache Camel 1.6.1/2.0: Specifies the transaction manager to use. If none provided, Apache Camel will use a JpaTransactionManager by default. Can be used to set a JTA transaction manager (for integration with an EJB container).
consumer.delay 500 JPA consumer only: Delay in milliseconds between each poll.
consumer.initialDelay 1000 JPA consumer only: Milliseconds before polling starts.
consumer.useFixedDelay false JPA consumer only: Set to true to use fixed delay between polls, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.
maxMessagesPerPoll 0 Apache Camel 2.0:JPA consumer only: An integer value to define the maximum number of messages to gather per poll. By default, no maximum is set. Can be used to avoid polling many thousands of messages when starting up the server. Set a value of 0 or negative to disable.
consumer.query JPA consumer only: To use a custom query when consuming data.
consumer.resultClass Camel 2.7: JPA consumer only: Defines the type of the returned payload (we will call entityManager.createNativeQuery(nativeQuery, resultClass) instead of entityManager.createNativeQuery(nativeQuery)). Without this option, we will return an object array. Only has an affect when using in conjunction with native query when consuming data.
consumer.namedQuery JPA consumer only: To use a named query when consuming data.
consumer.nativeQuery JPA consumer only: To use a custom native query when consuming data.
usePersist false Camel 2.5: JPA producer only: Indicates to use entityManager.persist(entity) instead of entityManager.merge(entity). Note: entityManager.persist(entity) doesn't work for detached entities (where the EntityManager has to execute an UPDATE instead of an INSERT query)!

Apache Camel adds the following message headers to the exchange:

Header Type Description
CamelJpaTemplate JpaTemplate Apache Camel 2.0: The JpaTemplate object that is used to access the entity bean. You need this object in some situations, for instance in a type converter or when you are doing some custom processing.

For the data queue message exchange:

Name Default value Description
ccsid default system CCSID Specifies the CCSID to use for the connection with the AS/400 system.
format text Specifies the data format for sending messages valid options are: text (represented by String) and binary (represented by byte[])
consumer.delay 500 Delay in milliseconds between each poll.
consumer.initialDelay 1000 Milliseconds before polling starts.
consumer.userFixedDelay false true to use fixed delay between polls, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.

For the remote program call (Camel 2.7):

Name Default value Description
outputFieldsIdx Specifies which fields (program parameters) are output parameters.
fieldsLength Specifies the fields (program parameters) length as in the AS/400 program definition.

The language component allows you to send Exchange to an endpoint which executes a script by any of the supported Languages in Camel. By having a component to execute language scripts, it allows more dynamic routing capabilities. For example by using the Routing SlipRouting Slip or Dynamic RouterDynamic Router EIPs you can send messages to language endpoints where the script is dynamic defined as well.

This component is provided out of the box in camel-core and hence no additional JARs is needed. You only have to include additional Camel components if the language of choice mandates it, such as using Groovy or JavaScript languages.

The component supports the following options.

Name Default Value Type Description
languageName null String The name of the Language to use, such as simple, groovy, javascript etc. This option is mandatory.
script null String The script to execute.
transform true boolean Whether or not the result of the script should be used as the new message body. By setting to false the script is executed but the result of the script is discarded.

The following message headers can be used to affect the behavior of the component

Header Description
CamelLanguageScript The script to execute provided in the header. Takes precedence over script configured on the endpoint.

For example you can use the Simple language to Message TranslatorMessage Translator a message:

from("direct:start").to("language:simple:Hello ${body}").to("mock:result");

In case you want to convert the message body type you can do this as well:

from("direct:start").to("language:simple:${mandatoryBodyAs(String)}").to("mock:result");

You can also use the Groovy language, such as this example where the input message will by multiplied with 2:

from("direct:start").to("language:groovy:request.body * 2").to("mock:result");

You can also provide the script as a header as shown below. Here we use XPath language to extract the text from the <foo> tag.

Object out = producer.requestBodyAndHeader("language:xpath", "<foo>Hello World</foo>", Exchange.LANGUAGE_SCRIPT, "/foo/text()");
assertEquals("Hello World", out);

  • Languages

  • Routing SlipRouting Slip

  • Dynamic RouterDynamic Router

ldap:ldapServerBean[?options]

The ldapServerBean portion of the URI refers to a DirContext bean in the registry. The LDAP component only supports producer endpoints, which means that an ldap URI cannot appear in the from at the start of a route.

You can append query options to the URI in the following format, ?option=value&option=value&...

Name Default Value Description
base ou=system The base DN for searches.
scope subtree Specifies how deeply to search the tree of entries, starting at the base DN. Value can be object, onelevel, or subtree.
pageSize No paging used. When specified the LDAP module uses paging to retrieve all results (most LDAP Servers throw an exception when trying to retrieve more than 1000 entries in one query). To be able to use this, an LdapContext (subclass of DirContext) has to be passed in as ldapServerBean (otherwise an exception is thrown)
returnedAttributes Depends on LDAP Server (could be all or none) . Comma-separated list of attributes that should be set in each entry of the result

The URI, ldap:ldapserver, references a Spring bean with the ID, ldapserver. The ldapserver bean may be defined as follows:

<bean id="ldapserver" class="javax.naming.directory.InitialDirContext" scope="prototype">
  <constructor-arg>
    <props>
      <prop key="java.naming.factory.initial">com.sun.jndi.ldap.LdapCtxFactory</prop>
      <prop key="java.naming.provider.url">ldap://localhost:10389</prop>
      <prop key="java.naming.security.authentication">none</prop>
    </props>
  </constructor-arg>
</bean>

The preceding example declares a regular Sun based LDAP DirContext that connects anonymously to a locally hosted LDAP server.

[Note]Note

DirContext objects are not required to support concurrency by contract. It is therefore important that the directory context is declared with the setting, scope="prototype", in the bean definition or that the context supports concurrency. In the Spring framework, prototype scoped objects are instantiated each time they are looked up.

[Note]Note

Apache Camel 1.6.1 and Apache Camel 2.0 include a fix to support concurrency for LDAP producers. ldapServerBean contexts are now looked up each time a request is sent to the LDAP server. In addition, the contexts are released as soon as the producer completes.

Option Default Type Description
level INFO String Logging level to use. Possible values: FATAL, ERROR, WARN, INFO, DEBUG, TRACE, OFF
groupSize null Integer An integer that specifies a group size for throughput logging. By default, regular logging is used.

The log formats the execution of exchanges to log lines. By default, the log uses LogFormatter to format the log output, where LogFormatter has the following options:

Option Default Description
showAll false Quick option for turning all options on (multiline, maxChars has to be manually set if to be used).
showExchangeId false Show the unique exchange ID.
showExchangePattern true Camel 2.3: Shows the Message Exchange Pattern (or MEP for short).
showProperties false Show the exchange properties.
showHeaders false Show the In message headers.
showBodyType true Show the In body Java type.
showBody true Show the In body.
showOut false If the exchange has an Out message, show the Out message.
showException false Apache Camel 2.0: If the exchange has an exception, show the exception message (no stack trace).
showCaughtException false Apache Camel 2.0: If the exchange has a caught exception, show the exception message (no stack trace). A caught exception is stored as a property on the exchange and for instance a doCatch can catch exceptions. See Try Catch Finally.
showStackTrace false Apache Camel 2.0: Show the stack trace, if an exchange has an exception.
showFuture false Camel 2.1: Whether Camel should show java.util.concurrent.Future bodies or not. If enabled Camel could potentially wait until the Future task is done. Will by default not wait.
multiline false If true, each piece of information is logged on a new line.
maxChars Apache Camel 2.0: Limits the number of characters logged per line.

Available as of Apache Camel 2.2

The lucene component is based on the Apache Lucene project. Apache Lucene is a powerful high-performance, full-featured text search engine library written entirely in Java. For more details about Lucene, please see the following links * http://lucene.apache.org/java/docs/ * http://lucene.apache.org/java/docs/features.html

The lucene component in camel facilitates integration and utilization of Lucene endpoints in enterprise integration patterns and scenarios. The lucene component does the following

  • builds a searchable index of documents when payloads are sent to the Lucene Endpoint

  • facilitates performing of indexed searches in Apache Camel

This component only supports producer endpoints.

Name Default Value Description
analyzer StandardAnalyzer An Analyzer builds TokenStreams, which analyze text. It thus represents a policy for extracting index terms from text. The value for analyzer can be any class that extends the abstract class org.apache.lucene.analysis.Analyzer. Lucene also offers a rich set of analyzers out of the box
indexDir ./indexDirectory A file system directory in which index files are created upon analysis of the document by the specified analyzer
srcDir null An optional directory containing files to be used to be analyzed and added to the index at producer startup.
Name Default Value Description
analyzer StandardAnalyzer An Analyzer builds TokenStreams, which analyze text. It thus represents a policy for extracting index terms from text. The value for analyzer can be any class that extends the abstract class org.apache.lucene.analysis.Analyzer. Lucene also offers a rich set of analyzers out of the box
indexDir ./indexDirectory A file system directory in which index files are created upon analysis of the document by the specified analyzer
maxHits 10 An integer value that limits the result set of the search operation
Header Description
QUERY The Lucene Query to performed on the index. The query may include wildcards and phrases
mina:tcp://hostname[:port][?options]
mina:udp://hostname[:port][?options]
mina:vm://hostname[:port][?options]

From Apache Camel 1.3 onwards you can specify a codec in the Registry using the codec option. If you are using TCP and no codec is specified then the textline flag is used to determine if text line based codec or object serialization should be used instead. By default the object serialization is used.

For UDP, if no codec is specified the default uses a basic ByteBuffer based codec.

The VM protocol is used as a direct forwarding mechanism in the same JVM. See the MINA VM-Pipe API documentation for details.

A Mina producer has a default timeout value of 30 seconds, while it waits for a response from the remote server.

In normal use, camel-mina only supports marshalling the body content—essage headers and exchange properties are not sent. However, the option, transferExchange, does allow you to transfer the exchange itself over the wire. See options below.

You can append query options to the URI in the following format, ?option=value&option=value&...

Option Default Value Description
codec null As of 1.3, you can refer to a named ProtocolCodecFactory instance in your Registry such as your Spring ApplicationContext, which is then used for the marshalling.
codec null Apache Camel 2.0: You must use the # notation to look up your codec in the Registry. For example, use #myCodec to look up a bean with the id value, myCodec.
disconnect false Camel 2.3: Whether or not to disconnect(close) from Mina session right after use. Can be used for both consumer and producer.
textline false Only used for TCP. If no codec is specified, you can use this flag in 1.3 or later to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP.
textlineDelimiter DEFAULT Apache Camel 1.6.0/2.0 Only used for TCP and if textline=true. Sets the text line delimiter to use. Possible values are: DEFAULT, AUTO, WINDOWS, UNIX or MAC. If none provided, Apache Camel will use DEFAULT. This delimiter is used to mark the end of text.
sync true As of 1.3, you can configure the exchange pattern to be either InOnly (default) or InOut. Setting sync=true means a synchronous exchange (InOut), where the client can read the response from MINA (the exchange Out message). The default value has changed in Apache Camel 1.5 to true. In older releases, the default value is false.
lazySessionCreation See description As of 1.3, sessions can be lazily created to avoid exceptions, if the remote server is not up and running when the Apache Camel producer is started. From Apache Camel 2.0 onwards, the default is true. In Apache Camel 1.x, the default is false.
timeout 30000 As of 1.3, you can configure the timeout that specifies how long to wait for a response from a remote server. The timeout unit is in milliseconds, so 60000 is 60 seconds. The timeout is only used for Mina producer.
encoding JVM Default As of 1.3, you can configure the encoding (a charset name) to use for the TCP textline codec and the UDP protocol. If not provided, Apache Camel will use the JVM default Charset.
transferExchange false Only used for TCP. As of 1.3, you can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Apache Camel will exclude any non-serializable objects and log it at WARN level.
minaLogger false As of 1.3, you can enable the Apache MINA logging filter. Apache MINA uses slf4j logging at INFO level to log all input and output.
filters null

As of 2.0, you can set a list of Mina IoFilters to register. The filters value must be one of the following:

  • Camel 2.2: comma-separated list of bean references (e.g. #filterBean1,#filterBean2) where each bean must be of type org.apache.mina.common.IoFilter.

  • Camel 2.0: a reference to a bean of type List<org.apache.mina.common.IoFilter>.

encoderMaxLineLength -1 As of 2.1, you can set the textline protocol encoder max line length. By default the default value of Mina itself is used which are Integer.MAX_VALUE.
decoderMaxLineLength -1 As of 2.1, you can set the textline protocol decoder max line length. By default the default value of Mina itself is used which are 1024.
allowDefaultCodec true The mina component installs a default codec if both, codec is null and textline is false. Setting allowDefaultCodec to false prevents the mina component from installing a default codec as the first element in the filter chain. This is useful in scenarios where another filter must be the first in the filter chain, like the SSL filter.
disconnectOnNoReply true Camel 2.3: If sync is enabled then this option dictates MinaConsumer if it should disconnect where there is no reply to send back.
noReplyLogLevel WARN Camel 2.3: If sync is enabled this option dictates MinaConsumer which logging level to use when logging a there is no reply to send back. Values are: FATAL, ERROR, INFO, DEBUG, OFF.

In Apache Camel 2.0 the codec option must use # notation for lookup of the codec bean in the Registry. In Apache Camel 2.0 the lazySessionCreation option now defaults to true.

In Apache Camel 1.5 the sync option has changed its default value from false to true, as we felt it was confusing for end-users when they used Mina to call remote servers and Apache Camel wouldn't wait for the response.

In Apache Camel 1.4 or later codec=textline is no longer supported. Use the textline=true option instead.

See the Mina documentation how to write your own codec. To use your custom codec with camel-mina, you should register your codec in the Registry; for example, by creating a bean in the Spring XML file. Then use the codec option to specify the bean ID of your codec.

Available as of Apache Camel 2.0

Configuration of Mina endpoints is now possible using regular Spring bean style configuration in the Spring DSL.

However, in the underlying Apache Mina toolkit, it is relatively difficult to set up the acceptor and the connector, because you can not use simple setters. To resolve this difficulty, we leverage the MinaComponent as a Spring factory bean to configure this for us. If you really need to configure this yourself, there are setters on the MinaEndpoint to set these when needed.

The sample below shows the factory approach:

<!-- Creating mina endpoints is a bit complex so we reuse MinaComponnet
     as a factory bean to create our endpoint, this is the easiest to do -->
<bean id="myMinaFactory" class="org.apache.camel.component.mina.MinaComponent">
    <!-- we must provide a camel context so we refer to it by its id -->
    <constructor-arg index="0" ref="myCamel"/>
</bean>

<!-- This is our mina endpoint configured with Spring, we will use the factory above
     to create it for us. The goal is to invoke the createEndpoint method with the
     mina configuration parameter we defined using the constructor-arg option -->
<bean id="myMinaEndpoint"
      factory-bean="myMinaFactory"
      factory-method="createEndpoint">
    <!-- and here we can pass it our configuration -->
    <constructor-arg index="0" ref="myMinaConfig"/>
</bean>

<!-- this is our mina configuration with plain properties -->
<bean id="myMinaConfig" class="org.apache.camel.component.mina.MinaConfiguration">
    <property name="protocol" value="tcp"/>
    <property name="host" value="localhost"/>
    <property name="port" value="1234"/>
    <property name="sync" value="false"/>
</bean>

And then we can refer to our endpoint directly in the route, as follows:

<route>
    <!-- here we route from or mina endpoint we have defined above -->
    <from ref="myMinaEndpoint"/>
    <to uri="mock:result"/>
</route>

Available since Apache Camel 2.0

Filters permit you to use some Mina Filters, such as SslFilter. You can also implement some customized filters. Please note that codec and logger are also implemented as Mina filters of type, IoFilter. Any filters you may define are appended to the end of the filter chain; that is, after codec and logger.

For instance, the example below will send a keep-alive message after 10 seconds of inactivity:

public class KeepAliveFilter extends IoFilterAdapter {
    @Override
    public void sessionCreated(NextFilter nextFilter, IoSession session)
            throws Exception {
        session.setIdleTime(IdleStatus.BOTH_IDLE, 10);

        nextFilter.sessionCreated(session);
    }

    @Override
    public void sessionIdle(NextFilter nextFilter, IoSession session,
            IdleStatus status) throws Exception {
        session.write("NOOP"); // NOOP is a FTP command for keep alive
        nextFilter.sessionIdle(session, status);
    }
}

As Apache Camel Mina may use a request-reply scheme, the endpoint as a client would like to drop some message, such as greeting when the connection is established. For example, when you connect to an FTP server, you will get a 220 message with a greeting (220 Welcome to Pure-FTPd). If you don't drop the message, your request-reply scheme will be broken.

public class DropGreetingFilter extends IoFilterAdapter {
 
    @Override
    public void messageReceived(NextFilter nextFilter, IoSession session,
            Object message) throws Exception {
        if (message instanceof String) {
            String ftpMessage = (String) message;
            // "220" is given as greeting. "200 Zzz" is given as a response to "NOOP" (keep alive)
            if (ftpMessage.startsWith("220") || or ftpMessage.startsWith("200 Zzz")) {
                // Dropping greeting
                return;
            }
        }
        nextFilter.messageReceived(session, message);
    }
}

Then, you can configure your endpoint using XML DSL:

<bean id="myMinaFactory" class="org.apache.camel.component.mina.MinaComponent">
    <constructor-arg index="0" ref="camelContext" />
</bean>
    
<bean id="myMinaEndpoint"
      factory-bean="myMinaFactory"
      factory-method="createEndpoint">
    <constructor-arg index="0" ref="myMinaConfig"/>
</bean>

<bean id="myMinaConfig" class="org.apache.camel.component.mina.MinaConfiguration">
    <property name="protocol" value="tcp" />
    <property name="host" value="localhost" />
    <property name="port" value="2121" />
    <property name="sync" value="true" />
    <property name="minaLogger" value="true" />
    <property name="filters" ref="listFilters"/>
</bean>

<bean id="listFilters" class="java.util.ArrayList" >
    <constructor-arg>
        <list value-type="org.apache.mina.common.IoFilter">
            <bean class="com.example.KeepAliveFilter"/>
            <bean class="com.example.DropGreetingFilter"/>
        </list>
    </constructor-arg>
</bean>

The MSV component performs XML validation of the message body using the MSV Library and any of the supported XML schema languages, such as XML Schema or RelaxNG XML Syntax.

Note that the Jing component also supports RelaxNG Compact Syntax

Option Default Description
useDom true Apache Camel 2.0: Whether DOMSource/DOMResult or SaxSource/SaxResult should be used by the validator. Note: DOM must be used by the MSV component.

The following example shows how to configure a route from endpoint direct:start which then goes to one of two endpoints, either mock:valid or mock:invalid based on whether or not the XML matches the given RelaxNG XML Schema (which is supplied on the classpath).

<camelContext xmlns="http://camel.apache.org/schema/spring">
    <route>
        <from uri="direct:start"/>
        <doTry>
            <to uri="msv:org/apache/camel/component/validator/msv/schema.rng"/>
            <to uri="mock:valid"/>

            <doCatch>
                <exception>org.apache.camel.ValidationException</exception>
                <to uri="mock:invalid"/>
            </doCatch>
            <doFinally>
                <to uri="mock:finally"/>
            </doFinally>
        </doTry>
    </route>
</camelContext>

Available as of Camel 2.7

The mybatis: component allows you to query, poll, insert, update and delete data in a relational database using MyBatis.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-mybatis</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

Option Type Default Description
consumer.onConsume String null Statements to run after consuming. Can be used, for example, to update rows after they have been consumed and processed in Camel. See sample later. Multiple statements can be separated with comma.
consumer.useIterator boolean true If true each row returned when polling will be processed individually. If false the entire List of data is set as the IN body.
consumer.routeEmptyResultSet boolean false Sets whether empty result set should be routed or not. By default, empty result sets are not routed.
statementType StatementType null Mandatory to specify for producer to control which kind of operation to invoke. The enum values are: SelectOne, SelectList, Insert, Update, Delete.
maxMessagesPerPoll int 0 An integer to define a maximum messages to gather per poll. By default, no maximum is set. Can be used to set a limit of e.g. 1000 to avoid when starting up the server that there are thousands of files. Set a value of 0 or negative to disabled it.

Camel will populate the result message, either IN or OUT with a header with the statement used:

Header Type Description
CamelMyBatisStatementName String The statementName used (for example: insertAccount).
CamelMyBatisResult Object The response returned from MtBatis in any of the operations. For instance an INSERT could return the auto-generated key, or number of rows etc.

Since this component does not support scheduled polling, you need to use another mechanism for triggering the scheduled polls, such as the Timer or Quartz components.

In the sample below we poll the database, every 30 seconds using the Timer component and send the data to the JMS queue:

from("timer://pollTheDatabase?delay=30000").to("mbatis:selectAllAccounts").to("activemq:queue:allAccounts");

And the MyBatis SQL mapping file used:

  <!-- Select with no parameters using the result map for Account class. -->
  <select id="selectAllAccounts" resultMap="AccountResult">
    select * from ACCOUNT
  </select>

Name Default Value Description
host none This is the address of the Nagios host where checks should be send.
port The port number of the host.
password Password to be authenticated when sending checks to Nagios.
connectionTimeout 5000 Connection timeout in millis.
timeout 5000 Sending timeout in millis.
nagiosSettings To use an already configured com.googlecode.jsendnsca.core.NagiosSettings object.
sendSync true Whether or not to use synchronous when sending a passive check. Setting it to false will allow Apache Camel to continue routing the message and the passive check message will be send asynchronously.

Name Description
CamelNagiosHostName This is the address of the Nagios host where checks should be send. This header will override any existing hostname configured on the endpoint.
CamelNagiosLevel This is the severity level. You can use values CRITICAL, WARNING, OK. Apache Camel will by default use OK.
CamelNagiosServiceName The servie name. Will default use the CamelContext name.

The Nagios component also provides an EventNotifer which you can use to send events to Nagios. For example we can enable this from Java as follows:

        NagiosEventNotifier notifier = new NagiosEventNotifier();
        notifier.getConfiguration().setHost("localhost");
        notifier.getConfiguration().setPort(5667);
        notifier.getConfiguration().setPassword("password");

        CamelContext context = ... 
        context.getManagementStrategy().addEventNotifier(notifier);
        return context;

In Spring XML its just a matter of defining a Spring bean with the type EventNotifier and Apache Camel will pick it up as documented here: Advanced configuration of CamelContext using Spring.

Name Default Value Description
keepAlive true Setting to ensure socket is not closed due to inactivity
tcpNoDelay true Setting to improve TCP protocol performance
broadcast false Setting to choose Multicast over UDP
connectTimeout 10000 Time to wait for a socket connection to be available. Value is in millis.
reuseAddress true Setting to facilitate socket multiplexing
sync true Setting to set endpoint as one-way or request-response
ssl false Setting to specify whether SSL encryption is applied to this endpoint
sendBufferSize 65536 bytes The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes.
receiveBufferSize 65536 bytes The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes.
corePoolSize 10 The number of allocated threads at component startup. Defaults to 10
maxPoolSize 100 The maximum number of threads that may be allocated to this endpoint. Defaults to 100
disconnect false Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer.
lazyChannelCreation true Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Apache Camel producer is started.
transferExchange false Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Apache Camel will exclude any non-serializable objects and log it at WARN level.
disconnectOnNoReply true If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back.
noReplyLogLevel WARN If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. Values are: FATAL, ERROR, INFO, DEBUG, OFF.
allowDefaultCodec true Camel 2.4: The netty component installs a default codec if both, encoder/deocder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain.
textline false Camel 2.4: Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP.
delimiter LINE Camel 2.4: The delimiter to use for the textline codec. Possible values are LINE and NULL.
decoderMaxLineLength 1024 Camel 2.4: The max line length to use for the textline codec.
autoAppendDelimiter true Camel 2.4: Whether or not to auto append missing end delimiter when sending using the textline codec.
encoding null Camel 2.4: The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset.

Codec Handlers and SSL Keystores can be enlisted in the Registry, such as in the Spring XML file. The values that could be passed in, are the following:

Name Description
passphrase password setting to use in order to encrypt/decrypt payloads sent using SSH
keyStoreFormat keystore format to be used for payload encryption. Defaults to "JKS" if not set
securityProvider Security provider to be used for payload encryption. Defaults to "SunX509" if not set.
keyStoreFile Client side certificate keystore to be used for encryption
trustStoreFile Server side certificate keystore to be used for encryption
sslHandler Reference to a class that could be used to return an SSL Handler
encoder A custom Handler class that can be used to perform special marshalling of outbound payloads. Must override org.jboss.netty.channel.ChannelDownStreamHandler.
encorders A list of encoder to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Apache Camel knows it should lookup.
decoder A custom Handler class that can be used to perform special marshalling of inbound payloads. Must override org.jboss.netty.channel.ChannelUpStreamHandler.
decoders A list of decorder to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Apache Camel knows it should lookup.

In certain cases it may be necessary to add chains of encoders and decoders to the netty pipeline. To add multpile codecs to a Apache Camel netty endpoint the 'encoders' and 'decoders' uri parameters should be used. Like the 'encoder' and 'decoder' parameters they are used to supply references (to lists of ChannelUpstreamHandlers and ChannelDownstreamHandlers) that should be added to the pipeline. Note that if encoders is specified then the encoder param will be ignored, similarly for decoders and the decoder param.

The lists of codecs need to be added to the Apache Camel's registry so they can be resolved when the endpoint is created.

LengthFieldBasedFrameDecoder lengthDecoder = new LengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4);
StringDecoder stringDecoder = new StringDecoder();
registry.bind("length-decoder", lengthDecoder);
registry.bind("string-decoder", stringDecoder);

LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4);
StringEncoder stringEncoder = new StringEncoder();
registry.bind("length-encoder", lengthEncoder);
registry.bind("string-encoder", stringEncoder);

List<ChannelUpstreamHandler> decoders = new ArrayList<ChannelUpstreamHandler>();
decoders.add(lengthDecoder);
decoders.add(stringDecoder);

List<ChannelDownstreamHandler> encoders = new ArrayList<ChannelDownstreamHandler>();
encoders.add(lengthEncoder);
encoders.add(stringEncoder);

registry.bind("encoders", encoders);
registry.bind("decoders", decoders);

Spring's native collections support can be used to specify the codec lists in an application context

    <util:list id="decoders" list-class="java.util.LinkedList">
        <bean class="org.jboss.netty.handler.codec.frame.LengthFieldBasedFrameDecoder">
            <constructor-arg value="1048576"/>
            <constructor-arg value="0"/>
            <constructor-arg value="4"/>
            <constructor-arg value="0"/>
            <constructor-arg value="4"/>
        </bean>
        <bean class="org.jboss.netty.handler.codec.string.StringDecoder"/>
    </util:list>

    <util:list id="encoders" list-class="java.util.LinkedList">
        <bean class="org.jboss.netty.handler.codec.frame.LengthFieldPrepender">
            <constructor-arg value="4"/>
        </bean>
        <bean class="org.jboss.netty.handler.codec.string.StringEncoder"/>
    </util:list>

    <bean id="length-encoder" class="org.jboss.netty.handler.codec.frame.LengthFieldPrepender">
        <constructor-arg value="4"/>
    </bean>
    <bean id="string-encoder" class="org.jboss.netty.handler.codec.string.StringEncoder"/>

    <bean id="length-decoder" class="org.jboss.netty.handler.codec.frame.LengthFieldBasedFrameDecoder">
        <constructor-arg value="1048576"/>
        <constructor-arg value="0"/>
        <constructor-arg value="4"/>
        <constructor-arg value="0"/>
        <constructor-arg value="4"/>
    </bean>
    <bean id="string-decoder" class="org.jboss.netty.handler.codec.string.StringDecoder"/>

</beans>

The bean names can then be used in netty endpoint definitions either as a comma separated list or contained in a List e.g.

<camelContext id="multiple-netty-codecs-context" xmlns="http://camel.apache.org/schema/spring">
    <route>
        <from uri="direct:multiple-codec"/>
        <to uri="netty:tcp://localhost:5150?encoders=#encoders&ync=false"/>
    </route>
    <route>
        <from uri="netty:tcp://localhost:5150?decoders=#length-decoder,#string-decoder&ync=false"/>
        <to uri="mock:multiple-codec"/>
    </route>
</camelContext>

Available as of Camel 2.5

Custom channel pipelines provide complete control to the user over the handler/interceptor chain by inserting custom handler(s), encoder(s) and decoders without having to specify them in the Netty Endpoint URL in a very simple way.

In order to add a custom pipeline, a custom channel pipeline factory must be created and registered with the context through the context registry (JNDIRegistry,or the Spring ApplicationContextRegistry etc).

A custom pipeline factory must be constructed as follows

The example below shows how ServerChannel Pipeline factory may be created

public class SampleServerChannelPipelineFactory extends ServerPipelineFactory {
    private int maxLineSize = 1024;
    private boolean invoked;

    public ChannelPipeline getPipeline() throws Exception {
        invoked = true;
      
        ChannelPipeline channelPipeline = Channels.pipeline();
      
        channelPipeline.addLast("encoder-SD", new StringEncoder(CharsetUtil.UTF_8));
        channelPipeline.addLast("decoder-DELIM", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter()));
        channelPipeline.addLast("decoder-SD", new StringDecoder(CharsetUtil.UTF_8));
        channelPipeline.addLast("handler", new ServerChannelHandler(consumer));

        return channelPipeline;
    }
      
    public boolean isfactoryInvoked() {
        return invoked;
    }
}

The custom channel pipeline factory can then be added to the registry and instantiated/utilized on a camel route as follows:

Registry registry = camelContext.getRegistry();
serverPipelineFactory = new TestServerChannelPipelineFactory();
registry.bind("spf", serverPipelineFactory);
context.addRoutes(new RouteBuilder() {
    public void configure() {
        String netty_ssl_endpoint =
          "netty:tcp://localhost:5150?serverPipelineFactory=#spf";
        String return_string =
          "When You Go Home, Tell Them Of Us And Say,"
          + "For Your Tomorrow, We Gave Our Today.";
      
        from(netty_ssl_endpoint)
          .process(new Processor() {
            public void process(Exchange exchange) throws Exception {
              exchange.getOut().setBody(return_string);
            }
          }
    }
});

The nmr component is an adapter to the Normalized Message Router (NMR) in ServiceMix, which is intended for use by Apache Camel applications deployed directly into the OSGi container. By contrast, the JBI component is intended for use by Apache Camel applications deployed into the ServiceMix JBI container.

The following code:

from("nmr:MyServiceEndpoint")

Automatically exposes a new endpoint to the bus with endpoint name MyServiceEndpoint (see URI format).

When an NMR endpoint appears at the end of a route, for example:

to("nmr:MyServiceEndpoint")

The messages sent by this producer endpoint are sent to the already deployed JBI endpoint.

Option Default Value Description
synchronous false When this is set to true on a consumer endpoint, an incoming, synchronous NMR Exchange will be handled on the sender's thread instead of being handled on a new thread of the NMR endpoint's thread pool
Name Default Value Description
mediaSize MediaSizeName.NA_LETTER Sets the stationary as defined by enumeration settings in the javax.print.attribute.standard.MediaSizeName API. The default setting is to use North American Letter sized stationary
copies 1 Sets number of copies based on the javax.print.attribute.standard.Copies API
sides Sides.ONE_SIDED Sets one sided or two sided printing based on the javax.print.attribute.standard.Sides API
flavor DocFlavor.BYTE_ARRAY Sets DocFlavor based on the javax.print.DocFlavor API
mimeType AUTOSENSE Sets mimeTypes supported by the javax.print.DocFlavor API

The quickfix component adapts the QuickFIX/J FIX engine for using in Camel . This component uses the standard Financial Interchange (FIX) protocol for message transport.

[Important]Previous Versions

The quickfix component was rewritten for Camel 2.5. For information about using the quickfix component prior to 2.5 see the documentation section below.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-quickfix</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

The exchange headers include information to help with exchange filtering, routing and other processing. The following headers are available:

Header Name Description
EventCategory One of AppMessageReceived, AppMessageSent, AdminMessageReceived, AdminMessageSent, SessionCreated, SessionLogon, SessionLogoff. See the QuickfixjEventCategory enum.
SessionID The FIX message SessionID
MessageType The FIX MsgType tag value
DataDictionary Specifies a data dictionary to used for parsing an incoming message. Can be an instance of a data dictionary or a resource path for a QuickFIX/J data dictionary file

The DataDictionary header is useful if string messages are being received and need to be parsed in a route. QuickFIX/J requires a data dictionary to parse certain types of messages (with repeating groups, for example). By injecting a DataDictionary header in the route after receiving a message string, the FIX engine can properly parse the data.

When the component detects an initiator or acceptor session setting in the QuickFIX/J configuration file it will automatically create the corresponding initiator and/or acceptor connector. These settings can be in the default or in a specific session section of the configuration file.

Session Setting Component Action
ConnectionType=initiator Create an initiator connector
ConnectionType=acceptor Create an acceptor connector

The threading model for the QuickFIX/J session connectors can also be specified. These settings affect all sessions in the configuration file and must be placed in the settings default section.

Default/Global Setting Component Action
ThreadModel=ThreadPerConnector Use SocketInitiator or SocketAcceptor (default)
ThreadModel=ThreadPerSession Use ThreadedSocketInitiator or ThreadedSocketAcceptor

The QuickFIX/J logger implementation can be specified by including the following settings in the default section of the configuration file. The ScreenLog is the default if none of the following settings are present in the configuration. It's an error to include settings that imply more than one log implementation.

Default/Global Setting Component Action
ScreenLogShowEvents Use a ScreenLog
ScreenLogShowIncoming Use a ScreenLog
ScreenLogShowOutgoing Use a ScreenLog
SLF4J* Camel 2.6+. Use a SLF4JLog. Any of the SLF4J settings will cause this log to be used.
FileLogPath Use a FileLog
JdbcDriver Use a JdbcLog
Default/Global Setting Component Action
UseJmx if Y, then enable QuickFIX/J JMX
ref:someName

Where someName is the name of an endpoint in the Registry (usually, but not always, the Spring registry). If you are using the Spring registry, someName would be the bean ID of an endpoint in the Spring registry.

This component can be used when you need dynamic discovery of endpoints in the Registry where you can compute the URI at runtime. Then you can look up the endpoint using the following code:

   // lookup the endpoint
   String myEndpointRef = "bigspenderOrder";
   Endpoint endpoint = context.getEndpoint("ref:" + myEndpointRef);
   
   Producer producer = endpoint.createProducer();
   Exchange exchange = producer.createExchange();
   exchange.getIn().setBody(payloadToSend);
   // send the exchange
   producer.process(exchange);
   ...

And you could have a list of endpoints defined in the Registry such as:

  <camelContext id="camel" xmlns="http://activemq.apache.org/camel/schema/spring">
      <endpoint id="normalOrder" uri="activemq:order.slow"/>
      <endpoint id="bigspenderOrder" uri="activemq:order.high"/>
      ...
  </camelContext>

Available as of Camel 2.6

[Warning]Routebox subject to change

The Routebox component will be revisited in upcoming releases to see if it can be further simplified, be more intuitive and user friendly. The related Context component may be regarded as the simpler component. This component might be deprecated in favor of Context.

The routebox component enables the creation of specialized endpoints that offer encapsulation and a strategy based indirection service to a collection of camel routes hosted in an automatically created or user injected camel context.

Routebox endpoints are camel endpoints that may be invoked directly on camel routes. The routebox endpoint performs the following key functions * encapsulation - acts as a blackbox, hosting a collection of camel routes stored in an inner camel context. The inner context is fully under the control of the routebox component and is JVM bound. * strategy based indirection - direct payloads sent to the routebox endpoint along a camel route to specific inner routes based on a user defined internal routing strategy or a dispatch map. * exchange propagation - forward exchanges modified by the routebox endpoint to the next segment of the camel route.

The routebox component supports both consumer and producer endpoints.

Producer endpoints are of two flavors * Producers that send or dispatch incoming requests to a external routebox consumer endpoint * Producers that directly invoke routes in an internal embedded camel context thereby not sending requests to an external consumer.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-routebox</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

Name Default Value Description
dispatchStrategy null A string representing a key in the Camel Registry matching an object value implementing the interface org.apache.camel.component.routebox.strategy.RouteboxDispatchStrategy
dispatchMap null A string representing a key in the Camel Registry matching an object value of the type HashMap<String, String>. The HashMap key should contain strings that can be matched against the value set for the exchange header ROUTE_DISPATCH_KEY. The HashMap value should contain inner route consumer URI's to which requests should be directed.
innerContext auto created A string representing a key in the Camel Registry matching an object value of the type org.apache.camel.CamelContext. If a CamelContext is not provided by the user a CamelContext is automatically created for deployment of inner routes.
innerRegistry null A string representing a key in the Camel Registry matching an object value that implements the interface org.apache.camel.spi.Registry. If Registry values are utilized by inner routes to create endpoints, an innerRegistry parameter must be provided
routeBuilders empty List A string representing a key in the Camel Registry matching an object value of the type List<org.apache.camel.builder.RouteBuilder>. If the user does not supply an innerContext pre-primed with inner routes, the routeBuilders option must be provided as a non-empty list of RouteBuilders containing inner routes
innerProtocol Direct The Protocol used internally by the Routebox component. Can be Direct or SEDA. The Routebox component currently offers protocols that are JVM bound.
sendToConsumer true Dictates whether a Producer endpoint sends a request to an external routebox consumer. If the setting is false, the Producer creates an embedded inner context and processes requests internally.
forkContext true The Protocol used internally by the Routebox component. Can be Direct or SEDA. The Routebox component currently offers protocols that are JVM bound.
threads 20 Number of threads to be used by the routebox to receive requests. Setting applicable only for innerProtocol SEDA.
queueSize unlimited Create a fixed size queue to receive requests. Setting applicable only for innerProtocol SEDA.

The rmi: component binds PojoExchanges to the RMI protocol (JRMP).

Since this binding is just using RMI, normal RMI rules still apply regarding what methods can be invoked. This component supports only PojoExchanges that carry a method invocation from an interface that extends the Remote interface. All parameters in the method should be either Serializable or Remote objects.

Name Default Value Description
method null As of Apache Camel 1.3, you can set the name of the method to invoke.
remoteInterfaces null Its now possible to use this option from Camel 2.7: in the XML DSL. It can be a list of interface names separated by comma.
Property Default Description
splitEntries true If true, Apache Camel splits a feed into its individual entries and returns each entry, poll by poll. For example, if a feed contains seven entries, Apache Camel returns the first entry on the first poll, the second entry on the second poll, and so on. When no more entries are left in the feed, Apache Camel contacts the remote RSS URI to obtain a new feed. If false, Apache Camel obtains a fresh feed on every poll and returns all of the feed's entries.
filter true Use in combination with the splitEntries option in order to filter returned entries. By default, Apache Camel applies the UpdateDateFilter filter, which returns only new entries from the feed, ensuring that the consumer endpoint never receives an entry more than once. The filter orders the entries chronologically, with the newest returned last.
throttleEntries true Camel 2.5: Sets whether all entries identified in a single feed poll should be delivered immediately. If true, only one entry is processed per consumer.delay. Only applicable when splitEntries is set to true.
lastUpdate null Use in combination with the filter option to block entries earlier than a specific date/time (uses the entry.updated timestamp). The format is: yyyy-MM-ddTHH:MM:ss. Example: 2007-12-24T17:45:59.
feedHeader true Specifies whether to add the ROME SyndFeed object as a header.
sortEntries false If splitEntries is true, this specifies whether to sort the entries by updated date.
consumer.delay 60000 Delay in milliseconds between each poll.
consumer.initialDelay 1000 Milliseconds before polling starts.
consumer.userFixedDelay false Set to true to use fixed delay between pools, otherwise fixed rate is used. See ScheduledExecutorService in JDK for details.

Apache Camel initializes the In body on the Exchange with a ROME SyndFeed. Depending on the value of the splitEntries flag, Apache Camel returns either a SyndFeed with one SyndEntry or a java.util.List of SyndEntrys.

Option Value Behavior
splitEntries true A single entry from the current feed is set in the exchange.
splitEntries false The entire list of entries from the current feed is set in the exchange.
Header Description
org.apache.camel.component.rss.feed Apache Camel 1.x: The entire SyncFeed object.
CamelRssFeed Apache Camel 2.0: The entire SyncFeed object.

You can filter out entries quite easily using XPath, as shown in the data format section above. You can also exploit Apache Camel's Bean Integration to implement your own conditions. For instance, a filter equivalent to the XPath example above would be:

// only entries with Camel in the title will get through the filter
from("rss:file:src/test/data/rss20.xml?splitEntries=true&consumer.delay=100").
    filter().method("myFilterBean", "titleContainsCamel").to("mock:result");

The custom bean for this would be:

public static class FilterBean {
    public boolean titleContainsCamel(@Body SyndFeed feed) {
        SyndEntry firstEntry = (SyndEntry) feed.getEntries().get(0);
        return firstEntry.getTitle().contains("Camel");
    }
}

The scalate: component allows you to process a message using Scalate template, which supports either SSP or Scaml format templates. This can be ideal when using Templating to generate responses for requests.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.fusesource.scalate</groupId>
    <artifactId>scalate-camel</artifactId>
    <version>1.0</version>
</dependency>

Apache Camel will provide exchange information in the Scalate context (just a Map). The Exchange is transfered as:

key value
exchange The Exchange itself.
headers The headers of the In message.
camelContext The Camel Context intance.
request The In message.
in The In message.
body The In message body.
out The Out message (only for InOut message exchange pattern).
response The Out message (only for InOut message exchange pattern).

Apache Camel provides two headers by which you can define a different resource location for a template or the template content itself. If any of these headers is set then Apache Camel uses this over the endpoint configured resource. This allows you to provide a dynamic template at runtime.

Header Type Description
CamelScalateResourceUri String An URI for the template resource to use instead of the endpoint configured.
CamelScalateTemplate String The template to use instead of the endpoint configured.
Name Default Value Description
type none The type of action you want to perform. Actually you can enter here POLL or TRAP. The value POLL will instruct the endpoint to poll a given host for the supplied OID keys. If you put in TRAP you will setup a listener for SNMP Trap Events.
address none This is the IP address and the port of the host to poll or where to setup the Trap Receiver. Example: 127.0.0.1:162
protocol udp Here you can select which protocol to use. By default it will be udp protocol but you may want to use tcp as well
retries 2 Defines how often a retry is made before canceling the request.
timeout 1500 Sets the timeout value for the request in millis.
snmpVersion 0 (which means SNMPv1) Sets the snmp version for the request.
snmpCommunity public Sets the community octet string for the snmp request.
delay 60 seconds Defines the delay in seconds between to poll cycles.
oids none Defines which values you are interested in. Please have a look at the Wikipedia to get a better understanding. You may provide a single OID or a coma separated list of OIDs. Example: oids="1.3.6.1.2.1.1.3.0,1.3.6.1.2.1.25.3.2.1.5.1,1.3.6.1.2.1.25.3.5.1.1.1,1.3.6.1.2.1.43.5.1.1.11.1"

Name Description Example Required Default Value
inputChannel The Spring integration input channel name that this endpoint wants to consume from, where the specified channel name is defined in the Spring context. inputChannel=requestChannel No
outputChannel The Spring integration output channel name that is used to send messages to the Spring integration context. outputChannel=replyChannel No
inOut The exchange pattern that the Spring integration endpoint should use. inOut=true No inOnly for the Spring integration consumer and outOnly for the Spring integration provider
consumer.delay Delay in milliseconds between each poll. consumer.delay=60000 No 500
consumer.initialDelay Milliseconds before polling starts. consumer.initialDelay=10000 No 1000
consumer.userFixedDelay Specify true to use fixed delay between polls, otherwise fixed rate is used. See the Java[ScheduledExecutorService|http://java.sun.com/j2se/1.5.0/docs/api/index.html?java/lang/Character.html] class for details. consumer.userFixedDelay=false No false

You can set up a Spring integration endpoint using a URI, as follows:

<beans:beans xmlns="http://www.springframework.org/schema/integration"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
			http://www.springframework.org/schema/beans/spring-beans.xsd
			http://www.springframework.org/schema/integration
			http://www.springframework.org/schema/integration/spring-integration.xsd
			http://camel.apache.org/schema/spring
			http://camel.apache.org/schema/spring/camel-spring.xsd">
	
	<channel id="inputChannel"/>
   	<channel id="outputChannel"/>
   	<channel id="onewayChannel"/>

	<service-activator input-channel="inputChannel"	          
	          ref="helloService"
	          method="sayHello"/>
	          	      
	<service-activator input-channel="onewayChannel"	          
	          ref="helloService"
	          method="greet"/>
	          
	<beans:bean id="helloService" class="org.apache.camel.component.spring.integration.HelloWorldService"/>
    
    <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
      <route>
        <from uri="direct:twowayMessage"/>
        <!-- Using the &as the separator of & -->
        <to uri="spring-integration:inputChannel?inOut=true&nputChannel=outputChannel"/>
      </route>
      <route>      
        <from uri="direct:onewayMessage"/>
        <to uri="spring-integration:onewayChannel?inOut=false"/>
      </route>
    </camelContext>
<channel id="requestChannel"/>
<channel id="responseChannel"/>

<beans:bean id="myProcessor" class="org.apache.camel.component.spring.integration.MyProcessor"/>

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <!-- Using the &as the separator of & -->
    <from uri="spring-integration://requestChannel?outputChannel=responseChannel&nOut=true"/>
    <process ref="myProcessor"/>
  </route>
</camelContext>

Or directly using a Spring integration channel name:

<beans:beans xmlns="http://www.springframework.org/schema/integration"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
			http://www.springframework.org/schema/beans/spring-beans.xsd
			http://www.springframework.org/schema/integration
			http://www.springframework.org/schema/integration/spring-integration.xsd
			http://camel.apache.org/schema/spring
			http://camel.apache.org/schema/spring/camel-spring.xsd">
	<channel id="outputChannel"/>

    <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
      <route>
        <!-- camel will create a spring integration endpoint automatically -->
        <from uri="outputChannel"/>
        <to uri="mock:result"/>
      </route>
    </camelContext>

Spring integration also provides the Spring integration's source and target adapters, which can route messages from a Spring integration channel to a Apache Camel endpoint or from a Apache Camel endpoint to a Spring integration channel.

This example uses the following namespaces:

<beans:beans xmlns="http://www.springframework.org/schema/integration"
       xmlns:beans="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:camel-si="http://camel.apache.org/schema/spring/integration"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/integration
	   http://www.springframework.org/schema/integration/spring-integration.xsd
       http://camel.apache.org/schema/spring/integration
       http://camel.apache.org/schema/spring/integration/camel-spring-integration.xsd
       http://camel.apache.org/schema/spring
       http://camel.apache.org/schema/spring/camel-spring.xsd
    ">

You can bind your source or target to a Apache Camel endpoint as follows:

<!-- Create the camel context here -->
<camelContext id="camelTargetContext" xmlns="http://camel.apache.org/schema/spring">
    <route>
        <from uri="direct:EndpointA" />
        <to uri="mock:result" />
    </route>
    <route>
        <from uri="direct:EndpointC"/>
        <process ref="myProcessor"/>
      </route>
</camelContext>

<!-- We can bind the camelTarget to the camel context's endpoint by specifying the camelEndpointUri attribute -->
<camel-si:camelTarget id="camelTargetA" camelEndpointUri="direct:EndpointA" expectReply="false">
    <camel-si:camelContextRef>camelTargetContext</camel-si:camelContextRef>
</camel-si:camelTarget>

<camel-si:camelTarget id="camelTargetB" camelEndpointUri="direct:EndpointC" replyChannel="channelC" expectReply="true">
    <camel-si:camelContextRef>camelTargetContext</camel-si:camelContextRef>
</camel-si:camelTarget>

<camel-si:camelTarget id="camelTargetD" camelEndpointUri="direct:EndpointC" expectReply="true">
    <camel-si:camelContextRef>camelTargetContext</camel-si:camelContextRef>
</camel-si:camelTarget>

<beans:bean id="myProcessor" class="org.apache.camel.component.spring.integration.MyProcessor"/>
<!-- spring integration channels -->
<channel id="channelA"/>
<channel id="channelB"/>
<channel id="channelC"/>
      
<!-- spring integration service activator -->
<service-activator input-channel="channelB" output-channel="channelC" ref="helloService" method="sayHello"/>
      
<!-- custom bean -->
<beans:bean id="helloService" class="org.apache.camel.component.spring.integration.HelloWorldService"/>
      
<camelContext id="camelSourceContext" xmlns="http://camel.apache.org/schema/spring">
    <route>
        <from uri="direct:OneWay"/>
        <to uri="direct:EndpointB" />
    </route>
    <route>
    	   <from uri="direct:TwoWay"/>
        <to uri="direct:EndpointC" />
    </route>
</camelContext>

<!-- camelSource will redirect the message coming for direct:EndpointB to the spring requestChannel channelA -->

<camel-si:camelSource id="camelSourceA" camelEndpointUri="direct:EndpointB"
                         requestChannel="channelA" expectReply="false">
    <camel-si:camelContextRef>camelSourceContext</camel-si:camelContextRef>
</camel-si:camelSource>

<!-- camelSource will redirect the message coming for direct:EndpointC to the spring requestChannel channelB
 then it will pull the response from channelC and put the response message back to direct:EndpointC -->

<camel-si:camelSource id="camelSourceB" camelEndpointUri="direct:EndpointC"
    requestChannel="channelB" replyChannel="channelC" expectReply="true">
    <camel-si:camelContextRef>camelSourceContext</camel-si:camelContextRef>
</camel-si:camelSource>

Available as of Camel 2.6

The spring-ws: component allows you to integrate with Spring Web Services. It offers both clientside support, for accessing web services, and serverside support for creating your own contract-first web services.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
	<groupId>org.apache.camel</groupId>
	<artifactId>camel-spring-ws</artifactId>
	<version>x.x.x</version>
	<!-- use the same version as your Camel core version -->
</dependency>

[Important]Dependencies

This component offers support for Spring-WS 1.5.9 which is compatible with Spring 2.5.x and 3.0.x. In order to run camel-spring-ws on Spring 2.5.x you need to add the spring-webmvc module from Spring 2.5.x.

In order to run Spring-WS 1.5.9 on Spring 3.0 you need to exclude the OXM module from Spring 3.0 as this module is also included in Spring-WS 1.5.9 (see this post)

The URI scheme for this component is as follows

spring-ws:[mapping-type:]address[?options]

To expose a web service mapping-type needs to be set to any of the following:

Mapping type Description
rootqname Offers the option to map web service requests based on the qualified name of the root element contained in the message.
soapaction Used to map web service requests based on the SOAP action specified in the header of the message.
uri In order to map web service requests that target a specific URI.
xpathresult Used to map web service requests based on the evaluation of an XPath expression against the incoming message. The result of the evaluation should match the XPath result specified in the endpoint URI.
beanname Allows you to reference a org.apache.camel.component.spring.ws.bean.CamelEndpointDispatcher in order to integrate with existing (legacy) endpoint mappings like PayloadRootQNameEndpointMapping, SoapActionEndpointMapping, etc

As a consumer the address should contain a value relevant to the specified mapping-type (e.g. a SOAP action, XPath expression). As a producer the address should be set to the URI of the web service your calling upon.

You can append query options to the URI in the following format, ?option=value&option=value&...

Name Required? Description
soapAction No SOAP action to include inside a SOAP request when accessing remote web services
wsAddressingAction No WS-Addressing 1.0 action header to include when accessing web services. The To header is set to the address of the web service as specified in the endpoint URI (default Spring-WS behavior).
expression Only when mapping-type is xpathresult XPath expression to use in the process of mapping web service requests, should match the result specified by xpathresult

The following options can be specified in the registry (most likely a Spring ApplicationContext) and referenced from the endpoint URI using the # notation.

Name Required? Description
webServiceTemplate No Option to provide a custom WebServiceTemplate. This allows for full control over client-side web services handling; like adding a custom interceptor or specifying a fault resolver, message sender or message factory.
messageSender No Option to provide a custom WebServiceMessageSender. For example to perform authentication or use alternative transports
messageFactory No Option to provide a custom WebServiceMessageFactory. For example when you want Apache Axiom to handle web service messages instead of SAAJ
transformerFactory No Option to override default TransformerFactory. The provided transformer factory must be of type javax.xml.transform.TransformerFactory
endpointMapping Only when mapping-type is rootqname, soapaction, uri or xpathresult Reference to org.apache.camel.component.spring.ws.bean.CamelEndpointMapping in the Registry/ApplicationContext. Only one bean is required in the registry to serve all Camel/Spring-WS endpoints. This bean is auto-discovered by the MessageDispatcher and used to map requests to Camel endpoints based on characteristics specified on the endpoint (like root QName, SOAP action, etc)

Name Type Description
CamelSpringWebserviceEndpointUri String URI of the web service your accessing as a client, overrides address part of the endpoint URI
CamelSpringWebserviceSoapAction String Header to specify the SOAP action of the message, overrides soapAction option if present
CamelSpringWebserviceAddressingAction URI Use this header to specify the WS-Addressing action of the message, overrides wsAddressingAction option if present

To call a web service at http://foo.com/bar simply define a route:

from("direct:example").to("spring-ws:http://foo.com/bar")

And sent a message:

template.requestBody("direct:example", "<foobar xmlns=\"http://foo.com\"><msg>test message</msg></foobar>");

In order to expose a web service using this component you first need to set-up a MessageDispatcher to look for endpoint mappings in a Spring XML file. If you plan on running inside a servlet container you probably want to use a MessageDispatcherServlet configured in web.xml.

By default the MessageDispatcherServlet will look for a Spring XML named /WEB-INF/spring-ws-servlet.xml. To use Camel with Spring-WS the only mandatory bean in that XML file is CamelEndpointMapping. This bean allows the MessageDispatcher to dispatch web service requests to your routes.

web.xml

<web-app>
    <servlet>
        <servlet-name>spring-ws</servlet-name>
        <servlet-class>org.springframework.ws.transport.http.MessageDispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>spring-ws</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

spring-ws-servlet.xml

<bean id="endpointMapping" class="org.apache.camel.component.spring.ws.bean.CamelEndpointMapping" />

<bean id="wsdl" class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition">
	<property name="schema"> 
		<bean class="org.springframework.xml.xsd.SimpleXsdSchema">                   
			<property name="xsd" value="/WEB-INF/foobar.xsd"/>
		</bean>    
	</property>                                        
	<property name="portTypeName" value="FooBar"/>                                
	<property name="locationUri" value="/"/>                              
	<property name="targetNamespace" value="http://example.com/"/>       
</bean>

More information on setting up Spring-WS can be found in Writing Contract-First Web Services. Basically paragraph 3.6 "Implementing the Endpoint" is handled by this component (specifically paragraph 3.6.2 "Routing the Message to the Endpoint" is where CamelEndpointMapping comes in).

With the XML configuration in-place you can now use Camel's DSL to define what web service requests are handled by your endpoint:

The following route will receive all web service requests that have a root element named "GetFoo" within the http://example.com/ namespace.

from("spring-ws:rootqname:{http://example.com/}GetFoo?endpointMapping=#endpointMapping")
.convertBodyTo(String.class).to(mock:example)

The following route will receive web service requests containing the http://example.com/GetFoo SOAP action.

from("spring-ws:soapaction:http://example.com/GetFoo?endpointMapping=#endpointMapping")
.convertBodyTo(String.class).to(mock:example)

The following route will receive all requests sent to http://example.com/foobar.

from("spring-ws:uri:http://example.com/foobar?endpointMapping=#endpointMapping")
.convertBodyTo(String.class).to(mock:example)

The route below will receive requests that contain the element <foobar>abc</foobar> anywhere inside the message (and the default namespace).

from("spring-ws:xpathresult:abc?expression=//foobar&endpointMapping=#endpointMapping")
.convertBodyTo(String.class).to(mock:example)

For every endpoint with mapping-type beanname one bean of type CamelEndpointDispatcher with a corresponding name is required in the Registry/ApplicationContext. This bean acts as a bridge between the Camel endpoint and an existing endpoint mapping like PayloadRootQNameEndpointMapping.

[Note]Note

The use of the beanname mapping-type is primarily meant for (legacy) situations where you're already using Spring-WS and have endpoint mappings defined in a Spring XML file. The beanname mapping-type allows you to wire your Camel route into an existing endpoint mapping. When you're starting from scratch it's recommended to define your endpoint mappings as Camel URI's (as illustrated above with endpointMapping) since it requires less configuration and is more expressive. Alternatively you could use vanilla Spring-WS with the help of annotations.

An example of a route using beanname:

<camelContext xmlns="http://camel.apache.org/schema/spring">
	<route>
		<from uri="spring-ws:beanname:QuoteEndpointDispatcher" />
		<to uri="mock:example" />
	</route>
</camelContext>

<bean id="legacyEndpointMapping" class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping">
    <property name="mappings">
        <props>
            <prop key="{http://example.com/}GetFuture">FutureEndpointDispatcher</prop>
            <prop key="{http://example.com/}GetQuote">QuoteEndpointDispatcher</prop>
        </props>
    </property>
</bean>

<bean id="QuoteEndpointDispatcher" class="org.apache.camel.component.spring.ws.bean.CamelEndpointDispatcher" />
<bean id="FutureEndpointDispatcher" class="org.apache.camel.component.spring.ws.bean.CamelEndpointDispatcher" />

The sql: component allows you to work with databases using JDBC queries. The difference between this component and JDBC component is that in case of SQL the query is a property of the endpoint and it uses message payload as parameters passed to the query.

This component uses spring-jdbc behind the scenes for the actual SQL handling.

The SQL component also supports:

  • a JDBC based repository for the Idempotent Consumer EIP pattern. See further below.

  • a JDBC based repository for the Aggregator EIP pattern. See further below.

Option Type Default Description
dataSourceRef String null Apache Camel 1.5.1/2.0: Reference to a DataSource to look up in the registry.
placeholder String # Camel 2.4: Specifies a character that will be replaced to ? in SQL query. Notice, that it is simple String.replaceAll() operation and no SQL parsing is involved (quoted strings will also change)
template.<xxx> null Sets additional options on the Spring JdbcTemplate that is used behind the scenes to execute the queries. For instance, template.maxRows=10. For detailed documentation, see the JdbcTemplate javadoc documentation.

When performing update operations, the SQL Component stores the update count in the following message headers:

Header Description
SqlProducer.UPDATE_COUNT Apache Camel 1.x: The number of rows updated for update operations, returned as an Integer object.
CamelSqlUpdateCount Apache Camel 2.0: The number of rows updated for update operations, returned as an Integer object.
CamelSqlRowCount Apache Camel 2.0: The number of rows returned for select operations, returned as an Integer object.

In the sample below we execute a query and retrieve the result as a List of rows, where each row is a Map<String, Object and the key is the column name.

First, we set up a table to use for our sample. As this is based on an unit test, we do it java code:

// this is the database we create with some initial data for our unit test
jdbcTemplate.execute("create table projects (id integer primary key,"
                     + "project varchar(10), license varchar(5))");
jdbcTemplate.execute("insert into projects values (1, 'Camel', 'ASF')");
jdbcTemplate.execute("insert into projects values (2, 'AMQ', 'ASF')");
jdbcTemplate.execute("insert into projects values (3, 'Linux', 'XXX')");

Then we configure our route and our sql component. Notice that we use a direct endpoint in front of the sql endpoint. This allows us to send an exchange to the direct endpoint with the URI, direct:simple, which is much easier for the client to use than the long sql: URI. Note that the DataSource is looked up up in the registry, so we can use standard Spring XML to configure our DataSource.

from("direct:simple")
    .to("sql:select * from projects where license = # order by id?dataSourceRef=jdbc/myDataSource")
    .to("mock:result");

And then we fire the message into the direct endpoint that will route it to our sql component that queries the database.

MockEndpoint mock = getMockEndpoint("mock:result");
mock.expectedMessageCount(1);

// send the query to direct that will route it to the sql where we will execute the query
// and bind the parameters with the data from the body. The body only contains one value
// in this case (XXX) but if we should use multi values then the body will be iterated
// so we could supply a List<String> instead containing each binding value.
template.sendBody("direct:simple", "XXX");

mock.assertIsSatisfied();

// the result is a List
List received = assertIsInstanceOf(List.class, mock.getReceivedExchanges().get(0).getIn().getBody());

// and each row in the list is a Map
Map row = assertIsInstanceOf(Map.class, received.get(0));

// and we should be able the get the project from the map that should be Linux
assertEquals("Linux", row.get("PROJECT"));

We could configure the DataSource in Spring XML as follows:

 <jee:jndi-lookup id="myDS" jndi-name="jdbc/myDataSource"/> 

Available as of Camel 2.6

[Important]Using JdbcAggregationRepository in Camel 2.6

In Camel 2.6, the JdbcAggregationRepository is provided in the camel-jdbc-aggregator component. From Camel 2.7 onwards, the JdbcAggregationRepository is provided in the camel-sql component.

JdbcAggregationRepository is an AggregationRepository which on the fly persists the aggregated messages. This ensures that you will not loose messages, as the default aggregator will use an in memory only AggregationRepository. The JdbcAggregationRepository allows together with Camel to provide persistent support for the Aggregator.

It has the following options:

Option Type Description
dataSource DataSource Mandatory: The javax.sql.DataSource to use for accessing the database.
repositoryName String Mandatory: The name of the repository.
transactionManager TransactionManager Mandatory: The org.springframework.transaction.PlatformTransactionManager to mange transactions for the database. The TransactionManager must be able to support databases.
lobHandler LobHandler A org.springframework.jdbc.support.lob.LobHandler to handle Lob types in the database. Use this option to use a vendor specific LobHandler, for example when using Oracle.
returnOldExchange boolean Whether the get operation should return the old existing Exchange if any existed. By default this option is false to optimize as we do not need the old exchange when aggregating.
useRecovery boolean Whether or not recovery is enabled. This option is by default true. When enabled the Aggregator automatic recover failed aggregated exchange and have them resubmitted.
recoveryInterval long If recovery is enabled then a background task is run every x'th time to scan for failed exchanges to recover and resubmit. By default this interval is 5000 millis.
maximumRedeliveries int Allows you to limit the maximum number of redelivery attempts for a recovered exchange. If enabled then the Exchange will be moved to the dead letter channel if all redelivery attempts failed. By default this option is disabled. If this option is used then the deadLetterUri option must also be provided.
deadLetterUri String An endpoint uri for a Dead Letter Channel where exhausted recovered Exchanges will be moved. If this option is used then the maximumRedeliveries option must also be provided.

The JdbcAggregationRepository will by default recover any failed exchange. It does this by having a background tasks that scans for failed Exchanges in the persistent store. You can use the checkInterval option to set how often this task runs. The recovery works as transactional which ensures that Camel will try to recover and redeliver the failed Exchange. Any Exchange which was found to be recovered will be restored from the persistent store and resubmitted and send out again.

The following headers is set when an exchange is being recovered/redelivered:

Header Type Description
Exchange.REDELIVERED Boolean Is set to true to indicate the Exchange is being redelivered.
Exchange.REDELIVERY_COUNTER Integer The redelivery attempt, starting from 1.

Only when an Exchange has been successfully processed it will be marked as complete which happens when the confirm method is invoked on the AggregationRepository. This means if the same Exchange fails again it will be kept retried until it success.

You can use option maximumRedeliveries to limit the maximum number of redelivery attempts for a given recovered Exchange. You must also set the deadLetterUri option so Camel knows where to send the Exchange when the maximumRedeliveries was hit.

You can see some examples in the unit tests of camel-sql, for example this test.

Name Default Value Description
delay 0 Initial delay in milliseconds before consuming or producing the stream.
encoding JVM Default As of 1.4, you can configure the encoding (is a charset name) to use text-based streams (for example, message body is a String object). If not provided, Apache Camel uses the JVM default Charset.
promptMessage null Apache Camel 2.0: Message prompt to use when reading from stream:in; for example, you could set this to Enter a command:
promptDelay 0 Apache Camel 2.0: Optional delay in milliseconds before showing the message prompt.
initialPromptDelay 2000 Apache Camel 2.0: Initial delay in milliseconds before showing the message prompt. This delay occurs only once. Can be used during system startup to avoid message prompts being written while other logging is done to the system out.
fileName null Apache Camel 2.0: When using the stream:file URI format, this option specifies the filename to stream to/from.
scanStream false

Apache Camel 2.0: To be used for continuously reading a stream such as the unix tail command. Apache Camel 2.4: will retry opening the file if it is overwritten, like tail --retry

retry false Camel 2.7: will retry opening the file if it's overwritten, somewhat like tail --retry
scanStreamDelay 0 Apache Camel 2.0: Delay in milliseconds between read attempts when using scanStream.
groupLines 0 Camel 2.5: To group X number of lines in the consumer. For example to group 10 lines and therefore only spit out an Exchange with 10 lines, instead of 1 Exchange per line.

In the following sample we route messages from the direct:in endpoint to the System.out stream:

@Test
public void testStringContent() throws Exception {
    template.sendBody("direct:in", "Hello Text World\n");
}

@Test
public void testBinaryContent() {
    template.sendBody("direct:in", "Hello Bytes World\n".getBytes());
}

protected RouteBuilder createRouteBuilder() {
    return new RouteBuilder() {
        public void configure() {
            from("direct:in").to("stream:out");
        }
    };
}

The following sample demonstrates how the header type can be used to determine which stream to use. In the sample we use our own output stream, MyOutputStream.

private OutputStream mystream = new MyOutputStream();
private StringBuffer sb = new StringBuffer();

@Test
public void testStringContent() {
    template.sendBody("direct:in", "Hello");
    // StreamProducer appends \n in text mode
    assertEquals("Hello\n", sb.toString());
}

@Test
public void testBinaryContent() {
    template.sendBody("direct:in", "Hello".getBytes());
    // StreamProducer is in binary mode so no \n is appended
    assertEquals("Hello", sb.toString());
}

protected RouteBuilder createRouteBuilder() {
    return new RouteBuilder() {
        public void configure() {
            from("direct:in").setHeader("stream", constant(mystream)).
                to("stream:header");
        }
    };
}

private class MyOutputStream extends OutputStream {

    public void write(int b) throws IOException {
        sb.append((char)b);
    }
}

The following sample demonstrates how to continuously read a file stream (analogous to the UNIX tail command):

from("stream:file?fileName=/server/logs/server.log&scanStream=true&scanStreamDelay=1000").to("bean:logService?method=parseLogLine");
[Note]Note

One difficulty with using the combination of scanStream and retry is that the file will be re-opened and scanned with each iteration of scanStreamDelay. Until NIO2 is available, we cannot reliably detect when a file is deleted or recreated.

The string-template: component allows you to process a message using a String Template. This can be ideal when using Templating to generate responses for requests.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-stringtemplate</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

Option Default Description
contentCache false New option in Apache Camel 1.4. Cache for the resource content when its loaded.

Apache Camel will provide exchange information as attributes (just a java.util.Map) to the string template. The Exchange is transfered as:

key value
exchange The Exchange itself.
headers The headers of the In message.
camelContext The Camel Context.
request The In message.
in The In message.
body The In message body.
out The Out message (only for InOut message exchange pattern).
response The Out message (only for InOut message exchange pattern).
Option Default Description
useDom false Apache Camel 2.0: Whether DOMSource/{{DOMResult}} or SaxSource/{{SaxResult}} should be used by the validator.
useSharedSchema true Camel 2.3: Whether the Schema instance should be shared or not. This option is introduced to work around a JDK 1.6.x bug. Xerces should not have this issue.

The following example shows how to configure a route from endpoint direct:start which then goes to one of two endpoints, either mock:valid or mock:invalid based on whether or not the XML matches the given schema (which is supplied on the classpath).

<camelContext xmlns="http://camel.apache.org/schema/spring">
    <route>
        <from uri="direct:start"/>
        <doTry>
            <to uri="validator:org/apache/camel/component/validator/schema.xsd"/>
            <to uri="mock:valid"/>
            <doCatch>
                <exception>org.apache.camel.ValidationException</exception>
                <to uri="mock:invalid"/>
            </doCatch>
            <doFinally>
                <to uri="mock:finally"/>
            </doFinally>
        </doTry>
    </route>
</camelContext>

The velocity: component allows you to process a message using an Apache Velocity template. This can be ideal when using Templating to generate responses for requests.

Option Default Description
loaderCache true Velocity based file loader cache.
contentCache New option in Apache Camel 1.4: Cache for the resource content when it is loaded. By default, it's false in Apache Camel 1.x. By default, it's true in Apache Camel 2.x.
encoding null New option in Apache Camel 1.6: Character encoding of the resource content.
propertiesFile null New option in Camel 2.1: The URI of the properties file which is used for VelocityEngine initialization.

The velocity component sets some headers on the message (you cannot set these yourself):

Header Description
org.apache.camel.velocity.resource Apache Camel 1.x: The resource as an org.springframework.core.io.Resource object.
org.apache.camel.velocity.resourceUri Apache Camel 1.x: The templateName as a String object.
CamelVelocityResource Apache Camel 2.0: The resource as an org.springframework.core.io.Resource object.
CamelVelocityResourceUri Apache Camel 2.0: The templateName as a String object.

In Apache Camel 1.4 headers set during the Velocity evaluation are returned to the message and added as headers. This makes it possible to return values from Velocity to the Message.

For example, to set the header value of fruit in the Velocity template .tm:

$in.setHeader('fruit', 'Apple')

The fruit header is now accessible from the message.out.headers.

Apache Camel will provide exchange information in the Velocity context (just a Map). The Exchange is transfered as:

key value
exchange The Exchange itself.
headers The headers of the In message.
camelContext The Camel Context intance.
request The In message.
in The In message.
body The In message body.
out The Out message (only for InOut message exchange pattern).
response The Out message (only for InOut message exchange pattern).

Available as of Camel 2.1 Camel provides two headers by which you can define a different resource location for a template or the template content itself. If any of these headers is set then Camel uses this over the endpoint configured resource. This allows you to provide a dynamic template at runtime.

Header Type Description
CamelVelocityResourceUri String Camel 2.1: A URI for the template resource to use instead of the endpoint configured.
CamelVelocityTemplate String Camel 2.1: The template to use instead of the endpoint configured.

The xslt: component allows you to process a message using an XSLT template. This can be ideal when using Templating to generate respopnses for requests.

xslt:templateName[?options]

Where templateName is the classpath-local URI of the template to invoke; or the complete URL of the remote template. Refer to the Spring Documentation for more detail of the URI syntax

You can append query options to the URI in the following format, ?option=value&option=value&...

Here are some example URIs

URI Description
xslt:com/acme/mytransform.xs Refers to the file, com/acme/mytransform.xsl, on the classpath.
xslt:file:///foo/bar.xs Refers to the file, /foo/bar.xsl.
xslt:http://acme.com/cheese/foo.xsl Refers to the remote HTTP resource.
Name Default Value Description
converter null Option to override default XmlConverter. Will lookup for the converter in the Registry. The provided converted must be of type org.apache.camel.converter.jaxp.XmlConverter.
transformerFactory null New added in Apache Camel 1.6 Option to override default TransformerFactory. Will lookup for the transformerFactory in the Registry. The provided transformer factory must be of type javax.xml.transform.TransformerFactory.
transformerFactoryClass null New added in Apache Camel 1.6 Option to override default TransformerFactory. Will create a TransformerFactoryClass instance and set it to the converter.
uriResolver null Camel 2.3: Allows you to use a custom javax.xml.transformation.URIResolver. Camel will by default use its own implementation org.apache.camel.builder.xml.XsltUriResolver which is capable of loading from classpath.
resultHandlerFactory null Camel 2.3: Allows you to use a custom org.apache.camel.builder.xml.ResultHandlerFactory which is capable of using custom org.apache.camel.builder.xml.ResultHandler types.
failOnNullBody true Camel 2.3: Whether or not to throw an exception if the input body is null.
output string Camel 2.3: Option to specify which output type to use. Possible values are: string, bytes, DOM, file. The first three options are all in memory based, where as file is streamed directly to a java.io.File. For file you must specify the filename in the IN header with the key Exchange.XSLT_FILE_NAME which is also CamelXsltFileName. Also any paths leading to the filename must be created beforehand, otherwise an exception is thrown at runtime.
contentCache true Camel 2.6: Cache for the resource content (the stylesheet file) when it is loaded. If set to false Camel will reloader the stylesheet file on each message processing. This is good for development.

Camel 1.6.2/2.2 or older If you use xsl:include in your XSL files then in Camel 2.2 or older it uses the default javax.xml.transform.URIResolver which means it can only lookup files from file system, and its does that relative from the JVM starting folder.

For example this include:

<xsl:include href="staff_template.xsl"/>

Will lookup the staff_tempkalte.xsl file from the starting folder where the application was started.

Camel 1.6.3/2.3 or newer Now Camel provides its own implementation of URIResolver which allows Camel to load included files from the classpath and more intelligent than before.

For example this include:

<xsl:include href="staff_template.xsl"/>

Will now be located relative from the starting endpoint, which for example could be:

.to("xslt:org/apache/camel/component/xslt/staff_include_relative.xsl")

Which means Camel will locate the file in the classpath as org/apache/camel/component/xslt/staff_template.xsl. This allows you to use xsl include and have xsl files located in the same folder such as we do in the example org/apache/camel/component/xslt.

You can use the following two prefixes classpath: or file: to instruct Camel to look either in classpath or file system. If you omit the prefix then Camel uses the prefix from the endpoint configuration. If that neither has one, then classpath is assumed.

You can also refer back in the paths such as

    <xsl:include href="../staff_other_template.xsl"/>

Which then will resolve the xsl file under org/apache/camel/component.