You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2016/01/16 13:56:03 UTC
[2/3] camel git commit: Component docs - To allow activemq-camel to
reuse docs.
Component docs - To allow activemq-camel to reuse docs.
Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/5baebbe0
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/5baebbe0
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/5baebbe0
Branch: refs/heads/master
Commit: 5baebbe0f28e6a9684c723c0eefc5378f7c5b1e7
Parents: 60dd312
Author: Claus Ibsen <da...@apache.org>
Authored: Sat Jan 16 13:52:21 2016 +0100
Committer: Claus Ibsen <da...@apache.org>
Committed: Sat Jan 16 13:53:40 2016 +0100
----------------------------------------------------------------------
.../camel/component/jms/JmsConfiguration.java | 337 ++++++++++++++-----
1 file changed, 262 insertions(+), 75 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/camel/blob/5baebbe0/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
----------------------------------------------------------------------
diff --git a/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java b/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
index ce13961..fafe09a 100644
--- a/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
+++ b/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
@@ -68,153 +68,341 @@ public class JmsConfiguration implements Cloneable {
private ConnectionFactory templateConnectionFactory;
private ConnectionFactory listenerConnectionFactory;
private int acknowledgementMode = -1;
- @UriParam(defaultValue = "AUTO_ACKNOWLEDGE", enums = "SESSION_TRANSACTED,CLIENT_ACKNOWLEDGE,AUTO_ACKNOWLEDGE,DUPS_OK_ACKNOWLEDGE", label = "consumer")
+ @UriParam(defaultValue = "AUTO_ACKNOWLEDGE", enums = "SESSION_TRANSACTED,CLIENT_ACKNOWLEDGE,AUTO_ACKNOWLEDGE,DUPS_OK_ACKNOWLEDGE", label = "consumer",
+ description = "The JMS acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE")
private String acknowledgementModeName;
// Used to configure the spring Container
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "Specifies the JMS Exception Listener that is to be notified of any underlying JMS exceptions.")
private ExceptionListener exceptionListener;
- @UriParam(label = "consumer,advanced", defaultValue = "Default")
+ @UriParam(label = "consumer,advanced", defaultValue = "Default",
+ description = "The consumer type to use, which can be one of: Simple, Default, or Custom."
+ + " The consumer type determines which Spring JMS listener to use. Default will use org.springframework.jms.listener.DefaultMessageListenerContainer,"
+ + " Simple will use org.springframework.jms.listener.SimpleMessageListenerContainer."
+ + " When Custom is specified, the MessageListenerContainerFactory defined by the messageListenerContainerFactory option"
+ + " will determine what org.springframework.jms.listener.AbstractMessageListenerContainer to use.")
private ConsumerType consumerType = ConsumerType.Default;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "Specifies a org.springframework.util.ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message."
+ + " By default these exceptions will be logged at the WARN level, if no errorHandler has been configured."
+ + " You can configure logging level and whether stack traces should be logged using errorHandlerLoggingLevel and errorHandlerLogStackTrace options."
+ + " This makes it much easier to configure, than having to code a custom errorHandler.")
private ErrorHandler errorHandler;
- @UriParam(defaultValue = "WARN", label = "advanced")
+ @UriParam(defaultValue = "WARN", label = "advanced",
+ description = "Allows to configure the default errorHandler logging level for logging uncaught exceptions.")
private LoggingLevel errorHandlerLoggingLevel = LoggingLevel.WARN;
- @UriParam(defaultValue = "true", label = "advanced")
+ @UriParam(defaultValue = "true", label = "advanced",
+ description = "Allows to control whether stacktraces should be logged or not, by the default errorHandler.")
private boolean errorHandlerLogStackTrace = true;
- @UriParam(label = "consumer", defaultValue = "true")
+ @UriParam(label = "consumer", defaultValue = "true",
+ description = "Specifies whether the consumer container should auto-startup.")
private boolean autoStartup = true;
- @UriParam(label = "consumer,advanced")
+ @UriParam(label = "consumer,advanced",
+ description = "Specifies whether the consumer accept messages while it is stopping."
+ + " You may consider enabling this option, if you start and stop JMS routes at runtime, while there are still messages"
+ + " enqued on the queue. If this option is false, and you stop the JMS route, then messages may be rejected,"
+ + " and the JMS broker would have to attempt redeliveries, which yet again may be rejected, and eventually the message"
+ + " may be moved at a dead letter queue on the JMS broker. To avoid this its recommended to enable this option.")
private boolean acceptMessagesWhileStopping;
- @UriParam
+ @UriParam(description = "Sets the JMS client ID to use. Note that 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."
+ + " If using Apache ActiveMQ you may prefer to use Virtual Topics instead.")
private String clientId;
- @UriParam
+ @UriParam(description = "The durable subscriber name for specifying durable topic subscriptions. The clientId option must be configured as well.")
private String durableSubscriptionName;
@Deprecated
private boolean subscriptionDurable;
- @UriParam(label = "consumer,advanced")
+ @UriParam(label = "consumer,advanced",
+ description = "Specifies whether the listener session should be exposed when consuming messages.")
private boolean exposeListenerSession = true;
private TaskExecutor taskExecutor;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "Specifies whether to inhibit the delivery of messages published by its own connection.")
private boolean pubSubNoLocal;
- @UriParam(defaultValue = "1", label = "consumer")
+ @UriParam(defaultValue = "1", label = "consumer",
+ description = "Specifies the default number of concurrent consumers when consuming from JMS (not for request/reply over JMS)."
+ + " See also the maxMessagesPerTask option to control dynamic scaling up/down of threads."
+ + " When doing request/reply over JMS then the option replyToConcurrentConsumers is used to control number"
+ + " of concurrent consumers on the reply message listener.")
private int concurrentConsumers = 1;
- @UriParam(defaultValue = "1", label = "producer")
+ @UriParam(defaultValue = "1", label = "producer",
+ description = "Specifies the default number of concurrent consumers when doing request/reply over JMS."
+ + " See also the maxMessagesPerTask option to control dynamic scaling up/down of threads.")
private int replyToConcurrentConsumers = 1;
- @UriParam(defaultValue = "-1", label = "advanced")
+ @UriParam(defaultValue = "-1", label = "advanced",
+ description = "The number of messages per task. -1 is unlimited."
+ + " If you use a range for concurrent consumers (eg min < max), then this option can be used to set"
+ + " a value to eg 100 to control how fast the consumers will shrink when less work is required.")
private int maxMessagesPerTask = -1;
private int cacheLevel = -1;
- @UriParam(defaultValue = "CACHE_AUTO", enums = "CACHE_AUTO,CACHE_CONNECTION,CACHE_CONSUMER,CACHE_NONE,CACHE_SESSION", label = "consumer")
+ @UriParam(defaultValue = "CACHE_AUTO", enums = "CACHE_AUTO,CACHE_CONNECTION,CACHE_CONSUMER,CACHE_NONE,CACHE_SESSION", label = "consumer",
+ description = "Sets the cache level by name for the underlying JMS resources."
+ + " Possible values are: CACHE_AUTO, CACHE_CONNECTION, CACHE_CONSUMER, CACHE_NONE, and CACHE_SESSION."
+ + " The default setting is CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more information.")
private String cacheLevelName;
- @UriParam(defaultValue = "5000", label = "advanced")
+ @UriParam(defaultValue = "5000", label = "advanced",
+ description = "Specifies the interval between recovery attempts, i.e. when a connection is being refreshed, in milliseconds."
+ + " The default is 5000 ms, that is, 5 seconds.")
private long recoveryInterval = 5000;
- @UriParam(defaultValue = "1000", label = "advanced")
+ @UriParam(defaultValue = "1000", label = "advanced",
+ description = "The timeout for receiving messages (in milliseconds).")
private long receiveTimeout = 1000;
- @UriParam(defaultValue = "20000", label = "producer")
+ @UriParam(defaultValue = "20000", label = "producer",
+ description = "The timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds)."
+ + " The default is 20 seconds. You can include the header \"CamelJmsRequestTimeout\" to override this endpoint configured"
+ + " timeout value, and thus have per message individual timeout values."
+ + " See also the requestTimeoutCheckerInterval option.")
private long requestTimeout = 20000L;
- @UriParam(defaultValue = "1000", label = "advanced")
+ @UriParam(defaultValue = "1000", label = "advanced",
+ description = "Configures how often Camel should check for timed out Exchanges when doing request/reply over JMS."
+ + " By default Camel checks once per second. But if you must react faster when a timeout occurs,"
+ + " then you can lower this interval, to check more frequently. The timeout is determined by the option requestTimeout.")
private long requestTimeoutCheckerInterval = 1000L;
- @UriParam(defaultValue = "1", label = "advanced")
+ @UriParam(defaultValue = "1", label = "advanced",
+ description = "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"
+ + " (in the case of dynamic scheduling; see the maxConcurrentConsumers setting)."
+ + " There is additional doc available from Spring.")
private int idleTaskExecutionLimit = 1;
- @UriParam(defaultValue = "1", label = "advanced")
+ @UriParam(defaultValue = "1", label = "advanced",
+ description = "Specify the limit for the number of consumers that are allowed to be idle at any given time.")
private int idleConsumerLimit = 1;
- @UriParam(label = "consumer")
+ @UriParam(label = "consumer",
+ description = "Specifies the maximum number of concurrent consumers when consuming from JMS (not for request/reply over JMS)."
+ + " See also the maxMessagesPerTask option to control dynamic scaling up/down of threads."
+ + " When doing request/reply over JMS then the option replyToMaxConcurrentConsumers is used to control number"
+ + " of concurrent consumers on the reply message listener.")
private int maxConcurrentConsumers;
- @UriParam(label = "producer")
+ @UriParam(label = "producer",
+ description = "Specifies the maximum number of concurrent consumers when using request/reply over JMS."
+ + " See also the maxMessagesPerTask option to control dynamic scaling up/down of threads.")
private int replyToMaxConcurrentConsumers;
// JmsTemplate only
- @UriParam(label = "producer", defaultValue = "false")
+ @UriParam(label = "producer", defaultValue = "false",
+ description = "Set if the deliveryMode, priority or timeToLive qualities of service should be used when sending messages."
+ + " This option is based on Spring's JmsTemplate. The deliveryMode, priority and timeToLive options are applied to the current endpoint."
+ + " This contrasts with the preserveMessageQos option, which operates at message granularity,"
+ + " reading QoS properties exclusively from the Camel In message headers.")
private Boolean explicitQosEnabled;
- @UriParam(defaultValue = "true", label = "producer")
+ @UriParam(defaultValue = "true", label = "producer",
+ description = "Specifies whether persistent delivery is used by default.")
private boolean deliveryPersistent = true;
- @UriParam(enums = "1,2", label = "producer")
+ @UriParam(enums = "1,2", label = "producer",
+ description = "Specifies the delivery mode to be used."
+ + " Possibles values are those defined by javax.jms.DeliveryMode."
+ + " NON_PERSISTENT = 1 and PERSISTENT = 2.")
private Integer deliveryMode;
- @UriParam(defaultValue = "true", label = "consumer")
+ @UriParam(defaultValue = "true", label = "consumer",
+ description = "Specifies whether to use persistent delivery by default for replies.")
private boolean replyToDeliveryPersistent = true;
- @UriParam(defaultValue = "-1", label = "producer")
+ @UriParam(defaultValue = "-1", label = "producer",
+ description = "When sending messages, specifies the time-to-live of the message (in milliseconds).")
private long timeToLive = -1;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "To use a custom Spring org.springframework.jms.support.converter.MessageConverter so you can be in control how to map to/from a javax.jms.Message.")
private MessageConverter messageConverter;
- @UriParam(defaultValue = "true", label = "advanced")
+ @UriParam(defaultValue = "true", label = "advanced",
+ description = "Specifies whether Camel should auto map the received JMS message to a suited payload type, such as javax.jms.TextMessage to a String etc.")
private boolean mapJmsMessage = true;
- @UriParam(defaultValue = "true", label = "advanced")
+ @UriParam(defaultValue = "true", label = "advanced",
+ description = "When sending, specifies whether message IDs should be added.")
private boolean messageIdEnabled = true;
- @UriParam(defaultValue = "true", label = "advanced")
+ @UriParam(defaultValue = "true", label = "advanced",
+ description = "Specifies whether timestamps should be enabled by default on sending messages.")
private boolean messageTimestampEnabled = true;
- @UriParam(defaultValue = "" + Message.DEFAULT_PRIORITY, enums = "1,2,3,4,5,6,7,8,9", label = "producer")
+ @UriParam(defaultValue = "" + Message.DEFAULT_PRIORITY, enums = "1,2,3,4,5,6,7,8,9", label = "producer",
+ description = "Values greater than 1 specify the message priority when sending (where 0 is the lowest priority and 9 is the highest)."
+ + " The explicitQosEnabled option must also be enabled in order for this option to have any effect.")
private int priority = Message.DEFAULT_PRIORITY;
// Transaction related configuration
- @UriParam(label = "transaction")
+ @UriParam(label = "transaction",
+ description = "Specifies whether to use transacted mode")
private boolean transacted;
+ @Deprecated
private boolean transactedInOut;
- @UriParam(defaultValue = "true", label = "transaction,advanced")
+ @UriParam(defaultValue = "true", label = "transaction,advanced",
+ description = "If true, Camel will create a JmsTransactionManager, if there is no transactionManager injected when option transacted=true.")
private boolean lazyCreateTransactionManager = true;
+ @UriParam(label = "transaction,advanced",
+ description = "The Spring transaction manager to use.")
private PlatformTransactionManager transactionManager;
- @UriParam(label = "transaction,advanced")
+ @UriParam(label = "transaction,advanced",
+ description = "The name of the transaction to use.")
private String transactionName;
- @UriParam(defaultValue = "-1", label = "transaction,advanced")
+ @UriParam(defaultValue = "-1", label = "transaction,advanced",
+ description = "The timeout value of the transaction (in seconds), if using transacted mode.")
private int transactionTimeout = -1;
- @UriParam(label = "producer")
+ @UriParam(label = "producer",
+ description = "Set to true, 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. You can provide all or only some of them. If not provided, Camel will fall back to use the"
+ + " values from the endpoint instead. So, when using this option, the headers override the values from the endpoint."
+ + " The explicitQosEnabled option, by contrast, will only use options set on the endpoint, and not values from the message header.")
private boolean preserveMessageQos;
- @UriParam
+ @UriParam(description = "If true, a producer will behave like a InOnly exchange with the exception that JMSReplyTo header is sent out and"
+ + " not be suppressed like in the case of InOnly. Like InOnly the producer will not wait for a reply."
+ + " A consumer with this flag will behave like InOnly. This feature can be used to bridge InOut requests to"
+ + " another queue so that a route on the other queue will send it´s response directly back to the original JMSReplyTo.")
private boolean disableReplyTo;
- @UriParam(label = "consumer,advanced")
+ @UriParam(label = "consumer,advanced",
+ description = "Enables eager loading of JMS properties as soon as a message is loaded"
+ + " which generally is inefficient as the JMS properties may not be required"
+ + " but sometimes can catch early any issues with the underlying JMS provider"
+ + " and the use of JMS properties")
private boolean eagerLoadingOfProperties;
// Always make a JMS message copy when it's passed to Producer
- @UriParam(label = "producer,advanced")
+ @UriParam(label = "producer,advanced",
+ description = "If true, Camel will always make a JMS message copy of the message when it is passed to the producer for sending."
+ + " Copying the message is needed in some situations, such as when a replyToDestinationSelectorName is set"
+ + " (incidentally, Camel will set the alwaysCopyMessage option to true, if a replyToDestinationSelectorName is set)")
private boolean alwaysCopyMessage;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages.")
private boolean useMessageIDAsCorrelationID;
private JmsProviderMetadata providerMetadata = new JmsProviderMetadata();
private JmsOperations metadataJmsOperations;
- @UriParam(label = "consumer")
+ @UriParam(label = "consumer",
+ description = "Provides an explicit ReplyTo destination, which overrides any incoming value of Message.getJMSReplyTo().")
private String replyTo;
- @UriParam(label = "producer,advanced")
+ @UriParam(label = "producer,advanced",
+ description = "Sets 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).")
private String replyToDestinationSelectorName;
- @UriParam(label = "producer")
+ @UriParam(label = "producer",
+ description = "Provides an explicit ReplyTo destination in the JMS message, which overrides the setting of replyTo."
+ + " It is useful if you want to forward the message to a remote Queue and receive the reply message from the ReplyTo destination.")
private String replyToOverride;
- @UriParam(label = "consumer,advanced")
+ @UriParam(label = "consumer,advanced",
+ description = "Whether a JMS consumer is allowed to send a reply message to the same destination that the consumer is using to"
+ + " consume from. This prevents an endless loop by consuming and sending back the same message to itself.")
private boolean replyToSameDestinationAllowed;
- @UriParam(enums = "Bytes,Map,Object,Stream,Text")
+ @UriParam(enums = "Bytes,Map,Object,Stream,Text",
+ description = "Allows you to force the use of a specific javax.jms.Message implementation for sending JMS messages."
+ + " Possible values are: Bytes, Map, Object, Stream, Text."
+ + " By default, Camel would determine which JMS message type to use from the In body type. This option allows you to specify it.")
private JmsMessageType jmsMessageType;
- @UriParam(label = "advanced", enums = "default,passthrough", javaType = "java.lang.String")
+ @UriParam(label = "advanced", enums = "default,passthrough", javaType = "java.lang.String",
+ description = "Pluggable strategy for encoding and decoding JMS keys so they can be compliant with the JMS specification."
+ + " Camel provides two implementations out of the box: default and passthrough."
+ + " The default strategy will safely marshal dots and hyphens (. and -). The passthrough strategy leaves the key as is."
+ + " Can be used for JMS brokers which do not care whether JMS header keys contain illegal characters."
+ + " You can provide your own implementation of the org.apache.camel.component.jms.JmsKeyFormatStrategy"
+ + " and refer to it using the # notation.")
private JmsKeyFormatStrategy jmsKeyFormatStrategy;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "You can transfer the exchange 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."
+ + " This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level."
+ + " You must enable this option on both the producer and consumer side, so Camel knows the payloads is an Exchange and not a regular payload.")
private boolean transferExchange;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "If enabled and you are using Request Reply messaging (InOut) and an Exchange failed on the consumer side,"
+ + " then the caused Exception will be send back in response as a javax.jms.ObjectMessage."
+ + " If the client is Camel, the returned Exception is rethrown. This allows you to use Camel JMS as a bridge"
+ + " in your routing - for example, using persistent queues to enable robust routing."
+ + " Notice that if you also have transferExchange enabled, this option takes precedence."
+ + " The caught exception is required to be serializable."
+ + " The original Exception on the consumer side can be wrapped in an outer exception"
+ + " such as org.apache.camel.RuntimeCamelException when returned to the producer.")
private boolean transferException;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "If enabled and you are using Request Reply messaging (InOut) and an Exchange failed with a SOAP fault (not exception) on the consumer side,"
+ + " then the fault flag on Message#isFault() will be send back in the response as a JMS header with the key JmsConstants#JMS_TRANSFER_FAULT."
+ + " If the client is Camel, the returned fault flag will be set on the {@link org.apache.camel.Message#setFault(boolean)}."
+ + " You may want to enable this when using Camel components that support faults such as SOAP based such as cxf or spring-ws.")
private boolean transferFault;
- @UriParam
+ @UriParam(description = "Specifies whether to test the connection on startup."
+ + " This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker."
+ + " If a connection cannot be granted then Camel throws an exception on startup."
+ + " This ensures that Camel is not started with failed connections."
+ + " The JMS producers is tested as well.")
private boolean testConnectionOnStartup;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "Whether to startup the JmsConsumer message listener asynchronously, when starting a route."
+ + " For example if a JmsConsumer cannot get a connection to a remote JMS broker, then it may block while retrying"
+ + " and/or failover. This will cause Camel to block while starting routes. By setting this option to true,"
+ + " you will let routes startup, while the JmsConsumer connects to the JMS broker using a dedicated thread"
+ + " in asynchronous mode. If this option is used, then beware that if the connection could not be established,"
+ + " then an exception is logged at WARN level, and the consumer will not be able to receive messages;"
+ + " You can then restart the route to retry.")
private boolean asyncStartListener;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "Whether to stop the JmsConsumer message listener asynchronously, when stopping a route.")
private boolean asyncStopListener;
// if the message is a JmsMessage and mapJmsMessage=false, force the
// producer to send the javax.jms.Message body to the next JMS destination
- @UriParam(label = "producer,advanced")
+ @UriParam(label = "producer,advanced",
+ description = "When using mapJmsMessage=false Camel will create a new JMS message to send to a new JMS destination"
+ + " if you touch the headers (get or set) during the route. Set this option to true to force Camel to send"
+ + " the original JMS message that was received.")
private boolean forceSendOriginalMessage;
// to force disabling time to live (works in both in-only or in-out mode)
- @UriParam(label = "producer,advanced")
+ @UriParam(label = "producer,advanced",
+ description = "Use this option to force disabling time to live."
+ + " For example when you do request/reply over JMS, then Camel will by default use the requestTimeout value"
+ + " as time to live on the message being sent. The problem is that the sender and receiver systems have"
+ + " to have their clocks synchronized, so they are in sync. This is not always so easy to archive."
+ + " So you can use disableTimeToLive=true to not set a time to live value on the sent message."
+ + " Then the message will not expire on the receiver system. See below in section About time to live for more details.")
private boolean disableTimeToLive;
- @UriParam(label = "producer")
+ @UriParam(label = "producer",
+ description = "Allows for explicitly specifying which kind of strategy to use for replyTo queues when doing request/reply over JMS."
+ + " Possible values are: Temporary, Shared, or Exclusive."
+ + " By default Camel will use temporary queues. However if replyTo has been configured, then Shared is used by default."
+ + " This option allows you to use exclusive queues instead of shared ones."
+ + " See Camel JMS documentation for more details, and especially the notes about the implications if running in a clustered environment,"
+ + " and the fact that Shared reply queues has lower performance than its alternatives Temporary and Exclusive.")
private ReplyToType replyToType;
- @UriParam(label = "consumer")
+ @UriParam(label = "consumer",
+ description = "Whether the JmsConsumer processes the Exchange asynchronously."
+ + " If enabled then the JmsConsumer may pickup the next message from the JMS queue,"
+ + " while the previous message is being processed asynchronously (by the Asynchronous Routing Engine)."
+ + " This means that messages may be processed not 100% strictly in order. If disabled (as default)"
+ + " then the Exchange is fully processed before the JmsConsumer will pickup the next message from the JMS queue."
+ + " Note if transacted has been enabled, then asyncConsumer=true does not run asynchronously, as transaction"
+ + " must be executed synchronously (Camel 3.0 may support async transactions).")
private boolean asyncConsumer;
// the cacheLevelName of reply manager
- @UriParam(label = "producer,advanced")
+ @UriParam(label = "producer,advanced",
+ description = "Sets the cache level by name for the reply consumer when doing request/reply over JMS."
+ + " This option only applies when using fixed reply queues (not temporary)."
+ + " Camel will by default use: CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName."
+ + " And CACHE_SESSION for shared without replyToSelectorName. Some JMS brokers such as IBM WebSphere"
+ + " may require to set the replyToCacheLevelName=CACHE_NONE to work."
+ + " Note: If using temporary queues then CACHE_NONE is not allowed,"
+ + " and you must use a higher value such as CACHE_CONSUMER or CACHE_SESSION.")
private String replyToCacheLevelName;
- @UriParam(defaultValue = "true", label = "producer,advanced")
+ @UriParam(defaultValue = "true", label = "producer,advanced",
+ description = "Whether to allow sending messages with no body. If this option is false and the message body is null, then an JMSException is thrown.")
private boolean allowNullBody = true;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "Registry ID of the MessageListenerContainerFactory used to determine what"
+ + " org.springframework.jms.listener.AbstractMessageListenerContainer to use to consume messages."
+ + " Setting this will automatically set consumerType to Custom.")
private MessageListenerContainerFactory messageListenerContainerFactory;
- @UriParam(label = "producer,advanced")
+ @UriParam(label = "producer,advanced",
+ description = "Only applicable when sending to JMS destination using InOnly (eg fire and forget)."
+ + " Enabling this option will enrich the Camel Exchange with the actual JMSMessageID"
+ + " that was used by the JMS client when the message was sent to the JMS destination.")
private boolean includeSentJMSMessageID;
- @UriParam(label = "consumer,advanced")
+ @UriParam(label = "consumer,advanced",
+ description = "Specifies what default TaskExecutor type to use in the DefaultMessageListenerContainer,"
+ + " for both consumer endpoints and the ReplyTo consumer of producer endpoints."
+ + " Possible values: SimpleAsync (uses Spring's SimpleAsyncTaskExecutor) or ThreadPool"
+ + " (uses Spring's ThreadPoolTaskExecutor with optimal values - cached threadpool-like)."
+ + " If not set, it defaults to the previous behaviour, which uses a cached thread pool"
+ + " for consumer endpoints and SimpleAsync for reply consumers."
+ + " The use of ThreadPool is recommended to reduce thread trash in elastic configurations"
+ + " with dynamically increasing and decreasing concurrent consumers.")
private DefaultTaskExecutorType defaultTaskExecutorType;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "Whether to include all JMSXxxx properties when mapping from JMS to Camel Message."
+ + " Setting this to true will include properties such as JMSXAppID, and JMSXUserID etc."
+ + " Note: If you are using a custom headerFilterStrategy then this option does not apply.")
private boolean includeAllJMSXProperties;
- @UriParam(label = "advanced")
+ @UriParam(label = "advanced",
+ description = "To use the given MessageCreatedStrategy which are invoked when Camel creates new instances of javax.jms.Message objects when Camel is sending a JMS message.")
private MessageCreatedStrategy messageCreatedStrategy;
public JmsConfiguration() {
@@ -540,7 +728,7 @@ public class JmsConfiguration implements Cloneable {
/**
* Sets the connection factory to be used for sending messages via the
- * {@link JmsTemplate} via {@link #createInOnlyTemplate(JmsEndpoint,boolean, String)}
+ * {@link JmsTemplate} via {@link #createInOnlyTemplate(JmsEndpoint, boolean, String)}
*/
public void setTemplateConnectionFactory(ConnectionFactory templateConnectionFactory) {
this.templateConnectionFactory = templateConnectionFactory;
@@ -579,7 +767,7 @@ public class JmsConfiguration implements Cloneable {
/**
* Sets the JMS client ID to use. Note that 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.
- * <p/>
+ * <p>
* If using Apache ActiveMQ you may prefer to use Virtual Topics instead.
*/
public void setClientId(String consumerClientId) {
@@ -706,7 +894,7 @@ public class JmsConfiguration implements Cloneable {
/**
* Specifies the default number of concurrent consumers when consuming from JMS (not for request/reply over JMS).
* See also the maxMessagesPerTask option to control dynamic scaling up/down of threads.
- * <p/>
+ * <p>
* When doing request/reply over JMS then the option replyToConcurrentConsumers is used to control number
* of concurrent consumers on the reply message listener.
*/
@@ -854,7 +1042,7 @@ public class JmsConfiguration implements Cloneable {
/**
* Specifies the maximum number of concurrent consumers when consuming from JMS (not for request/reply over JMS).
* See also the maxMessagesPerTask option to control dynamic scaling up/down of threads.
- * <p/>
+ * <p>
* When doing request/reply over JMS then the option replyToMaxConcurrentConsumers is used to control number
* of concurrent consumers on the reply message listener.
*/
@@ -905,7 +1093,7 @@ public class JmsConfiguration implements Cloneable {
}
/**
- * Specifies the delivery mode to be used. Possible values are
+ * Specifies the delivery mode to be used.
* Possibles values are those defined by javax.jms.DeliveryMode.
* NON_PERSISTENT = 1 and PERSISTENT = 2.
*/
@@ -955,7 +1143,6 @@ public class JmsConfiguration implements Cloneable {
/**
* Specifies whether Camel should auto map the received JMS message to a suited payload type, such as javax.jms.TextMessage to a String etc.
- * See section about how mapping works below for more details.
*/
public void setMapJmsMessage(boolean mapJmsMessage) {
this.mapJmsMessage = mapJmsMessage;
@@ -1023,7 +1210,7 @@ public class JmsConfiguration implements Cloneable {
/**
* Should InOut operations (request reply) default to using transacted mode?
- * <p/>
+ * <p>
* By default this is false as you need to commit the outgoing request before you can consume the input
*/
@Deprecated
@@ -1297,7 +1484,7 @@ public class JmsConfiguration implements Cloneable {
/**
* Defaults the JMS cache level if none is explicitly specified.
- * <p/>
+ * <p>
* Will return <tt>CACHE_AUTO</tt> which will pickup and use <tt>CACHE_NONE</tt>
* if transacted has been enabled, otherwise it will use <tt>CACHE_CONSUMER</tt>
* which is the most efficient.
@@ -1549,7 +1736,7 @@ public class JmsConfiguration implements Cloneable {
* then the fault flag on {@link org.apache.camel.Message#isFault()} will be send back in the response as a JMS header with the key
* {@link JmsConstants#JMS_TRANSFER_FAULT}.
* If the client is Camel, the returned fault flag will be set on the {@link org.apache.camel.Message#setFault(boolean)}.
- * <p/>
+ * <p>
* You may want to enable this when using Camel components that support faults such as SOAP based such as cxf or spring-ws.
*/
public void setTransferFault(boolean transferFault) {