Red Hat Training

A Red Hat training course is available for Red Hat Fuse

Apache Camel Component Reference

Red Hat Fuse 7.3

Configuration reference for Camel components

Red Hat Fuse Documentation Team fuse-docs-support@redhat.com

Abstract

Apache Camel has over 100 components and each component is highly configurable. This guide describes the settings for each of the components.

Chapter 1. Components Overview

This chapter provides a summary of all the components available for Apache Camel.

1.1. Container types

Red Hat Fuse provides a variety of container types, into which you can deploy your Camel applications:

Spring Boot
Apache Karaf
JBoss Enterprise Application Platform (JBoss EAP)

In addition, a Camel application can run as containerless: that is, where a Camel application runs directly in the JVM, without any special container.

In some cases, Fuse might support a Camel component in one container, but not in the others. There are various reasons for this, but in some cases a component is not suitable for all container types. For example, the camel-ejb component is designed spcifically for Java EE (that is, JBoss EAP), and cannot be supported in the other container types.

1.2. Supported components

Note the following key:

Symbol	Description
✔	Supported
❌	Unsupported or not yet supported
Deprecated	Likely to be removed in a future release

Table 1.1, “Apache Camel Component Support Matrix” provides comprehensive details about which Camel components are supported in which containers.

Table 1.1. Apache Camel Component Support Matrix

