http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-jms-starter/src/main/java/org/apache/camel/component/jms/springboot/JmsComponentConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-jms-starter/src/main/java/org/apache/camel/component/jms/springboot/JmsComponentConfiguration.java b/components-starter/camel-jms-starter/src/main/java/org/apache/camel/component/jms/springboot/JmsComponentConfiguration.java index 504de2d..5bddc33 100644 --- a/components-starter/camel-jms-starter/src/main/java/org/apache/camel/component/jms/springboot/JmsComponentConfiguration.java +++ b/components-starter/camel-jms-starter/src/main/java/org/apache/camel/component/jms/springboot/JmsComponentConfiguration.java @@ -19,15 +19,20 @@ package org.apache.camel.component.jms.springboot; import javax.jms.ConnectionFactory; import javax.jms.ExceptionListener; import org.apache.camel.LoggingLevel; +import org.apache.camel.component.jms.ConsumerType; import org.apache.camel.component.jms.DefaultTaskExecutorType; -import org.apache.camel.component.jms.JmsConfiguration; +import org.apache.camel.component.jms.JmsComponent; import org.apache.camel.component.jms.JmsKeyFormatStrategy; +import org.apache.camel.component.jms.JmsMessageType; +import org.apache.camel.component.jms.JmsProviderMetadata; import org.apache.camel.component.jms.MessageCreatedStrategy; +import org.apache.camel.component.jms.MessageListenerContainerFactory; import org.apache.camel.component.jms.QueueBrowseStrategy; import org.apache.camel.component.jms.ReplyToType; import org.apache.camel.spi.HeaderFilterStrategy; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.DeprecatedConfigurationProperty; +import org.springframework.boot.context.properties.NestedConfigurationProperty; import org.springframework.context.ApplicationContext; import org.springframework.core.task.TaskExecutor; import org.springframework.jms.core.JmsOperations; @@ -48,7 +53,7 @@ public class JmsComponentConfiguration { /** * To use a shared JMS configuration */ - private JmsConfiguration configuration; + private JmsConfigurationNestedConfiguration 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 @@ -179,6 +184,7 @@ public class JmsComponentConfiguration { * errorHandlerLogStackTrace options. This makes it much easier to configure * than having to code a custom errorHandler. */ + @NestedConfigurationProperty private ErrorHandler errorHandler; /** * Allows to configure the default errorHandler logging level for logging @@ -249,6 +255,7 @@ public class JmsComponentConfiguration { * org.springframework.jms.support.converter.MessageConverter so you can be * in control how to map to/from a javax.jms.Message. */ + @NestedConfigurationProperty private MessageConverter messageConverter; /** * Specifies whether Camel should auto map the received JMS message to a @@ -292,13 +299,13 @@ public class JmsComponentConfiguration { /** * The timeout for receiving messages (in milliseconds). */ - private long receiveTimeout; + private Long 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. */ - private long recoveryInterval; + private Long recoveryInterval; /** * Deprecated: Enabled by default if you specify a durableSubscriptionName * and a clientId. @@ -308,12 +315,13 @@ public class JmsComponentConfiguration { /** * Allows you to specify a custom task executor for consuming messages. */ + @NestedConfigurationProperty private TaskExecutor taskExecutor; /** * When sending messages specifies the time-to-live of the message (in * milliseconds). */ - private long timeToLive; + private Long timeToLive; /** * Specifies whether to use transacted mode */ @@ -326,6 +334,7 @@ public class JmsComponentConfiguration { /** * The Spring transaction manager to use. */ + @NestedConfigurationProperty private PlatformTransactionManager transactionManager; /** * The name of the transaction to use. @@ -376,7 +385,7 @@ public class JmsComponentConfiguration { * and thus have per message individual timeout values. See also the * requestTimeoutCheckerInterval option. */ - private long requestTimeout; + private Long requestTimeout; /** * Configures how often Camel should check for timed out Exchanges when * doing request/reply over JMS. By default Camel checks once per second. @@ -384,7 +393,7 @@ public class JmsComponentConfiguration { * this interval to check more frequently. The timeout is determined by the * option requestTimeout. */ - private long requestTimeoutCheckerInterval; + private Long 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 @@ -425,6 +434,7 @@ public class JmsComponentConfiguration { * JmsTemplate as default. Can be used for testing purpose but not used much * as stated in the spring API docs. */ + @NestedConfigurationProperty private JmsOperations jmsOperations; /** * A pluggable @@ -432,6 +442,7 @@ public class JmsComponentConfiguration { * allows you to use your own resolver (for example to lookup the real * destination in a JNDI registry). */ + @NestedConfigurationProperty private DestinationResolver destinationResolver; /** * Allows for explicitly specifying which kind of strategy to use for @@ -510,25 +521,30 @@ public class JmsComponentConfiguration { * implementation of the org.apache.camel.component.jms.JmsKeyFormatStrategy * and refer to it using the notation. */ + @NestedConfigurationProperty private JmsKeyFormatStrategy jmsKeyFormatStrategy; /** * Sets the Spring ApplicationContext to use */ + @NestedConfigurationProperty private ApplicationContext applicationContext; /** * To use a custom QueueBrowseStrategy when browsing queues */ + @NestedConfigurationProperty private QueueBrowseStrategy queueBrowseStrategy; /** * To use a custom HeaderFilterStrategy to filter header to and from Camel * message. */ + @NestedConfigurationProperty private HeaderFilterStrategy headerFilterStrategy; /** * 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. */ + @NestedConfigurationProperty private MessageCreatedStrategy messageCreatedStrategy; /** * Number of times to wait for provisional correlation id to be updated to @@ -540,13 +556,14 @@ public class JmsComponentConfiguration { * Interval in millis to sleep each time while waiting for provisional * correlation id to be updated. */ - private long waitForProvisionCorrelationToBeUpdatedThreadSleepingTime; + private Long waitForProvisionCorrelationToBeUpdatedThreadSleepingTime; - public JmsConfiguration getConfiguration() { + public JmsConfigurationNestedConfiguration getConfiguration() { return configuration; } - public void setConfiguration(JmsConfiguration configuration) { + public void setConfiguration( + JmsConfigurationNestedConfiguration configuration) { this.configuration = configuration; } @@ -859,19 +876,19 @@ public class JmsComponentConfiguration { this.pubSubNoLocal = pubSubNoLocal; } - public long getReceiveTimeout() { + public Long getReceiveTimeout() { return receiveTimeout; } - public void setReceiveTimeout(long receiveTimeout) { + public void setReceiveTimeout(Long receiveTimeout) { this.receiveTimeout = receiveTimeout; } - public long getRecoveryInterval() { + public Long getRecoveryInterval() { return recoveryInterval; } - public void setRecoveryInterval(long recoveryInterval) { + public void setRecoveryInterval(Long recoveryInterval) { this.recoveryInterval = recoveryInterval; } @@ -894,11 +911,11 @@ public class JmsComponentConfiguration { this.taskExecutor = taskExecutor; } - public long getTimeToLive() { + public Long getTimeToLive() { return timeToLive; } - public void setTimeToLive(long timeToLive) { + public void setTimeToLive(Long timeToLive) { this.timeToLive = timeToLive; } @@ -976,20 +993,20 @@ public class JmsComponentConfiguration { this.forceSendOriginalMessage = forceSendOriginalMessage; } - public long getRequestTimeout() { + public Long getRequestTimeout() { return requestTimeout; } - public void setRequestTimeout(long requestTimeout) { + public void setRequestTimeout(Long requestTimeout) { this.requestTimeout = requestTimeout; } - public long getRequestTimeoutCheckerInterval() { + public Long getRequestTimeoutCheckerInterval() { return requestTimeoutCheckerInterval; } public void setRequestTimeoutCheckerInterval( - long requestTimeoutCheckerInterval) { + Long requestTimeoutCheckerInterval) { this.requestTimeoutCheckerInterval = requestTimeoutCheckerInterval; } @@ -1142,12 +1159,1330 @@ public class JmsComponentConfiguration { this.waitForProvisionCorrelationToBeUpdatedCounter = waitForProvisionCorrelationToBeUpdatedCounter; } - public long getWaitForProvisionCorrelationToBeUpdatedThreadSleepingTime() { + public Long getWaitForProvisionCorrelationToBeUpdatedThreadSleepingTime() { return waitForProvisionCorrelationToBeUpdatedThreadSleepingTime; } public void setWaitForProvisionCorrelationToBeUpdatedThreadSleepingTime( - long waitForProvisionCorrelationToBeUpdatedThreadSleepingTime) { + Long waitForProvisionCorrelationToBeUpdatedThreadSleepingTime) { this.waitForProvisionCorrelationToBeUpdatedThreadSleepingTime = waitForProvisionCorrelationToBeUpdatedThreadSleepingTime; } + + public static class JmsConfigurationNestedConfiguration { + public static final Class CAMEL_NESTED_CLASS = org.apache.camel.component.jms.JmsConfiguration.class; + /** + * 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; + /** + * Sets the default connection factory to be used if a connection + * factory is not specified for either + * {@link #setTemplateConnectionFactory(ConnectionFactory)} or + * {@link #setListenerConnectionFactory(ConnectionFactory)} + */ + private ConnectionFactory connectionFactory; + /** + * Username to use with the ConnectionFactory. You can also configure + * username/password directly on the ConnectionFactory. + */ + private String username; + /** + * Password to use with the ConnectionFactory. You can also configure + * username/password directly on the ConnectionFactory. + */ + private String password; + /** + * Sets the connection factory to be used for consuming messages + */ + private ConnectionFactory listenerConnectionFactory; + /** + * Sets the connection factory to be used for sending messages via the + * {@link JmsTemplate} via + * {@link #createInOnlyTemplate(JmsEndpoint,boolean,String)} + */ + private ConnectionFactory templateConnectionFactory; + /** + * Specifies whether the consumer container should auto-startup. + */ + private Boolean autoStartup; + /** + * 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; + private Boolean allowReplyManagerQuickStop; + /** + * 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. + */ + private String clientId; + /** + * The durable subscriber name for specifying durable topic + * subscriptions. The clientId option must be configured as well. + */ + private String durableSubscriptionName; + /** + * Specifies the JMS Exception Listener that is to be notified of any + * underlying JMS exceptions. + */ + private ExceptionListener 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. + */ + @NestedConfigurationProperty + private ErrorHandler errorHandler; + /** + * Allows to configure the default errorHandler logging level for + * logging uncaught exceptions. + */ + private LoggingLevel errorHandlerLoggingLevel = LoggingLevel.WARN; + /** + * Allows to control whether stacktraces should be logged or not, by the + * default errorHandler. + */ + private Boolean errorHandlerLogStackTrace; + @Deprecated + private Boolean subscriptionDurable; + /** + * The JMS acknowledgement name, which is one of: SESSION_TRANSACTED, + * CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE + */ + private String acknowledgementModeName = "AUTO_ACKNOWLEDGE"; + /** + * Specifies whether the listener session should be exposed when + * consuming messages. + */ + private Boolean exposeListenerSession; + /** + * Allows you to specify a custom task executor for consuming messages. + */ + @NestedConfigurationProperty + private TaskExecutor taskExecutor; + /** + * Specifies whether to inhibit the delivery of messages published by + * its own connection. + */ + private Boolean pubSubNoLocal; + /** + * 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. + */ + private Integer 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. + */ + private Integer replyToConcurrentConsumers; + /** + * 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 Integer maxMessagesPerTask; + /** + * Sets the cache level by ID for the underlying JMS resources. See + * cacheLevelName option for more details. + */ + private Integer 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. + */ + private String cacheLevelName = "CACHE_AUTO"; + /** + * 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; + /** + * The timeout for receiving messages (in milliseconds). + */ + private Long receiveTimeout; + /** + * The Spring transaction manager to use. + */ + @NestedConfigurationProperty + private PlatformTransactionManager transactionManager; + /** + * The name of the transaction to use. + */ + private String transactionName; + /** + * The timeout value of the transaction (in seconds), if using + * transacted mode. + */ + private Integer transactionTimeout; + /** + * 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 Integer idleTaskExecutionLimit; + /** + * Specify the limit for the number of consumers that are allowed to be + * idle at any given time. + */ + private Integer idleConsumerLimit; + /** + * Number of times to wait for provisional correlation id to be updated + * to the actual correlation id when doing request/reply over JMS and + * when the option useMessageIDAsCorrelationID is enabled. + */ + private Integer waitForProvisionCorrelationToBeUpdatedCounter; + /** + * Interval in millis to sleep each time while waiting for provisional + * correlation id to be updated. + */ + private Long waitForProvisionCorrelationToBeUpdatedThreadSleepingTime; + /** + * 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. + */ + private Integer 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. + */ + private Integer replyToMaxConcurrentConsumers; + /** + * Specifies the maximum number of concurrent consumers for continue + * routing when timeout occurred when using request/reply over JMS. + */ + private Integer replyToOnTimeoutMaxConcurrentConsumers; + /** + * Specifies whether persistent delivery is used by default. + */ + private Boolean deliveryPersistent; + /** + * 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; + /** + * Specifies whether to use persistent delivery by default for replies. + */ + private Boolean replyToDeliveryPersistent; + /** + * When sending messages, specifies the time-to-live of the message (in + * milliseconds). + */ + private Long timeToLive; + /** + * 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. + */ + @NestedConfigurationProperty + private MessageConverter 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. + */ + private Boolean mapJmsMessage; + /** + * When sending, specifies whether message IDs should be added. This is + * just an hint to the JMS Broker. If the JMS provider accepts this + * hint, these messages must have the message ID set to null; if the + * provider ignores the hint, the message ID must be set to its normal + * unique value + */ + private Boolean messageIdEnabled; + /** + * Specifies whether timestamps should be enabled by default on sending + * messages. This is just an hint to the JMS Broker. If the JMS provider + * accepts this hint, these messages must have the timestamp set to + * zero; if the provider ignores the hint, the timestamp must be set to + * its normal value + */ + private Boolean messageTimestampEnabled; + /** + * 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 Integer priority; + /** + * 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. + */ + private Integer acknowledgementMode; + /** + * Specifies whether to use transacted mode + */ + private Boolean transacted; + @Deprecated + private Boolean transactedInOut; + /** + * If true, Camel will create a JmsTransactionManager, if there is no + * transactionManager injected when option transacted=true. + */ + private Boolean lazyCreateTransactionManager; + /** + * 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; + /** + * 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; + /** + * 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; + /** + * 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. + */ + @NestedConfigurationProperty + private JmsOperations 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). + */ + @NestedConfigurationProperty + private DestinationResolver destinationResolver; + /** + * Allows the provider metadata to be explicitly configured. Typically + * this is not required and Camel will auto-detect the provider metadata + * from the underlying provider. + */ + @NestedConfigurationProperty + private JmsProviderMetadata providerMetadata; + /** + * Sets the {@link JmsOperations} used to deduce the + * {@link JmsProviderMetadata} details which if none is customized one + * is lazily created on demand + */ + @NestedConfigurationProperty + private JmsOperations metadataJmsOperations; + /** + * 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; + /** + * Specifies whether JMSMessageID should always be used as + * JMSCorrelationID for InOut messages. + */ + private Boolean useMessageIDAsCorrelationID; + /** + * 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; + /** + * 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; + /** + * Provides an explicit ReplyTo destination, which overrides any + * incoming value of Message.getJMSReplyTo(). + */ + private String replyTo; + /** + * 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; + /** + * 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; + /** + * 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; + /** + * 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; + /** + * 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. + */ + @NestedConfigurationProperty + private JmsKeyFormatStrategy jmsKeyFormatStrategy; + /** + * 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; + /** + * 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; + /** + * 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 + * {@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> + * 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; + /** + * 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; + /** + * Whether to stop the JmsConsumer message listener asynchronously, when + * stopping a route. + */ + private Boolean asyncStopListener; + /** + * 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; + /** + * 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; + /** + * 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; + /** + * 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; + /** + * 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; + /** + * 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; + /** + * 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; + /** + * 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. + */ + @NestedConfigurationProperty + private MessageListenerContainerFactory messageListenerContainerFactory; + /** + * 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; + /** + * 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; + /** + * 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; + /** + * To use the given MessageCreatedStrategy which are invoked when Camel + * creates new instances of <tt>javax.jms.Message</tt> objects when + * Camel is sending a JMS message. + */ + @NestedConfigurationProperty + private MessageCreatedStrategy messageCreatedStrategy; + /** + * Sets the JMS selector to use + */ + private String selector; + + public ConsumerType getConsumerType() { + return consumerType; + } + + public void setConsumerType(ConsumerType consumerType) { + this.consumerType = consumerType; + } + + public ConnectionFactory getConnectionFactory() { + return connectionFactory; + } + + public void setConnectionFactory(ConnectionFactory connectionFactory) { + this.connectionFactory = connectionFactory; + } + + public String getUsername() { + return username; + } + + public void setUsername(String username) { + this.username = username; + } + + public String getPassword() { + return password; + } + + public void setPassword(String password) { + this.password = password; + } + + public ConnectionFactory getListenerConnectionFactory() { + return listenerConnectionFactory; + } + + public void setListenerConnectionFactory( + ConnectionFactory listenerConnectionFactory) { + this.listenerConnectionFactory = listenerConnectionFactory; + } + + public ConnectionFactory getTemplateConnectionFactory() { + return templateConnectionFactory; + } + + public void setTemplateConnectionFactory( + ConnectionFactory templateConnectionFactory) { + this.templateConnectionFactory = templateConnectionFactory; + } + + public Boolean getAutoStartup() { + return autoStartup; + } + + public void setAutoStartup(Boolean autoStartup) { + this.autoStartup = autoStartup; + } + + public Boolean getAcceptMessagesWhileStopping() { + return acceptMessagesWhileStopping; + } + + public void setAcceptMessagesWhileStopping( + Boolean acceptMessagesWhileStopping) { + this.acceptMessagesWhileStopping = acceptMessagesWhileStopping; + } + + public Boolean getAllowReplyManagerQuickStop() { + return allowReplyManagerQuickStop; + } + + public void setAllowReplyManagerQuickStop( + Boolean allowReplyManagerQuickStop) { + this.allowReplyManagerQuickStop = allowReplyManagerQuickStop; + } + + public String getClientId() { + return clientId; + } + + public void setClientId(String clientId) { + this.clientId = clientId; + } + + public String getDurableSubscriptionName() { + return durableSubscriptionName; + } + + public void setDurableSubscriptionName(String durableSubscriptionName) { + this.durableSubscriptionName = durableSubscriptionName; + } + + public ExceptionListener getExceptionListener() { + return exceptionListener; + } + + public void setExceptionListener(ExceptionListener exceptionListener) { + this.exceptionListener = exceptionListener; + } + + public ErrorHandler getErrorHandler() { + return errorHandler; + } + + public void setErrorHandler(ErrorHandler errorHandler) { + this.errorHandler = errorHandler; + } + + public LoggingLevel getErrorHandlerLoggingLevel() { + return errorHandlerLoggingLevel; + } + + public void setErrorHandlerLoggingLevel( + LoggingLevel errorHandlerLoggingLevel) { + this.errorHandlerLoggingLevel = errorHandlerLoggingLevel; + } + + public Boolean getErrorHandlerLogStackTrace() { + return errorHandlerLogStackTrace; + } + + public void setErrorHandlerLogStackTrace( + Boolean errorHandlerLogStackTrace) { + this.errorHandlerLogStackTrace = errorHandlerLogStackTrace; + } + + @Deprecated + @DeprecatedConfigurationProperty + public Boolean getSubscriptionDurable() { + return subscriptionDurable; + } + + @Deprecated + public void setSubscriptionDurable(Boolean subscriptionDurable) { + this.subscriptionDurable = subscriptionDurable; + } + + public String getAcknowledgementModeName() { + return acknowledgementModeName; + } + + public void setAcknowledgementModeName(String acknowledgementModeName) { + this.acknowledgementModeName = acknowledgementModeName; + } + + public Boolean getExposeListenerSession() { + return exposeListenerSession; + } + + public void setExposeListenerSession(Boolean exposeListenerSession) { + this.exposeListenerSession = exposeListenerSession; + } + + public TaskExecutor getTaskExecutor() { + return taskExecutor; + } + + public void setTaskExecutor(TaskExecutor taskExecutor) { + this.taskExecutor = taskExecutor; + } + + public Boolean getPubSubNoLocal() { + return pubSubNoLocal; + } + + public void setPubSubNoLocal(Boolean pubSubNoLocal) { + this.pubSubNoLocal = pubSubNoLocal; + } + + public Integer getConcurrentConsumers() { + return concurrentConsumers; + } + + public void setConcurrentConsumers(Integer concurrentConsumers) { + this.concurrentConsumers = concurrentConsumers; + } + + public Integer getReplyToConcurrentConsumers() { + return replyToConcurrentConsumers; + } + + public void setReplyToConcurrentConsumers( + Integer replyToConcurrentConsumers) { + this.replyToConcurrentConsumers = replyToConcurrentConsumers; + } + + public Integer getMaxMessagesPerTask() { + return maxMessagesPerTask; + } + + public void setMaxMessagesPerTask(Integer maxMessagesPerTask) { + this.maxMessagesPerTask = maxMessagesPerTask; + } + + public Integer getCacheLevel() { + return cacheLevel; + } + + public void setCacheLevel(Integer cacheLevel) { + this.cacheLevel = cacheLevel; + } + + public String getCacheLevelName() { + return cacheLevelName; + } + + public void setCacheLevelName(String cacheLevelName) { + this.cacheLevelName = cacheLevelName; + } + + public Long getRecoveryInterval() { + return recoveryInterval; + } + + public void setRecoveryInterval(Long recoveryInterval) { + this.recoveryInterval = recoveryInterval; + } + + public Long getReceiveTimeout() { + return receiveTimeout; + } + + public void setReceiveTimeout(Long receiveTimeout) { + this.receiveTimeout = receiveTimeout; + } + + public PlatformTransactionManager getTransactionManager() { + return transactionManager; + } + + public void setTransactionManager( + PlatformTransactionManager transactionManager) { + this.transactionManager = transactionManager; + } + + public String getTransactionName() { + return transactionName; + } + + public void setTransactionName(String transactionName) { + this.transactionName = transactionName; + } + + public Integer getTransactionTimeout() { + return transactionTimeout; + } + + public void setTransactionTimeout(Integer transactionTimeout) { + this.transactionTimeout = transactionTimeout; + } + + public Integer getIdleTaskExecutionLimit() { + return idleTaskExecutionLimit; + } + + public void setIdleTaskExecutionLimit(Integer idleTaskExecutionLimit) { + this.idleTaskExecutionLimit = idleTaskExecutionLimit; + } + + public Integer getIdleConsumerLimit() { + return idleConsumerLimit; + } + + public void setIdleConsumerLimit(Integer idleConsumerLimit) { + this.idleConsumerLimit = idleConsumerLimit; + } + + public Integer getWaitForProvisionCorrelationToBeUpdatedCounter() { + return waitForProvisionCorrelationToBeUpdatedCounter; + } + + public void setWaitForProvisionCorrelationToBeUpdatedCounter( + Integer waitForProvisionCorrelationToBeUpdatedCounter) { + this.waitForProvisionCorrelationToBeUpdatedCounter = waitForProvisionCorrelationToBeUpdatedCounter; + } + + public Long getWaitForProvisionCorrelationToBeUpdatedThreadSleepingTime() { + return waitForProvisionCorrelationToBeUpdatedThreadSleepingTime; + } + + public void setWaitForProvisionCorrelationToBeUpdatedThreadSleepingTime( + Long waitForProvisionCorrelationToBeUpdatedThreadSleepingTime) { + this.waitForProvisionCorrelationToBeUpdatedThreadSleepingTime = waitForProvisionCorrelationToBeUpdatedThreadSleepingTime; + } + + public Integer getMaxConcurrentConsumers() { + return maxConcurrentConsumers; + } + + public void setMaxConcurrentConsumers(Integer maxConcurrentConsumers) { + this.maxConcurrentConsumers = maxConcurrentConsumers; + } + + public Integer getReplyToMaxConcurrentConsumers() { + return replyToMaxConcurrentConsumers; + } + + public void setReplyToMaxConcurrentConsumers( + Integer replyToMaxConcurrentConsumers) { + this.replyToMaxConcurrentConsumers = replyToMaxConcurrentConsumers; + } + + public Integer getReplyToOnTimeoutMaxConcurrentConsumers() { + return replyToOnTimeoutMaxConcurrentConsumers; + } + + public void setReplyToOnTimeoutMaxConcurrentConsumers( + Integer replyToOnTimeoutMaxConcurrentConsumers) { + this.replyToOnTimeoutMaxConcurrentConsumers = replyToOnTimeoutMaxConcurrentConsumers; + } + + public Boolean getDeliveryPersistent() { + return deliveryPersistent; + } + + public void setDeliveryPersistent(Boolean deliveryPersistent) { + this.deliveryPersistent = deliveryPersistent; + } + + public Integer getDeliveryMode() { + return deliveryMode; + } + + public void setDeliveryMode(Integer deliveryMode) { + this.deliveryMode = deliveryMode; + } + + public Boolean getReplyToDeliveryPersistent() { + return replyToDeliveryPersistent; + } + + public void setReplyToDeliveryPersistent( + Boolean replyToDeliveryPersistent) { + this.replyToDeliveryPersistent = replyToDeliveryPersistent; + } + + public Long getTimeToLive() { + return timeToLive; + } + + public void setTimeToLive(Long timeToLive) { + this.timeToLive = timeToLive; + } + + public MessageConverter getMessageConverter() { + return messageConverter; + } + + public void setMessageConverter(MessageConverter messageConverter) { + this.messageConverter = messageConverter; + } + + public Boolean getMapJmsMessage() { + return mapJmsMessage; + } + + public void setMapJmsMessage(Boolean mapJmsMessage) { + this.mapJmsMessage = mapJmsMessage; + } + + public Boolean getMessageIdEnabled() { + return messageIdEnabled; + } + + public void setMessageIdEnabled(Boolean messageIdEnabled) { + this.messageIdEnabled = messageIdEnabled; + } + + public Boolean getMessageTimestampEnabled() { + return messageTimestampEnabled; + } + + public void setMessageTimestampEnabled(Boolean messageTimestampEnabled) { + this.messageTimestampEnabled = messageTimestampEnabled; + } + + public Integer getPriority() { + return priority; + } + + public void setPriority(Integer priority) { + this.priority = priority; + } + + public Integer getAcknowledgementMode() { + return acknowledgementMode; + } + + public void setAcknowledgementMode(Integer acknowledgementMode) { + this.acknowledgementMode = acknowledgementMode; + } + + public Boolean getTransacted() { + return transacted; + } + + public void setTransacted(Boolean transacted) { + this.transacted = transacted; + } + + @Deprecated + @DeprecatedConfigurationProperty + public Boolean getTransactedInOut() { + return transactedInOut; + } + + @Deprecated + public void setTransactedInOut(Boolean transactedInOut) { + this.transactedInOut = transactedInOut; + } + + public Boolean getLazyCreateTransactionManager() { + return lazyCreateTransactionManager; + } + + public void setLazyCreateTransactionManager( + Boolean lazyCreateTransactionManager) { + this.lazyCreateTransactionManager = lazyCreateTransactionManager; + } + + public Boolean getEagerLoadingOfProperties() { + return eagerLoadingOfProperties; + } + + public void setEagerLoadingOfProperties(Boolean eagerLoadingOfProperties) { + this.eagerLoadingOfProperties = eagerLoadingOfProperties; + } + + public Boolean getDisableReplyTo() { + return disableReplyTo; + } + + public void setDisableReplyTo(Boolean disableReplyTo) { + this.disableReplyTo = disableReplyTo; + } + + public Boolean getPreserveMessageQos() { + return preserveMessageQos; + } + + public void setPreserveMessageQos(Boolean preserveMessageQos) { + this.preserveMessageQos = preserveMessageQos; + } + + public JmsOperations getJmsOperations() { + return jmsOperations; + } + + public void setJmsOperations(JmsOperations jmsOperations) { + this.jmsOperations = jmsOperations; + } + + public DestinationResolver getDestinationResolver() { + return destinationResolver; + } + + public void setDestinationResolver( + DestinationResolver destinationResolver) { + this.destinationResolver = destinationResolver; + } + + public JmsProviderMetadata getProviderMetadata() { + return providerMetadata; + } + + public void setProviderMetadata(JmsProviderMetadata providerMetadata) { + this.providerMetadata = providerMetadata; + } + + public JmsOperations getMetadataJmsOperations() { + return metadataJmsOperations; + } + + public void setMetadataJmsOperations(JmsOperations metadataJmsOperations) { + this.metadataJmsOperations = metadataJmsOperations; + } + + public Boolean getAlwaysCopyMessage() { + return alwaysCopyMessage; + } + + public void setAlwaysCopyMessage(Boolean alwaysCopyMessage) { + this.alwaysCopyMessage = alwaysCopyMessage; + } + + public Boolean getUseMessageIDAsCorrelationID() { + return useMessageIDAsCorrelationID; + } + + public void setUseMessageIDAsCorrelationID( + Boolean useMessageIDAsCorrelationID) { + this.useMessageIDAsCorrelationID = useMessageIDAsCorrelationID; + } + + public Long getRequestTimeout() { + return requestTimeout; + } + + public void setRequestTimeout(Long requestTimeout) { + this.requestTimeout = requestTimeout; + } + + public Long getRequestTimeoutCheckerInterval() { + return requestTimeoutCheckerInterval; + } + + public void setRequestTimeoutCheckerInterval( + Long requestTimeoutCheckerInterval) { + this.requestTimeoutCheckerInterval = requestTimeoutCheckerInterval; + } + + public String getReplyTo() { + return replyTo; + } + + public void setReplyTo(String replyTo) { + this.replyTo = replyTo; + } + + public String getReplyToDestinationSelectorName() { + return replyToDestinationSelectorName; + } + + public void setReplyToDestinationSelectorName( + String replyToDestinationSelectorName) { + this.replyToDestinationSelectorName = replyToDestinationSelectorName; + } + + public String getReplyToOverride() { + return replyToOverride; + } + + public void setReplyToOverride(String replyToOverride) { + this.replyToOverride = replyToOverride; + } + + public Boolean getReplyToSameDestinationAllowed() { + return replyToSameDestinationAllowed; + } + + public void setReplyToSameDestinationAllowed( + Boolean replyToSameDestinationAllowed) { + this.replyToSameDestinationAllowed = replyToSameDestinationAllowed; + } + + public JmsMessageType getJmsMessageType() { + return jmsMessageType; + } + + public void setJmsMessageType(JmsMessageType jmsMessageType) { + this.jmsMessageType = jmsMessageType; + } + + public JmsKeyFormatStrategy getJmsKeyFormatStrategy() { + return jmsKeyFormatStrategy; + } + + public void setJmsKeyFormatStrategy( + JmsKeyFormatStrategy jmsKeyFormatStrategy) { + this.jmsKeyFormatStrategy = jmsKeyFormatStrategy; + } + + public Boolean getTransferExchange() { + return transferExchange; + } + + public void setTransferExchange(Boolean transferExchange) { + this.transferExchange = transferExchange; + } + + public Boolean getTransferException() { + return transferException; + } + + public void setTransferException(Boolean transferException) { + this.transferException = transferException; + } + + public Boolean getTransferFault() { + return transferFault; + } + + public void setTransferFault(Boolean transferFault) { + this.transferFault = transferFault; + } + + public Boolean getAsyncStartListener() { + return asyncStartListener; + } + + public void setAsyncStartListener(Boolean asyncStartListener) { + this.asyncStartListener = asyncStartListener; + } + + public Boolean getAsyncStopListener() { + return asyncStopListener; + } + + public void setAsyncStopListener(Boolean asyncStopListener) { + this.asyncStopListener = asyncStopListener; + } + + public Boolean getTestConnectionOnStartup() { + return testConnectionOnStartup; + } + + public void setTestConnectionOnStartup(Boolean testConnectionOnStartup) { + this.testConnectionOnStartup = testConnectionOnStartup; + } + + public Boolean getForceSendOriginalMessage() { + return forceSendOriginalMessage; + } + + public void setForceSendOriginalMessage(Boolean forceSendOriginalMessage) { + this.forceSendOriginalMessage = forceSendOriginalMessage; + } + + public Boolean getDisableTimeToLive() { + return disableTimeToLive; + } + + public void setDisableTimeToLive(Boolean disableTimeToLive) { + this.disableTimeToLive = disableTimeToLive; + } + + public ReplyToType getReplyToType() { + return replyToType; + } + + public void setReplyToType(ReplyToType replyToType) { + this.replyToType = replyToType; + } + + public Boolean getAsyncConsumer() { + return asyncConsumer; + } + + public void setAsyncConsumer(Boolean asyncConsumer) { + this.asyncConsumer = asyncConsumer; + } + + public String getReplyToCacheLevelName() { + return replyToCacheLevelName; + } + + public void setReplyToCacheLevelName(String replyToCacheLevelName) { + this.replyToCacheLevelName = replyToCacheLevelName; + } + + public Boolean getAllowNullBody() { + return allowNullBody; + } + + public void setAllowNullBody(Boolean allowNullBody) { + this.allowNullBody = allowNullBody; + } + + public MessageListenerContainerFactory getMessageListenerContainerFactory() { + return messageListenerContainerFactory; + } + + public void setMessageListenerContainerFactory( + MessageListenerContainerFactory messageListenerContainerFactory) { + this.messageListenerContainerFactory = messageListenerContainerFactory; + } + + public Boolean getIncludeSentJMSMessageID() { + return includeSentJMSMessageID; + } + + public void setIncludeSentJMSMessageID(Boolean includeSentJMSMessageID) { + this.includeSentJMSMessageID = includeSentJMSMessageID; + } + + public DefaultTaskExecutorType getDefaultTaskExecutorType() { + return defaultTaskExecutorType; + } + + public void setDefaultTaskExecutorType( + DefaultTaskExecutorType defaultTaskExecutorType) { + this.defaultTaskExecutorType = defaultTaskExecutorType; + } + + public Boolean getIncludeAllJMSXProperties() { + return includeAllJMSXProperties; + } + + public void setIncludeAllJMSXProperties(Boolean includeAllJMSXProperties) { + this.includeAllJMSXProperties = includeAllJMSXProperties; + } + + public MessageCreatedStrategy getMessageCreatedStrategy() { + return messageCreatedStrategy; + } + + public void setMessageCreatedStrategy( + MessageCreatedStrategy messageCreatedStrategy) { + this.messageCreatedStrategy = messageCreatedStrategy; + } + + public String getSelector() { + return selector; + } + + public void setSelector(String selector) { + this.selector = selector; + } + } } \ No newline at end of file
http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-jolt-starter/src/main/java/org/apache/camel/component/jolt/springboot/JoltComponentAutoConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-jolt-starter/src/main/java/org/apache/camel/component/jolt/springboot/JoltComponentAutoConfiguration.java b/components-starter/camel-jolt-starter/src/main/java/org/apache/camel/component/jolt/springboot/JoltComponentAutoConfiguration.java index 1531848..ca21556 100644 --- a/components-starter/camel-jolt-starter/src/main/java/org/apache/camel/component/jolt/springboot/JoltComponentAutoConfiguration.java +++ b/components-starter/camel-jolt-starter/src/main/java/org/apache/camel/component/jolt/springboot/JoltComponentAutoConfiguration.java @@ -44,6 +44,26 @@ public class JoltComponentAutoConfiguration { Map<String, Object> parameters = new HashMap<>(); IntrospectionSupport.getProperties(configuration, parameters, null, false); + for (Map.Entry<String, Object> entry : parameters.entrySet()) { + Object value = entry.getValue(); + Class<?> paramClass = value.getClass(); + if (paramClass.getName().endsWith("NestedConfiguration")) { + Class nestedClass = null; + try { + nestedClass = (Class) paramClass.getDeclaredField( + "CAMEL_NESTED_CLASS").get(null); + HashMap<String, Object> nestedParameters = new HashMap<>(); + IntrospectionSupport.getProperties(value, nestedParameters, + null, false); + Object nestedProperty = nestedClass.newInstance(); + IntrospectionSupport.setProperties(camelContext, + camelContext.getTypeConverter(), nestedProperty, + nestedParameters); + entry.setValue(nestedProperty); + } catch (NoSuchFieldException e) { + } + } + } IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), component, parameters); return component; http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-jolt-starter/src/main/java/org/apache/camel/component/jolt/springboot/JoltComponentConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-jolt-starter/src/main/java/org/apache/camel/component/jolt/springboot/JoltComponentConfiguration.java b/components-starter/camel-jolt-starter/src/main/java/org/apache/camel/component/jolt/springboot/JoltComponentConfiguration.java index 688679f..0322b23 100644 --- a/components-starter/camel-jolt-starter/src/main/java/org/apache/camel/component/jolt/springboot/JoltComponentConfiguration.java +++ b/components-starter/camel-jolt-starter/src/main/java/org/apache/camel/component/jolt/springboot/JoltComponentConfiguration.java @@ -18,6 +18,7 @@ package org.apache.camel.component.jolt.springboot; import com.bazaarvoice.jolt.Transform; import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.boot.context.properties.NestedConfigurationProperty; /** * The jolt component allows you to process a JSON messages using an JOLT @@ -32,6 +33,7 @@ public class JoltComponentConfiguration { * Explicitly sets the Transform to use. If not set a Transform specified by * the transformDsl will be created */ + @NestedConfigurationProperty private Transform transform; public Transform getTransform() { http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-jpa-starter/src/main/java/org/apache/camel/component/jpa/springboot/JpaComponentAutoConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-jpa-starter/src/main/java/org/apache/camel/component/jpa/springboot/JpaComponentAutoConfiguration.java b/components-starter/camel-jpa-starter/src/main/java/org/apache/camel/component/jpa/springboot/JpaComponentAutoConfiguration.java index 2723d49..0101611 100644 --- a/components-starter/camel-jpa-starter/src/main/java/org/apache/camel/component/jpa/springboot/JpaComponentAutoConfiguration.java +++ b/components-starter/camel-jpa-starter/src/main/java/org/apache/camel/component/jpa/springboot/JpaComponentAutoConfiguration.java @@ -44,6 +44,26 @@ public class JpaComponentAutoConfiguration { Map<String, Object> parameters = new HashMap<>(); IntrospectionSupport.getProperties(configuration, parameters, null, false); + for (Map.Entry<String, Object> entry : parameters.entrySet()) { + Object value = entry.getValue(); + Class<?> paramClass = value.getClass(); + if (paramClass.getName().endsWith("NestedConfiguration")) { + Class nestedClass = null; + try { + nestedClass = (Class) paramClass.getDeclaredField( + "CAMEL_NESTED_CLASS").get(null); + HashMap<String, Object> nestedParameters = new HashMap<>(); + IntrospectionSupport.getProperties(value, nestedParameters, + null, false); + Object nestedProperty = nestedClass.newInstance(); + IntrospectionSupport.setProperties(camelContext, + camelContext.getTypeConverter(), nestedProperty, + nestedParameters); + entry.setValue(nestedProperty); + } catch (NoSuchFieldException e) { + } + } + } IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), component, parameters); return component; http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-jpa-starter/src/main/java/org/apache/camel/component/jpa/springboot/JpaComponentConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-jpa-starter/src/main/java/org/apache/camel/component/jpa/springboot/JpaComponentConfiguration.java b/components-starter/camel-jpa-starter/src/main/java/org/apache/camel/component/jpa/springboot/JpaComponentConfiguration.java index 75359ca..4e26964 100644 --- a/components-starter/camel-jpa-starter/src/main/java/org/apache/camel/component/jpa/springboot/JpaComponentConfiguration.java +++ b/components-starter/camel-jpa-starter/src/main/java/org/apache/camel/component/jpa/springboot/JpaComponentConfiguration.java @@ -18,6 +18,7 @@ package org.apache.camel.component.jpa.springboot; import javax.persistence.EntityManagerFactory; import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.boot.context.properties.NestedConfigurationProperty; import org.springframework.transaction.PlatformTransactionManager; /** @@ -37,6 +38,7 @@ public class JpaComponentConfiguration { /** * To use the PlatformTransactionManager for managing transactions. */ + @NestedConfigurationProperty private PlatformTransactionManager transactionManager; /** * The camel-jpa component will join transaction by default. You can use http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-jsch-starter/src/main/java/org/apache/camel/component/scp/springboot/ScpComponentAutoConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-jsch-starter/src/main/java/org/apache/camel/component/scp/springboot/ScpComponentAutoConfiguration.java b/components-starter/camel-jsch-starter/src/main/java/org/apache/camel/component/scp/springboot/ScpComponentAutoConfiguration.java index e5c0037..9509915 100644 --- a/components-starter/camel-jsch-starter/src/main/java/org/apache/camel/component/scp/springboot/ScpComponentAutoConfiguration.java +++ b/components-starter/camel-jsch-starter/src/main/java/org/apache/camel/component/scp/springboot/ScpComponentAutoConfiguration.java @@ -44,6 +44,26 @@ public class ScpComponentAutoConfiguration { Map<String, Object> parameters = new HashMap<>(); IntrospectionSupport.getProperties(configuration, parameters, null, false); + for (Map.Entry<String, Object> entry : parameters.entrySet()) { + Object value = entry.getValue(); + Class<?> paramClass = value.getClass(); + if (paramClass.getName().endsWith("NestedConfiguration")) { + Class nestedClass = null; + try { + nestedClass = (Class) paramClass.getDeclaredField( + "CAMEL_NESTED_CLASS").get(null); + HashMap<String, Object> nestedParameters = new HashMap<>(); + IntrospectionSupport.getProperties(value, nestedParameters, + null, false); + Object nestedProperty = nestedClass.newInstance(); + IntrospectionSupport.setProperties(camelContext, + camelContext.getTypeConverter(), nestedProperty, + nestedParameters); + entry.setValue(nestedProperty); + } catch (NoSuchFieldException e) { + } + } + } IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), component, parameters); return component; http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-jt400-starter/src/main/java/org/apache/camel/component/jt400/springboot/Jt400ComponentAutoConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-jt400-starter/src/main/java/org/apache/camel/component/jt400/springboot/Jt400ComponentAutoConfiguration.java b/components-starter/camel-jt400-starter/src/main/java/org/apache/camel/component/jt400/springboot/Jt400ComponentAutoConfiguration.java index cccfab7..1c1e4a8 100644 --- a/components-starter/camel-jt400-starter/src/main/java/org/apache/camel/component/jt400/springboot/Jt400ComponentAutoConfiguration.java +++ b/components-starter/camel-jt400-starter/src/main/java/org/apache/camel/component/jt400/springboot/Jt400ComponentAutoConfiguration.java @@ -44,6 +44,26 @@ public class Jt400ComponentAutoConfiguration { Map<String, Object> parameters = new HashMap<>(); IntrospectionSupport.getProperties(configuration, parameters, null, false); + for (Map.Entry<String, Object> entry : parameters.entrySet()) { + Object value = entry.getValue(); + Class<?> paramClass = value.getClass(); + if (paramClass.getName().endsWith("NestedConfiguration")) { + Class nestedClass = null; + try { + nestedClass = (Class) paramClass.getDeclaredField( + "CAMEL_NESTED_CLASS").get(null); + HashMap<String, Object> nestedParameters = new HashMap<>(); + IntrospectionSupport.getProperties(value, nestedParameters, + null, false); + Object nestedProperty = nestedClass.newInstance(); + IntrospectionSupport.setProperties(camelContext, + camelContext.getTypeConverter(), nestedProperty, + nestedParameters); + entry.setValue(nestedProperty); + } catch (NoSuchFieldException e) { + } + } + } IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), component, parameters); return component; http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-jt400-starter/src/main/java/org/apache/camel/component/jt400/springboot/Jt400ComponentConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-jt400-starter/src/main/java/org/apache/camel/component/jt400/springboot/Jt400ComponentConfiguration.java b/components-starter/camel-jt400-starter/src/main/java/org/apache/camel/component/jt400/springboot/Jt400ComponentConfiguration.java index ac0cdc1..c72a44c 100644 --- a/components-starter/camel-jt400-starter/src/main/java/org/apache/camel/component/jt400/springboot/Jt400ComponentConfiguration.java +++ b/components-starter/camel-jt400-starter/src/main/java/org/apache/camel/component/jt400/springboot/Jt400ComponentConfiguration.java @@ -18,6 +18,7 @@ package org.apache.camel.component.jt400.springboot; import com.ibm.as400.access.AS400ConnectionPool; import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.boot.context.properties.NestedConfigurationProperty; /** * The jt400 component allows you to exchanges messages with an AS/400 system @@ -31,6 +32,7 @@ public class Jt400ComponentConfiguration { /** * Returns the default connection pool used by this component. */ + @NestedConfigurationProperty private AS400ConnectionPool connectionPool; public AS400ConnectionPool getConnectionPool() { http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-kafka-starter/src/main/java/org/apache/camel/component/kafka/springboot/KafkaComponentAutoConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-kafka-starter/src/main/java/org/apache/camel/component/kafka/springboot/KafkaComponentAutoConfiguration.java b/components-starter/camel-kafka-starter/src/main/java/org/apache/camel/component/kafka/springboot/KafkaComponentAutoConfiguration.java index b2f4075..0780a0b 100644 --- a/components-starter/camel-kafka-starter/src/main/java/org/apache/camel/component/kafka/springboot/KafkaComponentAutoConfiguration.java +++ b/components-starter/camel-kafka-starter/src/main/java/org/apache/camel/component/kafka/springboot/KafkaComponentAutoConfiguration.java @@ -44,6 +44,26 @@ public class KafkaComponentAutoConfiguration { Map<String, Object> parameters = new HashMap<>(); IntrospectionSupport.getProperties(configuration, parameters, null, false); + for (Map.Entry<String, Object> entry : parameters.entrySet()) { + Object value = entry.getValue(); + Class<?> paramClass = value.getClass(); + if (paramClass.getName().endsWith("NestedConfiguration")) { + Class nestedClass = null; + try { + nestedClass = (Class) paramClass.getDeclaredField( + "CAMEL_NESTED_CLASS").get(null); + HashMap<String, Object> nestedParameters = new HashMap<>(); + IntrospectionSupport.getProperties(value, nestedParameters, + null, false); + Object nestedProperty = nestedClass.newInstance(); + IntrospectionSupport.setProperties(camelContext, + camelContext.getTypeConverter(), nestedProperty, + nestedParameters); + entry.setValue(nestedProperty); + } catch (NoSuchFieldException e) { + } + } + } IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), component, parameters); return component; http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-kestrel-starter/src/main/java/org/apache/camel/component/kestrel/springboot/KestrelComponentAutoConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-kestrel-starter/src/main/java/org/apache/camel/component/kestrel/springboot/KestrelComponentAutoConfiguration.java b/components-starter/camel-kestrel-starter/src/main/java/org/apache/camel/component/kestrel/springboot/KestrelComponentAutoConfiguration.java index 83adabb..1bd0d5b 100644 --- a/components-starter/camel-kestrel-starter/src/main/java/org/apache/camel/component/kestrel/springboot/KestrelComponentAutoConfiguration.java +++ b/components-starter/camel-kestrel-starter/src/main/java/org/apache/camel/component/kestrel/springboot/KestrelComponentAutoConfiguration.java @@ -45,6 +45,26 @@ public class KestrelComponentAutoConfiguration { Map<String, Object> parameters = new HashMap<>(); IntrospectionSupport.getProperties(configuration, parameters, null, false); + for (Map.Entry<String, Object> entry : parameters.entrySet()) { + Object value = entry.getValue(); + Class<?> paramClass = value.getClass(); + if (paramClass.getName().endsWith("NestedConfiguration")) { + Class nestedClass = null; + try { + nestedClass = (Class) paramClass.getDeclaredField( + "CAMEL_NESTED_CLASS").get(null); + HashMap<String, Object> nestedParameters = new HashMap<>(); + IntrospectionSupport.getProperties(value, nestedParameters, + null, false); + Object nestedProperty = nestedClass.newInstance(); + IntrospectionSupport.setProperties(camelContext, + camelContext.getTypeConverter(), nestedProperty, + nestedParameters); + entry.setValue(nestedProperty); + } catch (NoSuchFieldException e) { + } + } + } IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), component, parameters); return component; http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-kestrel-starter/src/main/java/org/apache/camel/component/kestrel/springboot/KestrelComponentConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-kestrel-starter/src/main/java/org/apache/camel/component/kestrel/springboot/KestrelComponentConfiguration.java b/components-starter/camel-kestrel-starter/src/main/java/org/apache/camel/component/kestrel/springboot/KestrelComponentConfiguration.java index 8c0e311..ae17c4d 100644 --- a/components-starter/camel-kestrel-starter/src/main/java/org/apache/camel/component/kestrel/springboot/KestrelComponentConfiguration.java +++ b/components-starter/camel-kestrel-starter/src/main/java/org/apache/camel/component/kestrel/springboot/KestrelComponentConfiguration.java @@ -16,7 +16,6 @@ */ package org.apache.camel.component.kestrel.springboot; -import org.apache.camel.component.kestrel.KestrelConfiguration; import org.springframework.boot.context.properties.ConfigurationProperties; /** @@ -32,13 +31,54 @@ public class KestrelComponentConfiguration { * To use a shared configured configuration as base for creating new * endpoints. */ - private KestrelConfiguration configuration; + private KestrelConfigurationNestedConfiguration configuration; - public KestrelConfiguration getConfiguration() { + public KestrelConfigurationNestedConfiguration getConfiguration() { return configuration; } - public void setConfiguration(KestrelConfiguration configuration) { + public void setConfiguration( + KestrelConfigurationNestedConfiguration configuration) { this.configuration = configuration; } + + public static class KestrelConfigurationNestedConfiguration { + public static final Class CAMEL_NESTED_CLASS = org.apache.camel.component.kestrel.KestrelConfiguration.class; + /** + * The addresses + */ + private String[] addresses; + /** + * The wait time in milliseconds + */ + private Integer waitTimeMs; + /** + * The number of concurrent consumers + */ + private Integer concurrentConsumers; + + public String[] getAddresses() { + return addresses; + } + + public void setAddresses(String[] addresses) { + this.addresses = addresses; + } + + public Integer getWaitTimeMs() { + return waitTimeMs; + } + + public void setWaitTimeMs(Integer waitTimeMs) { + this.waitTimeMs = waitTimeMs; + } + + public Integer getConcurrentConsumers() { + return concurrentConsumers; + } + + public void setConcurrentConsumers(Integer concurrentConsumers) { + this.concurrentConsumers = concurrentConsumers; + } + } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/camel/blob/d485f2f0/components-starter/camel-linkedin-starter/src/main/java/org/apache/camel/component/linkedin/springboot/LinkedInComponentAutoConfiguration.java ---------------------------------------------------------------------- diff --git a/components-starter/camel-linkedin-starter/src/main/java/org/apache/camel/component/linkedin/springboot/LinkedInComponentAutoConfiguration.java b/components-starter/camel-linkedin-starter/src/main/java/org/apache/camel/component/linkedin/springboot/LinkedInComponentAutoConfiguration.java index 95a6077..2be385e 100644 --- a/components-starter/camel-linkedin-starter/src/main/java/org/apache/camel/component/linkedin/springboot/LinkedInComponentAutoConfiguration.java +++ b/components-starter/camel-linkedin-starter/src/main/java/org/apache/camel/component/linkedin/springboot/LinkedInComponentAutoConfiguration.java @@ -45,6 +45,26 @@ public class LinkedInComponentAutoConfiguration { Map<String, Object> parameters = new HashMap<>(); IntrospectionSupport.getProperties(configuration, parameters, null, false); + for (Map.Entry<String, Object> entry : parameters.entrySet()) { + Object value = entry.getValue(); + Class<?> paramClass = value.getClass(); + if (paramClass.getName().endsWith("NestedConfiguration")) { + Class nestedClass = null; + try { + nestedClass = (Class) paramClass.getDeclaredField( + "CAMEL_NESTED_CLASS").get(null); + HashMap<String, Object> nestedParameters = new HashMap<>(); + IntrospectionSupport.getProperties(value, nestedParameters, + null, false); + Object nestedProperty = nestedClass.newInstance(); + IntrospectionSupport.setProperties(camelContext, + camelContext.getTypeConverter(), nestedProperty, + nestedParameters); + entry.setValue(nestedProperty); + } catch (NoSuchFieldException e) { + } + } + } IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), component, parameters); return component;
