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/f1bd0be5 Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/f1bd0be5 Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/f1bd0be5 Branch: refs/heads/camel-2.16.x Commit: f1bd0be5ec9681fc58fa3d422c72d61f11e62ddc Parents: 2200e51 Author: Claus Ibsen <davscl...@apache.org> Authored: Sat Jan 16 13:52:21 2016 +0100 Committer: Claus Ibsen <davscl...@apache.org> Committed: Sat Jan 16 13:55:04 2016 +0100 ---------------------------------------------------------------------- .../camel/component/jms/JmsConfiguration.java | 329 +++++++++++++++---- 1 file changed, 256 insertions(+), 73 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/camel/blob/f1bd0be5/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 510765b..c3e2877 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,151 +68,335 @@ 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 + @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() { @@ -538,7 +722,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; @@ -577,7 +761,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) { @@ -704,7 +888,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. */ @@ -852,7 +1036,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. */ @@ -903,7 +1087,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. */ @@ -953,7 +1137,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; @@ -1021,7 +1204,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 @@ -1295,7 +1478,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.