Component	Type	Containerless	Spring Boot	Karaf	JBoss EAP
`activemq-camel`	Endpoint	✔	✔	✔	✔
`camel-ahc`	Endpoint	✔	✔	✔	✔
`camel-ahc-ws`	Endpoint	✔	✔	✔	✔
`camel-ahc-wss`	Endpoint	✔	✔	✔	✔
`camel-amqp`	Endpoint	✔	✔	✔	✔
`camel-apns`	Endpoint	✔	✔	✔	✔
`camel-asn1`	Data Format	✔	✔	✔	✔
`camel-asterisk`	Endpoint	✔	✔	✔	✔
`camel-atmos`	Endpoint	✔	✔	❌	❌
`camel-atmosphere-websocket`	Endpoint	✔	✔	✔	✔
`camel-atom`	Endpoint	✔	✔	✔	✔
`camel-atomix`	Endpoint	✔	✔	✔	✔
`camel-avro`	Endpoint	✔	✔	✔	✔
`camel-avro`	Data Format	✔	✔	✔	✔
`camel-aws`	Endpoint	✔	✔	✔	✔
`camel-azure`	Endpoint	✔	✔	✔	✔
`camel-bam`	Endpoint	Deprecated	✔	✔	❌
`camel-barcode`	Data Format	✔	✔	✔	✔
`camel-base64`	Data Format	✔	✔	✔	✔
`camel-bean`	Endpoint	✔	✔	✔	✔
`camel-bean`	Language	✔	✔	✔	✔
`camel-bean-validator`	Endpoint	✔	✔	✔	✔
`camel-beanio`	Data Format	✔	✔	✔	✔
`camel-beanstalk`	Endpoint	✔	✔	✔	❌
`camel-binding`	Endpoint	Deprecated	✔	✔	✔
`camel-bindy`	Endpoint	✔	✔	✔	✔
`camel-bindy`	Data Format	✔	✔	✔	✔
`camel-blueprint`	Endpoint	✔	❌	✔	❌
`camel-bonita`	Endpoint	✔	❌	❌	❌
`camel-boon`	Data Format	✔	✔	✔	✔
`camel-box`	Endpoint	✔	✔	✔	✔
`camel-braintree`	Endpoint	✔	✔	✔	✔
`camel-browse`	Endpoint	✔	✔	✔	✔
`camel-cache`	Endpoint	Deprecated	✔	✔	❌
`camel-caffeine`	Endpoint	✔	✔	✔	✔
`camel-castor`	Data Format	Deprecated	✔	✔	✔
`camel-cdi`	Endpoint	✔	❌	Deprecated	✔
`camel-chronicle-engine`	Endpoint	✔	✔	✔	✔
`camel-chunk`	Endpoint	✔	✔	✔	✔
`camel-class`	Endpoint	✔	✔	✔	✔
`camel-cm-sms`	Endpoint	✔	✔	✔	✔
`camel-cmis`	Endpoint	✔	✔	✔	✔
`camel-coap`	Endpoint	✔	✔	✔	✔
`camel-cometd`	Endpoint	✔	✔	✔	✔
`camel-constant`	Language	✔	✔	✔	✔
`camel-context`	Endpoint	Deprecated	❌	❌	❌
`camel-consul`	Endpoint	✔	✔	✔	✔
`camel-controlbus`	Endpoint	✔	✔	✔	✔
`camel-couchbase`	Endpoint	✔	✔	✔	✔
`camel-couchdb`	Endpoint	✔	✔	✔	✔
`camel-cql`	Endpoint	✔	✔	✔	✔
`camel-crypto`	Endpoint	✔	✔	✔	✔
`camel-crypto`	Data Format	✔	✔	✔	✔
`camel-crypto-cms`	Endpoint	✔	✔	✔	✔
`camel-csv`	Data Format	✔	✔	✔	✔
`camel-cxf`	Endpoint	✔	✔	✔	✔
`camel-cxf-transport`	Endpoint	✔	✔	✔	✔
`camel-dataformat`	Endpoint	✔	✔	✔	✔
`camel-dataset`	Endpoint	✔	✔	✔	✔
`camel-digitalocean`	Endpoint	✔	✔	✔	✔
`camel-direct`	Endpoint	✔	✔	✔	✔
`camel-direct-vm`	Endpoint	✔	✔	✔	✔
`camel-disruptor`	Endpoint	✔	✔	✔	✔
`camel-dns`	Endpoint	✔	✔	✔	✔
`camel-docker`	Endpoint	✔	✔	✔	✔
`camel-dozer`	Endpoint	✔	✔	✔	✔
`camel-drill`	Endpoint	✔	✔	✔	❌
`camel-dropbox`	Endpoint	✔	✔	✔	✔
`camel-eclipse`		Deprecated	❌	❌	❌
`camel-ehcache`	Endpoint	✔	✔	✔	✔
`camel-ejb`	Endpoint	✔	❌	❌	✔
`camel-el`	Language	Deprecated	❌	❌	❌
`camel-elasticsearch`	Endpoint	✔	✔	✔	✔
`camel-elasticsearch5`	Endpoint	✔	✔	✔	✔
`camel-elasticsearch-rest`	Endpoint	✔	✔	✔	❌
`camel-elsql`	Endpoint	✔	✔	✔	✔
`camel-etcd`	Endpoint	✔	✔	✔	✔
`camel-eventadmin`	Endpoint	✔	❌	✔	❌
`camel-exchangeProperty`	Language	✔	✔	✔	✔
`camel-exec`	Endpoint	✔	✔	✔	✔
`camel-facebook`	Endpoint	✔	✔	✔	✔
`camel-fhir`	Data Format	✔	✔	✔	✔
`camel-file`	Endpoint	✔	✔	✔	✔
`camel-file`	Language	✔	✔	✔	✔
`camel-flatpack`	Endpoint	✔	✔	✔	✔
`camel-flatpack`	Data Format	✔	✔	✔	✔
`camel-flink`	Endpoint	✔	✔	❌	✔
`camel-fop`	Endpoint	✔	✔	✔	✔
`camel-freemarker`	Endpoint	✔	✔	✔	✔
`camel-ftp`	Endpoint	✔	✔	✔	✔
`camel-gae`	Endpoint	Deprecated	❌	❌	❌
`camel-ganglia`	Endpoint	✔	✔	✔	✔
`camel-geocoder`	Endpoint	✔	✔	✔	✔
`camel-git`	Endpoint	✔	✔	✔	✔
`camel-github`	Endpoint	✔	✔	✔	✔
`camel-google-bigquery`	Endpoint	✔	✔	❌	✔
`camel-google-calendar`	Endpoint	✔	✔	✔	✔
`camel-google-drive`	Endpoint	✔	✔	✔	✔
`camel-google-mail`	Endpoint	✔	✔	✔	✔
`camel-google-pubsub`	Endpoint	✔	✔	✔	✔
`camel-grape`	Endpoint	✔	✔	✔	❌
`camel-groovy`	Language	✔	✔	✔	✔
`camel-groovy-dsl`		Deprecated	❌	❌	❌
`camel-grpc`	Endpoint	✔	✔	✔	✔
`camel-guava-eventbus`	Endpoint	✔	✔	✔	✔
`camel-guice`	Endpoint	Deprecated	✔	❌	❌
`camel-gzip`	Data Format	✔	✔	✔	✔
`camel-hawtdb`	Endpoint	Deprecated	✔	✔	❌
`camel-hazelcast`	Endpoint	✔	✔	✔	✔
`camel-hbase`	Endpoint	✔	✔	❌	❌
`camel-hdfs`	Endpoint	Deprecated	✔	❌	❌
`camel-hdfs2`	Endpoint	✔	✔	✔	✔
`camel-header`	Language	✔	✔	✔	✔
`camel-headersmap`		✔	✔	✔	✔
`camel-hessian`	Data Format	Deprecated	✔	✔	✔
`camel-hipchat`	Endpoint	✔	✔	✔	✔
`camel-hl7`	Data Format	✔	✔	✔	✔
`camel-http`	Endpoint	Deprecated	✔	✔	❌
`camel-http4`	Endpoint	✔	✔	✔	✔
`camel-hystrix`	Endpoint	✔	✔	✔	✔
`camel-ibatis`	Endpoint	Deprecated	❌	❌	❌
`camel-ical`	Data Format	✔	✔	✔	✔
`camel-iec60870`	Endpoint	✔	✔	✔	✔
`camel-ignite`	Endpoint	❌	❌	❌	❌
`camel-imap`	Endpoint	✔	✔	✔	✔
`camel-infinispan`	Endpoint	✔	✔	✔	✔
`camel-influxdb`	Endpoint	✔	✔	✔	✔
`camel-irc`	Endpoint	✔	✔	✔	✔
`camel-ironmq`	Endpoint	❌	❌	❌	❌
`camel-jacksonxml`	Data Format	✔	✔	✔	✔
`camel-jasypt`	Endpoint	✔	✔	✔	✔
`camel-javaspace`	Endpoint	Deprecated	❌	❌	❌
`camel-jaxb`	Data Format	✔	✔	✔	✔
`camel-jbpm`	Endpoint	❌	❌	❌	❌
`camel-jcache`	Endpoint	✔	✔	✔	✔
`camel-jcifs`	Endpoint	✔	❌	✔	❌
`camel-jclouds`	Endpoint	✔	❌	✔	✔
`camel-jcr`	Endpoint	✔	✔	✔	✔
`camel-jdbc`	Endpoint	✔	✔	✔	✔
`camel-jetty`	Endpoint	Deprecated	Deprecated	Deprecated	❌
`camel-jetty8`	Endpoint	❌	❌	❌	❌
`camel-jetty9`	Endpoint	✔	✔	✔	❌
`camel-jgroups`	Endpoint	✔	✔	✔	✔
`camel-jibx`	Data Format	✔	✔	✔	✔
`camel-jing`	Endpoint	✔	✔	✔	✔
`camel-jira`	Endpoint	✔	❌	❌	❌
`camel-jms`	Endpoint	✔	✔	✔	✔
`camel-jmx`	Endpoint	✔	✔	✔	✔
`camel-jolt`	Endpoint	✔	✔	✔	✔
`camel-josql`	Endpoint	Deprecated	✔	✔	❌
`camel-jpa`	Endpoint	✔	✔	✔	✔
`camel-jsch`	Endpoint	✔	✔	✔	✔
`camel-json-fastjson`	Data Format	✔	✔	✔	✔
`camel-json-gson`	Data Format	✔	✔	✔	✔
`camel-json-jackson`	Data Format	✔	✔	✔	✔
`camel-json-johnzon`	Data Format	✔	✔	✔	✔
`camel-json-validator`	Endpoint	✔	✔	✔	❌
`camel-json-xstream`	Data Format	✔	✔	✔	✔
`camel-jsonpath`	Language	✔	✔	✔	✔
`camel-jt400`	Endpoint	✔	✔	✔	✔
`camel-juel`	Endpoint	Deprecated	✔	✔	❌
`camel-jxpath`	Language	Deprecated	❌	❌	❌
`camel-kafka`	Endpoint	✔	✔	✔	✔
`camel-kestrel`	Endpoint	Deprecated	✔	✔	❌
`camel-krati`	Endpoint	Deprecated	✔	✔	❌
`camel-kubernetes`	Endpoint	✔	✔	✔	✔
`camel-kura`		✔	❌	✔	❌
`camel-ldap`	Endpoint	✔	✔	✔	✔
`camel-ldif`	Endpoint	✔	✔	✔	❌
`camel-leveldb`	Endpoint	✔	✔	✔	✔
`camel-linkedin`	Endpoint	✔	✔	✔	✔
`camel-log`	Endpoint	✔	✔	✔	✔
`camel-lpr`	Endpoint	✔	✔	✔	✔
`camel-lra`		❌	❌	❌	✔
`camel-lucene`	Endpoint	✔	✔	✔	✔
`camel-lumberjack`	Endpoint	✔	✔	✔	✔
`camel-lzf`	Data Format	✔	✔	✔	✔
`camel-master`		✔	✔	✔	❌
`camel-mail`	Endpoint	✔	✔	✔	✔
`camel-metrics`	Endpoint	✔	✔	✔	✔
`camel-milo`	Endpoint	✔	✔	✔	✔
`camel-mime-multipart`	Data Format	✔	✔	✔	✔
`camel-mina`	Endpoint	Deprecated	❌	✔	❌
`camel-mina2`	Endpoint	✔	✔	✔	✔
`camel-mllp`	Endpoint	✔	✔	✔	✔
`camel-mock`	Endpoint	✔	✔	✔	✔
`camel-mongodb`	Endpoint	✔	✔	✔	✔
`camel-mongodb-gridfs`	Endpoint	✔	✔	✔	✔
`camel-mongodb3`	Endpoint	✔	✔	✔	✔
`camel-mqtt`	Endpoint	✔	✔	✔	✔
`camel-msv`	Endpoint	✔	✔	✔	✔
`camel-mustache`	Endpoint	✔	✔	✔	✔
`camel-mvel`	Endpoint	✔	✔	✔	✔
`camel-mvel`	Language	✔	✔	✔	✔
`camel-mybatis`	Endpoint	✔	✔	✔	✔
`camel-nagios`	Endpoint	✔	✔	✔	❌
`camel-nats`	Endpoint	✔	✔	✔	✔
`camel-netty`	Endpoint	Deprecated	✔	✔	❌
`camel-netty-http`	Endpoint	Deprecated	✔	✔	❌
`camel-netty4`	Endpoint	✔	✔	✔	✔
`camel-netty4-http`	Endpoint	✔	✔	✔	❌
`camel-ognl`	Language	✔	✔	✔	✔
`camel-olingo2`	Endpoint	✔	✔	✔	✔
`camel-olingo4`	Endpoint	✔	✔	✔	✔
`camel-openshift`	Endpoint	Deprecated	✔	✔	❌
`camel-openstack`	Endpoint	✔	✔	✔	✔
`camel-opentracing`		✔	✔	✔	✔
`camel-optaplanner`	Endpoint	✔	✔	✔	✔
`camel-paho`	Endpoint	✔	✔	✔	✔
`camel-paxlogging`	Endpoint	✔	❌	✔	❌
`camel-pdf`	Endpoint	✔	✔	✔	✔
`camel-pgevent`	Endpoint	✔	✔	✔	✔
`camel-pgp`	Data Format	✔	✔	✔	✔
`camel-php`	Language	Deprecated	❌	❌	✔
`camel-pop3`	Endpoint	✔	✔	✔	✔
`camel-printer`	Endpoint	✔	✔	✔	✔
`camel-properties`	Endpoint	✔	✔	✔	✔
`camel-protobuf`	Data Format	✔	✔	✔	✔
`camel-pubnub`	Endpoint	✔	✔	✔	✔
`camel-python`	Language	Deprecated	❌	❌	❌
`camel-quartz`	Endpoint	Deprecated	✔	✔	❌
`camel-quartz2`	Endpoint	✔	✔	✔	✔
`camel-quickfix`	Endpoint	✔	✔	✔	✔
`camel-rabbitmq`	Endpoint	✔	✔	✔	✔
`camel-reactive-streams`	Endpoint	✔	✔	✔	✔
`camel-reactor`		✔	✔	✔	✔
`camel-ref`	Endpoint	✔	✔	✔	✔
`camel-ref`	Language	✔	✔	✔	✔
`camel-rest`	Endpoint	✔	✔	✔	✔
`camel-rest-api`	Endpoint	✔	✔	✔	✔
`camel-rest-swagger`	Endpoint	✔	✔	✔	✔
`camel-restlet`	Endpoint	✔	✔	✔	❌
`camel-ribbon`		✔	✔	❌	✔
`camel-rmi`	Endpoint	✔	✔	✔	✔
`camel-routebox`	Endpoint	Deprecated	✔	✔	❌
`camel-rss`	Endpoint	✔	✔	✔	✔
`camel-rss`	Data Format	✔	✔	✔	✔
`camel-ruby`	Language	Deprecated	❌	❌	❌
`camel-rx`	Endpoint	Deprecated	✔	✔	❌
`camel-saga`	Endpoint	❌	❌	❌	❌
`camel-salesforce`	Endpoint	✔	✔	✔	✔
`camel-sap`	Endpoint	✔	✔	✔	✔
`camel-sap-netweaver`	Endpoint	✔	✔	✔	✔
`camel-saxon`	Endpoint	✔	✔	✔	✔
`camel-scala`	Endpoint	Deprecated	✔	✔	❌
`camel-scheduler`	Endpoint	✔	✔	✔	✔
`camel-schematron`	Endpoint	✔	✔	✔	✔
`camel-scp`	Endpoint	✔	✔	✔	✔
`camel-scr`	Endpoint	Deprecated	✔	Deprecated	❌
`camel-script`	Endpoint	Deprecated	Deprecated	Deprecated	Deprecated
`camel-seda`	Endpoint	✔	✔	✔	✔
`camel-serialization`	Data Format	✔	✔	✔	✔
`camel-servicenow`	Endpoint	✔	✔	✔	✔
`camel-servlet`	Endpoint	✔	✔	✔	✔
`camel-servletlistener`	Endpoint	Deprecated	✔	✔	❌
`camel-sftp`	Endpoint	✔	✔	✔	✔
`camel-shiro`	Endpoint	✔	✔	✔	✔
`camel-simple`	Language	✔	✔	✔	✔
`camel-sip`	Endpoint	✔	✔	✔	✔
`camel-sjms`	Endpoint	✔	✔	✔	✔
`camel-sjms2`	Endpoint	✔	✔	✔	✔
`camel-slack`	Endpoint	✔	✔	✔	✔
`camel-smpp`	Endpoint	✔	✔	✔	✔
`camel-snakeyaml`	Endpoint	✔	✔	✔	✔
`camel-snmp`	Endpoint	✔	✔	✔	✔
`camel-soapjaxb`	Data Format	✔	✔	✔	✔
`camel-solr`	Endpoint	✔	✔	✔	✔
`camel-spark`	Endpoint	✔	✔	❌	❌
`camel-spark-rest`	Endpoint	✔	✔	❌	❌
`camel-spel`	Language	✔	✔	❌	✔
`camel-splunk`	Endpoint	✔	✔	✔	✔
`camel-spring`	Endpoint	✔	✔	✔	✔
`camel-spring-batch`	Endpoint	✔	✔	✔	✔
`camel-spring-boot`	Endpoint	✔	✔	❌	❌
`camel-spring-cloud`		✔	✔	❌	❌
`camel-spring-cloud-netflix`		✔	✔	❌	❌
`camel-spring-event`	Endpoint	✔	✔	❌	✔
`camel-spring-integration`	Endpoint	✔	❌	❌	✔
`camel-spring-javaconfig`	Endpoint	✔	✔	❌	✔
`camel-spring-ldap`	Endpoint	✔	✔	✔	✔
`camel-spring-redis`	Endpoint	✔	✔	✔	✔
`camel-spring-security`	Endpoint	✔	✔	❌	✔
`camel-spring-ws`	Endpoint	✔	✔	✔	✔
`camel-sql`	Endpoint	✔	✔	✔	✔
`camel-sql-stored`	Endpoint	✔	✔	✔	✔
`camel-ssh`	Endpoint	✔	✔	✔	✔
`camel-stax`	Endpoint	✔	✔	✔	✔
`camel-stomp`	Endpoint	✔	✔	✔	✔
`camel-stream`	Endpoint	✔	✔	✔	✔
`camel-string`	Data Format	✔	✔	✔	✔
`camel-string-template`	Endpoint	✔	✔	✔	✔
`camel-stub`	Endpoint	✔	✔	✔	✔
`camel-swagger`	Endpoint	Deprecated	✔	Deprecated	❌
`camel-swagger-java`	Endpoint	✔	✔	✔	✔
`camel-syslog`	Data Format	✔	✔	✔	✔
`camel-tagsoup`	Endpoint	✔	✔	✔	✔
`camel-tarfile`	Data Format	✔	✔	✔	✔
`camel-telegram`	Endpoint	✔	✔	✔	✔
`camel-thrift`	Endpoint	✔	✔	✔	✔
`camel-thrift`	Data Format	✔	✔	✔	✔
`camel-tika`	Endpoint	✔	✔	✔	✔
`camel-timer`	Endpoint	✔	✔	✔	✔
`camel-tokenize`	Language	✔	✔	✔	✔
`camel-twilio`	Endpoint	✔	✔	✔	✔
`camel-twitter`	Endpoint	✔	✔	✔	✔
`camel-undertow`	Endpoint	✔	✔	✔	✔
`camel-univocity-csv`	Data Format	✔	✔	✔	✔
`camel-univocity-fixed`	Data Format	✔	✔	✔	✔
`camel-univocity-tsv`	Data Format	✔	✔	✔	✔
`camel-urlrewrite`	Endpoint	Deprecated	✔	✔	❌
`camel-validator`	Endpoint	✔	✔	✔	✔
`camel-velocity`	Endpoint	✔	✔	✔	✔
`camel-vertx`	Endpoint	✔	✔	✔	✔
`camel-vm`	Endpoint	✔	✔	✔	✔
`camel-weather`	Endpoint	✔	✔	✔	✔
`camel-websocket`	Endpoint	✔	✔	✔	❌
`camel-wordpress`	Endpoint	✔	✔	✔	✔
`camel-xchange`	Endpoint	✔	✔	✔	❌
`camel-xmlbeans`	Data Format	Deprecated	Deprecated	Deprecated	✔
`camel-xmljson`	Data Format	Deprecated	Deprecated	Deprecated	Deprecated
`camel-xmlrpc`	Endpoint	❌	❌	❌	❌
`camel-xmlrpc`	Data Format	❌	❌	❌	❌
`camel-xmlsecurity`	Endpoint	✔	✔	✔	✔
`camel-xmpp`	Endpoint	✔	✔	✔	✔
`camel-xpath`	Language	✔	✔	✔	✔
`camel-xquery`	Endpoint	✔	✔	✔	✔
`camel-xquery`	Language	✔	✔	✔	✔
`camel-xslt`	Endpoint	✔	✔	✔	✔
`camel-xstream`	Data Format	✔	✔	✔	✔
`camel-xtokenize`	Language	✔	✔	✔	✔
`camel-yaml-snakeyaml`	Data Format	✔	✔	✔	✔
`camel-yammer`	Endpoint	✔	✔	✔	✔
`camel-yql`	Endpoint	❌	❌	❌	❌
`camel-zendesk`	Endpoint	✔	✔	❌	✔
`camel-zip`	Data Format	✔	✔	✔	✔
`camel-zipfile`	Data Format	✔	✔	✔	✔
`camel-zipkin`	Endpoint	✔	✔	✔	✔
`camel-zookeeper`	Endpoint	✔	✔	✔	✔
`camel-zookeeper-master`	Endpoint	✔	✔	✔	✔

