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 2015/05/18 11:46:10 UTC
[3/3] camel git commit: Component docs
Component docs
Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/af50c9df
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/af50c9df
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/af50c9df
Branch: refs/heads/master
Commit: af50c9dfadc50750ba9173a01a1ace438e234e19
Parents: a1dfcd2
Author: Claus Ibsen <da...@apache.org>
Authored: Mon May 18 11:50:12 2015 +0200
Committer: Claus Ibsen <da...@apache.org>
Committed: Mon May 18 11:50:28 2015 +0200
----------------------------------------------------------------------
.../camel/component/jms/JmsComponent.java | 317 ++++++++++++++++++-
1 file changed, 314 insertions(+), 3 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/camel/blob/af50c9df/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsComponent.java
----------------------------------------------------------------------
diff --git a/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsComponent.java b/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsComponent.java
index 3baeba9..e13eecb 100644
--- a/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsComponent.java
+++ b/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsComponent.java
@@ -158,263 +158,565 @@ public class JmsComponent extends UriEndpointComponent implements ApplicationCon
}
/**
- * Sets the JMS configuration
- *
- * @param configuration the configuration to use by default for endpoints
+ * To use a shared JMS configuration
*/
public void setConfiguration(JmsConfiguration configuration) {
this.configuration = configuration;
}
+ /**
+ * 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.
+ */
public void setAcceptMessagesWhileStopping(boolean acceptMessagesWhileStopping) {
getConfiguration().setAcceptMessagesWhileStopping(acceptMessagesWhileStopping);
}
+ /**
+ * The JMS acknowledgement mode defined as an Integer.
+ * Allows you to set vendor-specific extensions to the acknowledgment mode.
+ * For the regular modes, it is preferable to use the acknowledgementModeName instead.
+ */
public void setAcknowledgementMode(int consumerAcknowledgementMode) {
getConfiguration().setAcknowledgementMode(consumerAcknowledgementMode);
}
+ /**
+ * 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
+ */
public void setEagerLoadingOfProperties(boolean eagerLoadingOfProperties) {
getConfiguration().setEagerLoadingOfProperties(eagerLoadingOfProperties);
}
+ /**
+ * The JMS acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE
+ */
public void setAcknowledgementModeName(String consumerAcknowledgementMode) {
getConfiguration().setAcknowledgementModeName(consumerAcknowledgementMode);
}
+ /**
+ * Specifies whether the consumer container should auto-startup.
+ */
public void setAutoStartup(boolean autoStartup) {
getConfiguration().setAutoStartup(autoStartup);
}
+ /**
+ * Sets the cache level by ID for the underlying JMS resources. See cacheLevelName option for more details.
+ */
public void setCacheLevel(int cacheLevel) {
getConfiguration().setCacheLevel(cacheLevel);
}
+ /**
+ * 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.
+ */
public void setCacheLevelName(String cacheName) {
getConfiguration().setCacheLevelName(cacheName);
}
+ /**
+ * 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.
+ */
public void setReplyToCacheLevelName(String cacheName) {
getConfiguration().setReplyToCacheLevelName(cacheName);
}
+ /**
+ * 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/>
+ * If using Apache ActiveMQ you may prefer to use Virtual Topics instead.
+ */
public void setClientId(String consumerClientId) {
getConfiguration().setClientId(consumerClientId);
}
+ /**
+ * 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/>
+ * When doing request/reply over JMS then the option replyToConcurrentConsumers is used to control number
+ * of concurrent consumers on the reply message listener.
+ */
public void setConcurrentConsumers(int concurrentConsumers) {
getConfiguration().setConcurrentConsumers(concurrentConsumers);
}
+ /**
+ * 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.
+ */
public void setReplyToConcurrentConsumers(int concurrentConsumers) {
getConfiguration().setReplyToConcurrentConsumers(concurrentConsumers);
}
+ /**
+ * Sets the default connection factory to be use
+ */
public void setConnectionFactory(ConnectionFactory connectionFactory) {
getConfiguration().setConnectionFactory(connectionFactory);
}
+ /**
+ * Specifies whether persistent delivery is used by default.
+ */
public void setDeliveryPersistent(boolean deliveryPersistent) {
getConfiguration().setDeliveryPersistent(deliveryPersistent);
}
+ /**
+ * Specifies the delivery mode to be used. Possible values are
+ * Possibles values are those defined by javax.jms.DeliveryMode.
+ * NON_PERSISTENT = 1 and PERSISTENT = 2.
+ */
public void setDeliveryMode(Integer deliveryMode) {
getConfiguration().setDeliveryMode(deliveryMode);
}
+ /**
+ * The durable subscriber name for specifying durable topic subscriptions. The clientId option must be configured as well.
+ */
public void setDurableSubscriptionName(String durableSubscriptionName) {
getConfiguration().setDurableSubscriptionName(durableSubscriptionName);
}
+ /**
+ * Specifies the JMS Exception Listener that is to be notified of any underlying JMS exceptions.
+ */
public void setExceptionListener(ExceptionListener exceptionListener) {
getConfiguration().setExceptionListener(exceptionListener);
}
+ /**
+ * 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.
+ */
public void setErrorHandler(ErrorHandler errorHandler) {
getConfiguration().setErrorHandler(errorHandler);
}
+ /**
+ * Allows to configure the default errorHandler logging level for logging uncaught exceptions.
+ */
public void setErrorHandlerLoggingLevel(LoggingLevel errorHandlerLoggingLevel) {
getConfiguration().setErrorHandlerLoggingLevel(errorHandlerLoggingLevel);
}
+ /**
+ * Allows to control whether stacktraces should be logged or not, by the default errorHandler.
+ */
public void setErrorHandlerLogStackTrace(boolean errorHandlerLogStackTrace) {
getConfiguration().setErrorHandlerLogStackTrace(errorHandlerLogStackTrace);
}
+ /**
+ * 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.
+ */
public void setExplicitQosEnabled(boolean explicitQosEnabled) {
getConfiguration().setExplicitQosEnabled(explicitQosEnabled);
}
+ /**
+ * Specifies whether the listener session should be exposed when consuming messages.
+ */
public void setExposeListenerSession(boolean exposeListenerSession) {
getConfiguration().setExposeListenerSession(exposeListenerSession);
}
+ /**
+ * 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.
+ */
public void setIdleTaskExecutionLimit(int idleTaskExecutionLimit) {
getConfiguration().setIdleTaskExecutionLimit(idleTaskExecutionLimit);
}
+ /**
+ * Specify the limit for the number of consumers that are allowed to be idle at any given time.
+ */
public void setIdleConsumerLimit(int idleConsumerLimit) {
getConfiguration().setIdleConsumerLimit(idleConsumerLimit);
}
+ /**
+ * 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/>
+ * When doing request/reply over JMS then the option replyToMaxConcurrentConsumers is used to control number
+ * of concurrent consumers on the reply message listener.
+ */
public void setMaxConcurrentConsumers(int maxConcurrentConsumers) {
getConfiguration().setMaxConcurrentConsumers(maxConcurrentConsumers);
}
+ /**
+ * 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.
+ */
public void setReplyToMaxConcurrentConsumers(int maxConcurrentConsumers) {
getConfiguration().setReplyToMaxConcurrentConsumers(maxConcurrentConsumers);
}
+ /**
+ * 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.
+ */
public void setMaxMessagesPerTask(int maxMessagesPerTask) {
getConfiguration().setMaxMessagesPerTask(maxMessagesPerTask);
}
+ /**
+ * 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.
+ */
public void setMessageConverter(MessageConverter messageConverter) {
getConfiguration().setMessageConverter(messageConverter);
}
+ /**
+ * 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) {
getConfiguration().setMapJmsMessage(mapJmsMessage);
}
+ /**
+ * When sending, specifies whether message IDs should be added.
+ */
public void setMessageIdEnabled(boolean messageIdEnabled) {
getConfiguration().setMessageIdEnabled(messageIdEnabled);
}
+ /**
+ * Specifies whether timestamps should be enabled by default on sending messages.
+ */
public void setMessageTimestampEnabled(boolean messageTimestampEnabled) {
getConfiguration().setMessageTimestampEnabled(messageTimestampEnabled);
}
+ /**
+ * 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)
+ */
public void setAlwaysCopyMessage(boolean alwaysCopyMessage) {
getConfiguration().setAlwaysCopyMessage(alwaysCopyMessage);
}
+ /**
+ * Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages.
+ */
public void setUseMessageIDAsCorrelationID(boolean useMessageIDAsCorrelationID) {
getConfiguration().setUseMessageIDAsCorrelationID(useMessageIDAsCorrelationID);
}
+ /**
+ * 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.
+ */
public void setPriority(int priority) {
getConfiguration().setPriority(priority);
}
+ /**
+ * Specifies whether to inhibit the delivery of messages published by its own connection.
+ */
public void setPubSubNoLocal(boolean pubSubNoLocal) {
getConfiguration().setPubSubNoLocal(pubSubNoLocal);
}
+ /**
+ * The timeout for receiving messages (in milliseconds).
+ */
public void setReceiveTimeout(long receiveTimeout) {
getConfiguration().setReceiveTimeout(receiveTimeout);
}
+ /**
+ * 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.
+ */
public void setRecoveryInterval(long recoveryInterval) {
getConfiguration().setRecoveryInterval(recoveryInterval);
}
+ /**
+ * Deprecated: Enabled by default, if you specify a durableSubscriptionName and a clientId.
+ */
@Deprecated
public void setSubscriptionDurable(boolean subscriptionDurable) {
getConfiguration().setSubscriptionDurable(subscriptionDurable);
}
+ /**
+ * Allows you to specify a custom task executor for consuming messages.
+ */
public void setTaskExecutor(TaskExecutor taskExecutor) {
getConfiguration().setTaskExecutor(taskExecutor);
}
+ /**
+ * When sending messages, specifies the time-to-live of the message (in milliseconds).
+ */
public void setTimeToLive(long timeToLive) {
getConfiguration().setTimeToLive(timeToLive);
}
+ /**
+ * Specifies whether to use transacted mode
+ */
public void setTransacted(boolean consumerTransacted) {
getConfiguration().setTransacted(consumerTransacted);
}
+ /**
+ * If true, Camel will create a JmsTransactionManager, if there is no transactionManager injected when option transacted=true.
+ */
public void setLazyCreateTransactionManager(boolean lazyCreating) {
getConfiguration().setLazyCreateTransactionManager(lazyCreating);
}
+ /**
+ * The Spring transaction manager to use.
+ */
public void setTransactionManager(PlatformTransactionManager transactionManager) {
getConfiguration().setTransactionManager(transactionManager);
}
+ /**
+ * The name of the transaction to use.
+ */
public void setTransactionName(String transactionName) {
getConfiguration().setTransactionName(transactionName);
}
+ /**
+ * The timeout value of the transaction (in seconds), if using transacted mode.
+ */
public void setTransactionTimeout(int transactionTimeout) {
getConfiguration().setTransactionTimeout(transactionTimeout);
}
+ /**
+ * 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.
+ */
public void setTestConnectionOnStartup(boolean testConnectionOnStartup) {
getConfiguration().setTestConnectionOnStartup(testConnectionOnStartup);
}
+ /**
+ * 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.
+ */
public void setAsyncStartListener(boolean asyncStartListener) {
getConfiguration().setAsyncStartListener(asyncStartListener);
}
+ /**
+ * Whether to stop the JmsConsumer message listener asynchronously, when stopping a route.
+ */
public void setAsyncStopListener(boolean asyncStopListener) {
getConfiguration().setAsyncStopListener(asyncStopListener);
}
+ /**
+ * 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.
+ */
public void setForceSendOriginalMessage(boolean forceSendOriginalMessage) {
getConfiguration().setForceSendOriginalMessage(forceSendOriginalMessage);
}
+ /**
+ * 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.
+ */
public void setRequestTimeout(long requestTimeout) {
getConfiguration().setRequestTimeout(requestTimeout);
}
+ /**
+ * 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.
+ */
public void setRequestTimeoutCheckerInterval(long requestTimeoutCheckerInterval) {
getConfiguration().setRequestTimeoutCheckerInterval(requestTimeoutCheckerInterval);
}
+ /**
+ * 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.
+ */
public void setTransferExchange(boolean transferExchange) {
getConfiguration().setTransferExchange(transferExchange);
}
+ /**
+ * 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.
+ */
public void setTransferException(boolean transferException) {
getConfiguration().setTransferException(transferException);
}
+ /**
+ * Allows you to use your own implementation of the org.springframework.jms.core.JmsOperations interface.
+ * Camel uses JmsTemplate as default. Can be used for testing purpose, but not used much as stated in the spring API docs.
+ */
public void setJmsOperations(JmsOperations jmsOperations) {
getConfiguration().setJmsOperations(jmsOperations);
}
+ /**
+ * A pluggable org.springframework.jms.support.destination.DestinationResolver that allows you to use your own resolver
+ * (for example, to lookup the real destination in a JNDI registry).
+ */
public void setDestinationResolver(DestinationResolver destinationResolver) {
getConfiguration().setDestinationResolver(destinationResolver);
}
+ /**
+ * 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.
+ */
public void setReplyToType(ReplyToType replyToType) {
getConfiguration().setReplyToType(replyToType);
}
+ /**
+ * 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.
+ */
public void setPreserveMessageQos(boolean preserveMessageQos) {
getConfiguration().setPreserveMessageQos(preserveMessageQos);
}
+ /**
+ * 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).
+ */
public void setAsyncConsumer(boolean asyncConsumer) {
getConfiguration().setAsyncConsumer(asyncConsumer);
}
+ /**
+ * Whether to allow sending messages with no body. If this option is false and the message body is null, then an JMSException is thrown.
+ */
public void setAllowNullBody(boolean allowNullBody) {
getConfiguration().setAllowNullBody(allowNullBody);
}
+ /**
+ * 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.
+ */
public void setIncludeSentJMSMessageID(boolean includeSentJMSMessageID) {
getConfiguration().setIncludeSentJMSMessageID(includeSentJMSMessageID);
}
+ /**
+ * 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.
+ */
public void setIncludeAllJMSXProperties(boolean includeAllJMSXProperties) {
getConfiguration().setIncludeAllJMSXProperties(includeAllJMSXProperties);
}
+ /**
+ * 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.
+ */
public void setDefaultTaskExecutorType(DefaultTaskExecutorType type) {
getConfiguration().setDefaultTaskExecutorType(type);
}
+ /**
+ * 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.
+ */
public void setJmsKeyFormatStrategy(JmsKeyFormatStrategy jmsKeyFormatStrategy) {
getConfiguration().setJmsKeyFormatStrategy(jmsKeyFormatStrategy);
}
+ /**
+ * 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.
+ */
public void setJmsKeyFormatStrategy(String jmsKeyFormatStrategyName) {
// allow to configure a standard by its name, which is simpler
JmsKeyFormatStrategy strategy = resolveStandardJmsKeyFormatStrategy(jmsKeyFormatStrategyName);
@@ -425,6 +727,9 @@ public class JmsComponent extends UriEndpointComponent implements ApplicationCon
}
}
+ /**
+ * Sets the Spring ApplicationContext to use
+ */
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
@@ -436,6 +741,9 @@ public class JmsComponent extends UriEndpointComponent implements ApplicationCon
return queueBrowseStrategy;
}
+ /**
+ * To use a custom QueueBrowseStrategy when browsing queues
+ */
public void setQueueBrowseStrategy(QueueBrowseStrategy queueBrowseStrategy) {
this.queueBrowseStrategy = queueBrowseStrategy;
}
@@ -444,6 +752,9 @@ public class JmsComponent extends UriEndpointComponent implements ApplicationCon
return headerFilterStrategy;
}
+ /**
+ * To use a custom HeaderFilterStrategy to filter header to and from Camel message.
+ */
public void setHeaderFilterStrategy(HeaderFilterStrategy strategy) {
this.headerFilterStrategy = strategy;
}