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 2019/08/07 10:00:29 UTC
[camel] branch master updated: CAMEL-13829: Add caution to
transferExchange/transferException option on JMS components
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/master by this push:
new 156fa41 CAMEL-13829: Add caution to transferExchange/transferException option on JMS components
156fa41 is described below
commit 156fa414c343601f2a7af29c20b5d59431f77bdf
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Wed Aug 7 11:59:25 2019 +0200
CAMEL-13829: Add caution to transferExchange/transferException option on JMS components
---
.../src/main/docs/activemq-component.adoc | 6 +--
.../camel-jms/src/main/docs/jms-component.adoc | 6 +--
.../apache/camel/component/jms/JmsComponent.java | 11 +++-
.../camel/component/jms/JmsConfiguration.java | 12 ++++-
.../dsl/ActiveMQEndpointBuilderFactory.java | 60 +++++++++++++++++++---
.../endpoint/dsl/JmsEndpointBuilderFactory.java | 60 +++++++++++++++++++---
.../springboot/ActiveMQComponentConfiguration.java | 5 +-
.../jms/springboot/JmsComponentConfiguration.java | 15 +++++-
8 files changed, 150 insertions(+), 25 deletions(-)
diff --git a/components/camel-activemq/src/main/docs/activemq-component.adoc b/components/camel-activemq/src/main/docs/activemq-component.adoc
index ab5fc9a..f357782 100644
--- a/components/camel-activemq/src/main/docs/activemq-component.adoc
+++ b/components/camel-activemq/src/main/docs/activemq-component.adoc
@@ -111,7 +111,7 @@ The ActiveMQ component supports 85 options, which are listed below.
| *requestTimeout* (producer) | 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. | 20000 | long
| *requestTimeoutChecker Interval* (advanced) | 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. | 1000 | long
| *transferExchange* (advanced) | 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 E [...]
-| *transferException* (advanced) | 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 preced [...]
+| *transferException* (advanced) | 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 preced [...]
| *jmsOperations* (advanced) | 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. | | JmsOperations
| *destinationResolver* (advanced) | 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). | | DestinationResolver
| *replyToType* (producer) | 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 [...]
@@ -246,8 +246,8 @@ with the following path and query parameters:
| *recoveryInterval* (advanced) | 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. | 5000 | long
| *requestTimeoutChecker Interval* (advanced) | 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. | 1000 | long
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
-| *transferException* (advanced) | 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 preced [...]
-| *transferExchange* (advanced) | 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 E [...]
+| *transferException* (advanced) | 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 preced [...]
+| *transferExchange* (advanced) | 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 E [...]
| *useMessageIDAsCorrelation ID* (advanced) | Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *waitForProvisionCorrelation ToBeUpdatedCounter* (advanced) | 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. | 50 | int
| *waitForProvisionCorrelation ToBeUpdatedThreadSleeping Time* (advanced) | Interval in millis to sleep each time while waiting for provisional correlation id to be updated. | 100 | long
diff --git a/components/camel-jms/src/main/docs/jms-component.adoc b/components/camel-jms/src/main/docs/jms-component.adoc
index 95ee60a..0bdd271 100644
--- a/components/camel-jms/src/main/docs/jms-component.adoc
+++ b/components/camel-jms/src/main/docs/jms-component.adoc
@@ -254,7 +254,7 @@ The JMS component supports 80 options, which are listed below.
| *requestTimeout* (producer) | 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. | 20000 | long
| *requestTimeoutChecker Interval* (advanced) | 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. | 1000 | long
| *transferExchange* (advanced) | 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 E [...]
-| *transferException* (advanced) | 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 preced [...]
+| *transferException* (advanced) | 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 preced [...]
| *jmsOperations* (advanced) | 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. | | JmsOperations
| *destinationResolver* (advanced) | 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). | | DestinationResolver
| *replyToType* (producer) | 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 [...]
@@ -403,8 +403,8 @@ with the following path and query parameters:
| *recoveryInterval* (advanced) | 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. | 5000 | long
| *requestTimeoutChecker Interval* (advanced) | 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. | 1000 | long
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
-| *transferException* (advanced) | 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 preced [...]
-| *transferExchange* (advanced) | 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 E [...]
+| *transferException* (advanced) | 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 preced [...]
+| *transferExchange* (advanced) | 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 E [...]
| *useMessageIDAsCorrelation ID* (advanced) | Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *waitForProvisionCorrelation ToBeUpdatedCounter* (advanced) | 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. | 50 | int
| *waitForProvisionCorrelation ToBeUpdatedThreadSleeping Time* (advanced) | Interval in millis to sleep each time while waiting for provisional correlation id to be updated. | 100 | long
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 a46346c..1c146c4 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
@@ -817,7 +817,9 @@ public class JmsComponent extends HeaderFilterStrategyComponent implements Appli
+ " 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.")
+ + " 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."
+ + " Use this with caution as the data is using Java Object serialization and requires the received to be able to deserialize the data at Class level, "
+ + " which forces a strong coupling between the producers and consumer having to use compatible Camel versions!")
public void setTransferExchange(boolean transferExchange) {
getConfiguration().setTransferExchange(transferExchange);
}
@@ -831,6 +833,9 @@ public class JmsComponent extends HeaderFilterStrategyComponent implements Appli
* 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.
+ * Use this with caution as the data is using Java Object serialization and requires the received to be able to deserialize the data at Class level,
+ * which forces a strong coupling between the producers and consumer!
+ *
*/
@Metadata(label = "advanced",
description = "If enabled and you are using Request Reply messaging (InOut) and an Exchange failed on the consumer side,"
@@ -840,7 +845,9 @@ public class JmsComponent extends HeaderFilterStrategyComponent implements Appli
+ " 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.")
+ + " such as org.apache.camel.RuntimeCamelException when returned to the producer."
+ + " Use this with caution as the data is using Java Object serialization and requires the received to be able to deserialize the data at Class level, "
+ + " which forces a strong coupling between the producers and consumer!")
public void setTransferException(boolean transferException) {
getConfiguration().setTransferException(transferException);
}
diff --git a/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java b/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
index cad5e0d..47ec84c 100644
--- a/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
+++ b/components/camel-jms/src/main/java/org/apache/camel/component/jms/JmsConfiguration.java
@@ -322,7 +322,9 @@ public class JmsConfiguration implements Cloneable {
+ " 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.")
+ + " 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."
+ + " Use this with caution as the data is using Java Object serialization and requires the received to be able to deserialize the data at Class level, "
+ + " which forces a strong coupling between the producers and consumer having to use compatible Camel versions!")
private boolean transferExchange;
@UriParam(label = "advanced",
description = "Controls whether or not to include serialized headers."
@@ -337,7 +339,9 @@ public class JmsConfiguration implements Cloneable {
+ " 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.")
+ + " such as org.apache.camel.RuntimeCamelException when returned to the producer."
+ + " Use this with caution as the data is using Java Object serialization and requires the received to be able to deserialize the data at Class level, "
+ + " which forces a strong coupling between the producers and consumer!")
private boolean transferException;
@UriParam(description = "Specifies whether to test the connection on startup."
+ " This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker."
@@ -1797,6 +1801,8 @@ public class JmsConfiguration implements Cloneable {
* 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.
+ * Use this with caution as the data is using Java Object serialization and requires the received to be able to deserialize the data at Class level,
+ * which forces a strong coupling between the producers and consumer having to use compatible Camel versions!
*/
public void setTransferExchange(boolean transferExchange) {
this.transferExchange = transferExchange;
@@ -1828,6 +1834,8 @@ public class JmsConfiguration implements Cloneable {
* 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.
+ * Use this with caution as the data is using Java Object serialization and requires the received to be able to deserialize the data at Class level,
+ * which forces a strong coupling between the producers and consumer!
*/
public void setTransferException(boolean transferException) {
this.transferException = transferException;
diff --git a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/ActiveMQEndpointBuilderFactory.java b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/ActiveMQEndpointBuilderFactory.java
index f1c79dd..5205408 100644
--- a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/ActiveMQEndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/ActiveMQEndpointBuilderFactory.java
@@ -1764,6 +1764,10 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option is a: <code>boolean</code> type.
*
@@ -1785,6 +1789,10 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -1803,7 +1811,11 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option is a: <code>boolean</code> type.
*
@@ -1822,7 +1834,11 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -3658,6 +3674,10 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option is a: <code>boolean</code> type.
*
@@ -3679,6 +3699,10 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -3697,7 +3721,11 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option is a: <code>boolean</code> type.
*
@@ -3716,7 +3744,11 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -4865,6 +4897,10 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option is a: <code>boolean</code> type.
*
@@ -4886,6 +4922,10 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -4904,7 +4944,11 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option is a: <code>boolean</code> type.
*
@@ -4923,7 +4967,11 @@ public interface ActiveMQEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option will be converted to a <code>boolean</code> type.
*
diff --git a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/JmsEndpointBuilderFactory.java b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/JmsEndpointBuilderFactory.java
index 347aa2d..ffd9ad2 100644
--- a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/JmsEndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/JmsEndpointBuilderFactory.java
@@ -1758,6 +1758,10 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option is a: <code>boolean</code> type.
*
@@ -1779,6 +1783,10 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -1797,7 +1805,11 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option is a: <code>boolean</code> type.
*
@@ -1816,7 +1828,11 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -3645,6 +3661,10 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option is a: <code>boolean</code> type.
*
@@ -3666,6 +3686,10 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -3684,7 +3708,11 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option is a: <code>boolean</code> type.
*
@@ -3703,7 +3731,11 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -4843,6 +4875,10 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option is a: <code>boolean</code> type.
*
@@ -4864,6 +4900,10 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!.
*
* The option will be converted to a <code>boolean</code> type.
*
@@ -4882,7 +4922,11 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option is a: <code>boolean</code> type.
*
@@ -4901,7 +4945,11 @@ public interface JmsEndpointBuilderFactory {
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!.
*
* The option will be converted to a <code>boolean</code> type.
*
diff --git a/platforms/spring-boot/components-starter/camel-activemq-starter/src/main/java/org/apache/camel/component/activemq/springboot/ActiveMQComponentConfiguration.java b/platforms/spring-boot/components-starter/camel-activemq-starter/src/main/java/org/apache/camel/component/activemq/springboot/ActiveMQComponentConfiguration.java
index 1206a92..1fe6bf3 100644
--- a/platforms/spring-boot/components-starter/camel-activemq-starter/src/main/java/org/apache/camel/component/activemq/springboot/ActiveMQComponentConfiguration.java
+++ b/platforms/spring-boot/components-starter/camel-activemq-starter/src/main/java/org/apache/camel/component/activemq/springboot/ActiveMQComponentConfiguration.java
@@ -441,7 +441,10 @@ public class ActiveMQComponentConfiguration
* 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.
+ * org.apache.camel.RuntimeCamelException when returned to the producer. Use
+ * this with caution as the data is using Java Object serialization and
+ * requires the received to be able to deserialize the data at Class level,
+ * which forces a strong coupling between the producers and consumer!
*/
private Boolean transferException = false;
/**
diff --git a/platforms/spring-boot/components-starter/camel-jms-starter/src/main/java/org/apache/camel/component/jms/springboot/JmsComponentConfiguration.java b/platforms/spring-boot/components-starter/camel-jms-starter/src/main/java/org/apache/camel/component/jms/springboot/JmsComponentConfiguration.java
index e5c1fdd..52c0d11 100644
--- a/platforms/spring-boot/components-starter/camel-jms-starter/src/main/java/org/apache/camel/component/jms/springboot/JmsComponentConfiguration.java
+++ b/platforms/spring-boot/components-starter/camel-jms-starter/src/main/java/org/apache/camel/component/jms/springboot/JmsComponentConfiguration.java
@@ -420,7 +420,10 @@ public class JmsComponentConfiguration
* 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.
+ * org.apache.camel.RuntimeCamelException when returned to the producer. Use
+ * this with caution as the data is using Java Object serialization and
+ * requires the received to be able to deserialize the data at Class level,
+ * which forces a strong coupling between the producers and consumer!
*/
private Boolean transferException = false;
/**
@@ -1709,7 +1712,11 @@ public class JmsComponentConfiguration
* 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.
+ * a regular payload. Use this with caution as the data is using Java
+ * Object serialization and requires the received to be able to
+ * deserialize the data at Class level, which forces a strong coupling
+ * between the producers and consumer having to use compatible Camel
+ * versions!
*/
private Boolean transferExchange = false;
/**
@@ -1730,6 +1737,10 @@ public class JmsComponentConfiguration
* 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.
+ * Use this with caution as the data is using Java Object serialization
+ * and requires the received to be able to deserialize the data at Class
+ * level, which forces a strong coupling between the producers and
+ * consumer!
*/
private Boolean transferException = false;
/**