Chapter 2. ActiveMQ

ActiveMQ Component

The ActiveMQ component allows messages to be sent to a JMS Queue or Topic; or messages to be consumed from a JMS Queue or Topic using Apache ActiveMQ.

This component is based on the Chapter 170, JMS Component and uses Spring’s JMS support for declarative transactions, using Spring’s JmsTemplate for sending and a MessageListenerContainer for consuming. All the options from the Chapter 170, JMS Component component also apply for this component.

To use this component, make sure you have the activemq.jar or activemq-core.jar on your classpath along with any Apache Camel dependencies such as camel-core.jar, camel-spring.jar and camel-jms.jar.

Transacted and caching

See section Transactions and Cache Levels below on JMS page if you are using transactions with JMS as it can impact performance.

URI format

activemq:[queue:|topic:]destinationName

Where destinationName is an ActiveMQ queue or topic name. By default, the destinationName is interpreted as a queue name. For example, to connect to the queue, FOO.BAR, use:

activemq:FOO.BAR

You can include the optional queue: prefix, if you prefer:

activemq:queue:FOO.BAR

To connect to a topic, you must include the topic: prefix. For example, to connect to the topic, Stocks.Prices, use:

activemq:topic:Stocks.Prices

Options

See Options on the Chapter 170, JMS Component component as all these options also apply for this component.

Camel on EAP deployment

This component is supported by the Camel on EAP (Wildfly Camel) framework, which offers a simplified deployment model on the Red Hat JBoss Enterprise Application Platform (JBoss EAP) container.

You can configure the ActiveMQ Camel component to work either with an embedded broker or an external broker. To embed a broker in the JBoss EAP container, configure the ActiveMQ Resource Adapter in the EAP container configuration file — for details, see ActiveMQ Resource Adapter Configuration.

Configuring the Connection Factory

The following test case shows how to add an ActiveMQComponent to the CamelContext using the activeMQComponent() method while specifying the brokerURL used to connect to ActiveMQ.

camelContext.addComponent("activemq", activeMQComponent("vm://localhost?broker.persistent=false"));

Configuring the Connection Factory using Spring XML

You can configure the ActiveMQ broker URL on the ActiveMQComponent as follows

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

  <camelContext xmlns="http://camel.apache.org/schema/spring">
  </camelContext>

  <bean id="activemq" class="org.apache.activemq.camel.component.ActiveMQComponent">
    <property name="brokerURL" value="tcp://somehost:61616"/>
  </bean>

</beans>

Using connection pooling

When sending to an ActiveMQ broker using Camel it’s recommended to use a pooled connection factory to handle efficient pooling of JMS connections, sessions and producers. This is documented in the page ActiveMQ Spring Support.

You can grab Jencks AMQ pool with Maven:

    <dependency>
      <groupId>org.apache.activemq</groupId>
      <artifactId>activemq-pool</artifactId>
      <version>5.3.2</version>
    </dependency>

And then setup the activemq component as follows:

    <bean id="jmsConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://localhost:61616" />
    </bean>

    <bean id="pooledConnectionFactory"    class="org.apache.activemq.pool.PooledConnectionFactory" init-method="start" destroy-method="stop">
        <property name="maxConnections" value="8" />
        <property name="connectionFactory" ref="jmsConnectionFactory" />
    </bean>

    <bean id="jmsConfig" class="org.apache.camel.component.jms.JmsConfiguration">
        <property name="connectionFactory" ref="pooledConnectionFactory"/>
        <property name="concurrentConsumers" value="10"/>
    </bean>

    <bean id="activemq" class="org.apache.activemq.camel.component.ActiveMQComponent">
        <property name="configuration" ref="jmsConfig"/>
    </bean>

Note

Notice the init and destroy methods on the pooled connection factory. This is important to ensure the connection pool is properly started and shutdown.

The PooledConnectionFactory will then create a connection pool with up to 8 connections in use at the same time. Each connection can be shared by many sessions. There is an option named maxActive you can use to configure the maximum number of sessions per connection; the default value is 500. From ActiveMQ 5.7 onwards the option has been renamed to better reflect its purpose, being named as maxActiveSessionPerConnection. Notice the concurrentConsumers is set to a higher value than maxConnections is. This is okay, as each consumer is using a session, and as a session can share the same connection, we are in the safe. In this example we can have 8 * 500 = 4000 active sessions at the same time.

Invoking MessageListener POJOs in a route

The ActiveMQ component also provides a helper Type Converter from a JMS MessageListener to a Processor. This means that the Chapter 41, Bean Component component is capable of invoking any JMS MessageListener bean directly inside any route.

So for example you can create a MessageListener in JMS as follows:

public class MyListener implements MessageListener {
   public void onMessage(Message jmsMessage) {
       // ...
   }
}

Then use it in your route as follows

from("file://foo/bar").
  bean(MyListener.class);

That is, you can reuse any of the Apache Camel components and easily integrate them into your JMS MessageListener POJO\!

Using ActiveMQ Destination Options

Available as of ActiveMQ 5.6

You can configure the Destination Options in the endpoint uri, using the "destination." prefix. For example to mark a consumer as exclusive, and set its prefetch size to 50, you can do as follows:

<camelContext xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="file://src/test/data?noop=true"/>
    <to uri="activemq:queue:foo"/>
  </route>
  <route>
    <!-- use consumer.exclusive ActiveMQ destination option, notice we have to prefix with destination. -->
    <from uri="activemq:foo?destination.consumer.exclusive=true&amp;destination.consumer.prefetchSize=50"/>
    <to uri="mock:results"/>
  </route>
</camelContext>

Consuming Advisory Messages

ActiveMQ can generate Advisory messages which are put in topics that you can consume. Such messages can help you send alerts in case you detect slow consumers or to build statistics (number of messages/produced per day, etc.) The following Spring DSL example shows you how to read messages from a topic.

<route>
	<from uri="activemq:topic:ActiveMQ.Advisory.Connection?mapJmsMessage=false" />
	<convertBodyTo type="java.lang.String"/>
	<transform>
	     <simple>${in.body}&#13;</simple>
	</transform>
	<to uri="file://data/activemq/?fileExist=Append&ileName=advisoryConnection-${date:now:yyyyMMdd}.txt" />
</route>

If you consume a message on a queue, you should see the following files under data/activemq folder :

advisoryConnection-20100312.txt advisoryProducer-20100312.txt

and containing string:

      ActiveMQMessage {commandId = 0, responseRequired = false, messageId = ID:dell-charles-3258-1268399815140
      -1:0:0:0:221, originalDestination = null, originalTransactionId = null, producerId = ID:dell-charles-
      3258-1268399815140-1:0:0:0, destination = topic://ActiveMQ.Advisory.Connection, transactionId = null,
      expiration = 0, timestamp = 0, arrival = 0, brokerInTime = 1268403383468, brokerOutTime = 1268403383468,
      correlationId = null, replyTo = null, persistent = false, type = Advisory, priority = 0, groupID = null,
      groupSequence = 0, targetConsumerId = null, compressed = false, userID = null, content = null,
      marshalledProperties = org.apache.activemq.util.ByteSequence@17e2705, dataStructure = ConnectionInfo
      {commandId = 1, responseRequired = true, connectionId = ID:dell-charles-3258-1268399815140-2:50,
      clientId = ID:dell-charles-3258-1268399815140-14:0, userName = , password = *****,
      brokerPath = null, brokerMasterConnector = false, manageable = true, clientMaster = true},
      redeliveryCounter = 0, size = 0, properties = {originBrokerName=master, originBrokerId=ID:dell-charles-
      3258-1268399815140-0:0, originBrokerURL=vm://master}, readOnlyProperties = true, readOnlyBody = true,
      droppable = false}

Getting Component JAR

You need this dependency:

activemq-camel

ActiveMQ is an extension of the Chapter 170, JMS Component component released with the ActiveMQ project.

<dependency>
  <groupId>org.apache.activemq</groupId>
  <artifactId>activemq-camel</artifactId>
  <version>5.6.0</version>
</dependency>

Chapter 3. AHC Component

Available as of Camel version 2.8

The ahc: component provides HTTP based endpoints for consuming external HTTP resources (as a client to call external servers using HTTP).
The component uses the Async Http Client library.

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

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

3.1. URI format

ahc:http://hostname[:port][/resourceUri][?options]
ahc:https://hostname[:port][/resourceUri][?options]

Will by default use port 80 for HTTP and 443 for HTTPS.

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

3.2. AhcEndpoint Options

The AHC endpoint is configured using URI syntax:

ahc:httpUri

with the following path and query parameters:

3.2.1. Path Parameters (1 parameters):

Name	Description	Default	Type
httpUri	Required The URI to use such as http://hostname:port/path		URI

3.2.2. Query Parameters (13 parameters):

Name	Description	Default	Type
bridgeEndpoint (producer)	If the option is true, then the Exchange.HTTP_URI header is ignored, and use the endpoint’s URI for request. You may also set the throwExceptionOnFailure to be false to let the AhcProducer send all the fault response back.	false	boolean
bufferSize (producer)	The initial in-memory buffer size used when transferring data between Camel and AHC Client.	4096	int
connectionClose (producer)	Define if the Connection Close header has to be added to HTTP Request. This parameter is false by default	false	boolean
cookieHandler (producer)	Configure a cookie handler to maintain a HTTP session		CookieHandler
headerFilterStrategy (producer)	To use a custom HeaderFilterStrategy to filter header to and from Camel message.		HeaderFilterStrategy
throwExceptionOnFailure (producer)	Option to disable throwing the AhcOperationFailedException in case of failed responses from the remote server. This allows you to get all responses regardless of the HTTP status code.	true	boolean
transferException (producer)	If enabled and an Exchange failed processing on the consumer side, and if the caused Exception was send back serialized in the response as a application/x-java-serialized-object content type (for example using Jetty or Servlet Camel components). On the producer side the exception will be deserialized and thrown as is, instead of the AhcOperationFailedException. The caused exception is required to be serialized. This is by default turned off. If you enable this then be aware that Java will deserialize the incoming data from the request to Java and that can be a potential security risk.	false	boolean
binding (advanced)	To use a custom AhcBinding which allows to control how to bind between AHC and Camel.		AhcBinding
clientConfig (advanced)	To configure the AsyncHttpClient to use a custom com.ning.http.client.AsyncHttpClientConfig instance.		AsyncHttpClientConfig
clientConfigOptions (advanced)	To configure the AsyncHttpClientConfig using the key/values from the Map.		Map
synchronous (advanced)	Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported).	false	boolean
clientConfigRealmOptions (security)	To configure the AsyncHttpClientConfig Realm using the key/values from the Map.		Map
sslContextParameters (security)	Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. This reference overrides any configured SSLContextParameters at the component level. See Using the JSSE Configuration Utility. Note that configuring this option will override any SSL/TLS configuration options provided through the clientConfig option at the endpoint or component level.		SSLContextParameters

3.3. AhcComponent Options

The AHC component supports 8 options which are listed below.

Name	Description	Default	Type
client (advanced)	To use a custom AsyncHttpClient		AsyncHttpClient
binding (advanced)	To use a custom AhcBinding which allows to control how to bind between AHC and Camel.		AhcBinding
clientConfig (advanced)	To configure the AsyncHttpClient to use a custom com.ning.http.client.AsyncHttpClientConfig instance.		AsyncHttpClientConfig
sslContextParameters (security)	Reference to a org.apache.camel.util.jsse.SSLContextParameters in the Registry. Note that configuring this option will override any SSL/TLS configuration options provided through the clientConfig option at the endpoint or component level.		SSLContextParameters
allowJavaSerialized Object (advanced)	Whether to allow java serialization when a request uses context-type=application/x-java-serialized-object This is by default turned off. If you enable this then be aware that Java will deserialize the incoming data from the request to Java and that can be a potential security risk.	false	boolean
useGlobalSslContext Parameters (security)	Enable usage of global SSL context parameters.	false	boolean
headerFilterStrategy (filter)	To use a custom org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel message.		HeaderFilterStrategy
resolveProperty Placeholders (advanced)	Whether the component should resolve property placeholders on itself when starting. Only properties which are of String type can use property placeholders.	true	boolean

Notice that setting any of the options on the AhcComponent will propagate those options to AhcEndpoints being created. However the AhcEndpoint can also configure/override a custom option. Options set on endpoints will always take precedence over options from the AhcComponent.

3.4. Message Headers

Name	Type	Description
`Exchange.HTTP_URI`	`String`	URI to call. Will override existing URI set directly on the endpoint.
`Exchange.HTTP_PATH`	`String`	Request URI’s path, the header will be used to build the request URI with the HTTP_URI. If the path is start with "/", http producer will try to find the relative path based on the Exchange.HTTP_BASE_URI header or the `exchange.getFromEndpoint().getEndpointUri();`
`Exchange.HTTP_QUERY`	`String`	Camel 2.11 onwards: URI parameters. Will override existing URI parameters set directly on the endpoint.
`Exchange.HTTP_RESPONSE_CODE`	`int`	The HTTP response code from the external server. Is 200 for OK.
`Exchange.HTTP_CHARACTER_ENCODING`	`String`	Character encoding.
`Exchange.CONTENT_TYPE`	`String`	The HTTP content type. Is set on both the IN and OUT message to provide a content type, such as `text/html`.
`Exchange.CONTENT_ENCODING`	`String`	The HTTP content encoding. Is set on both the IN and OUT message to provide a content encoding, such as `gzip`.

3.5. Message Body

Camel will store the HTTP response from the external server on the OUT body. All headers from the IN message will be copied to the OUT message, so headers are preserved during routing. Additionally Camel will add the HTTP response headers as well to the OUT message headers.

3.6. Response code

Camel will handle according to the HTTP response code:

Response code is in the range 100..299, Camel regards it as a success response.
Response code is in the range 300..399, Camel regards it as a redirection response and will throw a AhcOperationFailedException with the information.
Response code is 400+, Camel regards it as an external server failure and will throw a AhcOperationFailedException with the information.
throwExceptionOnFailure
The option, throwExceptionOnFailure, can be set to false to prevent the AhcOperationFailedException from being thrown for failed response codes. This allows you to get any response from the remote server.

3.7. AhcOperationFailedException

This exception contains the following information:

The HTTP status code
The HTTP status line (text of the status code)
Redirect location, if server returned a redirect
Response body as a java.lang.String, if server provided a body as response

3.8. Calling using GET or POST

The following algorithm is used to determine if either GET or POST HTTP method should be used:
1. Use method provided in header.
2. GET if query string is provided in header.
3. GET if endpoint is configured with a query string.
4. POST if there is data to send (body is not null).
5. GET otherwise.

3.9. Configuring URI to call

You can set the HTTP producer’s URI directly form the endpoint URI. In the route below, Camel will call out to the external server, oldhost, using HTTP.

from("direct:start")
        .to("ahc:http://oldhost");

And the equivalent Spring sample:

<camelContext xmlns="http://activemq.apache.org/camel/schema/spring">
  <route>
    <from uri="direct:start"/>
    <to uri="ahc:http://oldhost"/>
  </route>
</camelContext>

You can override the HTTP endpoint URI by adding a header with the key, Exchange.HTTP_URI, on the message.

from("direct:start")
    .setHeader(Exchange.HTTP_URI, constant("http://newhost"))
    .to("ahc:http://oldhost");

3.10. Configuring URI Parameters

The ahc producer supports URI parameters to be sent to the HTTP server. The URI parameters can either be set directly on the endpoint URI or as a header with the key Exchange.HTTP_QUERY on the message.

from("direct:start")
        .to("ahc:http://oldhost?order=123&detail=short");

Or options provided in a header:

from("direct:start")
            .setHeader(Exchange.HTTP_QUERY, constant("order=123&detail=short"))
        .to("ahc:http://oldhost");

3.11. How to set the http method to the HTTP producer

The HTTP component provides a way to set the HTTP request method by setting the message header. Here is an example;

from("direct:start")
            .setHeader(Exchange.HTTP_METHOD, constant("POST"))
        .to("ahc:http://www.google.com")
            .to("mock:results");

And the equivalent Spring sample:

<camelContext xmlns="http://activemq.apache.org/camel/schema/spring">
  <route>
    <from uri="direct:start"/>
    <setHeader headerName="CamelHttpMethod">
        <constant>POST</constant>
    </setHeader>
    <to uri="ahc:http://www.google.com"/>
    <to uri="mock:results"/>
  </route>
</camelContext>

3.12. Configuring charset

If you are using POST to send data you can configure the charset using the Exchange property:

exchange.setProperty(Exchange.CHARSET_NAME, "iso-8859-1");

3.12.1. URI Parameters from the endpoint URI

In this sample we have the complete URI endpoint that is just what you would have typed in a web browser. Multiple URI parameters can of course be set using the & character as separator, just as you would in the web browser. Camel does no tricks here.

// we query for Camel at the Google page
template.sendBody("ahc:http://www.google.com/search?q=Camel", null);

3.12.2. URI Parameters from the Message

Map headers = new HashMap();
headers.put(Exchange.HTTP_QUERY, "q=Camel&lr=lang_en");
// we query for Camel and English language at Google
template.sendBody("ahc:http://www.google.com/search", null, headers);

In the header value above notice that it should not be prefixed with ? and you can separate parameters as usual with the & char.

3.12.3. Getting the Response Code

You can get the HTTP response code from the AHC component by getting the value from the Out message header with Exchange.HTTP_RESPONSE_CODE.

Exchange exchange = template.send("ahc:http://www.google.com/search", new Processor() {
            public void process(Exchange exchange) throws Exception {
                exchange.getIn().setHeader(Exchange.HTTP_QUERY, constant("hl=en&q=activemq"));
            }
   });
   Message out = exchange.getOut();
   int responseCode = out.getHeader(Exchange.HTTP_RESPONSE_CODE, Integer.class);

3.13. Configuring AsyncHttpClient

The AsyncHttpClient client uses a AsyncHttpClientConfig to configure the client. See the documentation at
Async Http Client for more details.

In Camel 2.8, configuration is limited to using the builder pattern provided by AsyncHttpClientConfig.Builder. In Camel 2.8, the AsyncHttpClientConfig doesn’t support getters/setters so its not easy to create/configure using a Spring bean style (eg the <bean> tag in the XML file).

The example below shows how to use a builder to create the AsyncHttpClientConfig which we configure on the AhcComponent.

In Camel 2.9, the AHC component uses Async HTTP library 1.6.4. This newer version provides added support for plain bean style configuration. The AsyncHttpClientConfigBean class provides getters and setters for the configuration options available in AsyncHttpClientConfig. An instance of AsyncHttpClientConfigBean may be passed directly to the AHC component or referenced in an endpoint URI using the clientConfig URI parameter.

Also available in Camel 2.9 is the ability to set configuration options directly in the URI. URI parameters starting with "clientConfig." can be used to set the various configurable properties of AsyncHttpClientConfig. The properties specified in the endpoint URI are merged with those specified in the configuration referenced by the "clientConfig" URI parameter with those being set using the "clientConfig." parameter taking priority. The AsyncHttpClientConfig instance referenced is always copied for each endpoint such that settings on one endpoint will remain independent of settings on any previously created endpoints. The example below shows how to configure the AHC component using the "clientConfig." type URI parameters.

from("direct:start")
    .to("ahc:http://localhost:8080/foo?clientConfig.maxRequestRetry=3&clientConfig.followRedirects=true")

3.14. SSL Support (HTTPS)

Using the JSSE Configuration Utility

As of Camel 2.9, the AHC component supports SSL/TLS configuration through the Camel JSSE Configuration Utility. This utility greatly decreases the amount of component specific code you need to write and is configurable at the endpoint and component levels. The following examples demonstrate how to use the utility with the AHC component.

Programmatic configuration of the component

KeyStoreParameters ksp = new KeyStoreParameters();
ksp.setResource("/users/home/server/keystore.jks");
ksp.setPassword("keystorePassword");

KeyManagersParameters kmp = new KeyManagersParameters();
kmp.setKeyStore(ksp);
kmp.setKeyPassword("keyPassword");

SSLContextParameters scp = new SSLContextParameters();
scp.setKeyManagers(kmp);

AhcComponent component = context.getComponent("ahc", AhcComponent.class);
component.setSslContextParameters(scp));

Spring DSL based configuration of endpoint

...
  <camel:sslContextParameters
      id="sslContextParameters">
    <camel:keyManagers
        keyPassword="keyPassword">
      <camel:keyStore
          resource="/users/home/server/keystore.jks"
          password="keystorePassword"/>
    </camel:keyManagers>
  </camel:sslContextParameters>...
...
  <to uri="ahc:https://localhost/foo?sslContextParameters=#sslContextParameters"/>
...

3.15. See Also

Configuring Camel
Component
Endpoint
Getting Started