camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From acosent...@apache.org
Subject [camel] 11/20: Improve configurability re build project
Date Wed, 21 Aug 2019 07:58:06 GMT
This is an automated email from the ASF dual-hosted git repository.

acosentino pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git

commit 1e147a350b8454b0e267deef59645820b50dfb90
Author: Roberto Flores <betoflowv93@gmail.com>
AuthorDate: Mon Jul 15 07:17:00 2019 -0500

    Improve configurability
    re build project
---
 .../src/main/docs/browse-component.adoc            |  1 +
 .../src/main/docs/controlbus-component.adoc        |  1 +
 .../src/main/docs/dataformat-component.adoc        |  1 +
 .../src/main/docs/direct-component.adoc            |  1 +
 .../src/main/docs/direct-vm-component.adoc         |  1 +
 .../camel-log/src/main/docs/log-component.adoc     |  1 +
 .../camel-ref/src/main/docs/ref-component.adoc     |  1 +
 .../camel-saga/src/main/docs/saga-component.adoc   |  1 +
 .../camel-seda/src/main/docs/seda-component.adoc   |  1 +
 .../camel-stub/src/main/docs/stub-component.adoc   |  1 +
 .../src/main/docs/validator-component.adoc         |  1 +
 .../camel-vm/src/main/docs/vm-component.adoc       |  1 +
 .../camel-xslt/src/main/docs/xslt-component.adoc   |  1 +
 components/readme.adoc                             |  2 +-
 .../org/apache/camel/builder/DataFormatClause.java |  8 ++--
 .../camel/model/dataformat/Any23DataFormat.java    | 48 ++++++++++++----------
 .../apache/camel/model/dataformat/Any23Type.java   | 30 ++++++++++++++
 .../reifier/dataformat/Any23DataFormatReifier.java | 18 +++++---
 .../endpoint/dsl/BrowseEndpointBuilderFactory.java | 40 ++++++++++++++++++
 .../endpoint/dsl/DirectEndpointBuilderFactory.java | 40 ++++++++++++++++++
 .../dsl/DirectVmEndpointBuilderFactory.java        | 40 ++++++++++++++++++
 .../endpoint/dsl/RefEndpointBuilderFactory.java    | 40 ++++++++++++++++++
 .../endpoint/dsl/SedaEndpointBuilderFactory.java   | 40 ++++++++++++++++++
 .../endpoint/dsl/StubEndpointBuilderFactory.java   | 40 ++++++++++++++++++
 .../endpoint/dsl/VmEndpointBuilderFactory.java     | 40 ++++++++++++++++++
 .../modules/ROOT/pages/any23-dataformat.adoc       | 15 ++++---
 .../springboot/Any23DataFormatConfiguration.java   | 26 ++++--------
 27 files changed, 383 insertions(+), 57 deletions(-)

diff --git a/components/camel-browse/src/main/docs/browse-component.adoc b/components/camel-browse/src/main/docs/browse-component.adoc
index fde908d..f9a6cce 100644
--- a/components/camel-browse/src/main/docs/browse-component.adoc
+++ b/components/camel-browse/src/main/docs/browse-component.adoc
@@ -63,6 +63,7 @@ with the following path and query parameters:
 | *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
 | *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
 | *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
 | *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
 |===
diff --git a/components/camel-controlbus/src/main/docs/controlbus-component.adoc b/components/camel-controlbus/src/main/docs/controlbus-component.adoc
index 330d620..c9197fc 100644
--- a/components/camel-controlbus/src/main/docs/controlbus-component.adoc
+++ b/components/camel-controlbus/src/main/docs/controlbus-component.adoc
@@ -94,6 +94,7 @@ with the following path and query parameters:
 | Name | Description | Default | Type
 | *action* (producer) | To denote an action that can be either: start, stop, or status. To either start or stop a route, or to get the status of the route as output in the message body. You can use suspend and resume from Camel 2.11.1 onwards to either suspend or resume a route. And from Camel 2.11.1 onwards you can use stats to get performance statics returned in XML format; the routeId option can be used to define which route to get the performance stats for, if routeId is not defined, [...]
 | *async* (producer) | Whether to execute the control bus task asynchronously. Important: If this option is enabled, then any result from the task is not set on the Exchange. This is only possible if executing tasks synchronously. | false | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *loggingLevel* (producer) | Logging level used for logging when task is done, or if any exceptions occurred during processing the task. | INFO | LoggingLevel
 | *restartDelay* (producer) | The delay in millis to use when restarting a route. | 1000 | int
 | *routeId* (producer) | To specify a route by its id. The special keyword current indicates the current route. |  | String
diff --git a/components/camel-dataformat/src/main/docs/dataformat-component.adoc b/components/camel-dataformat/src/main/docs/dataformat-component.adoc
index 53bcf31..badbcec 100644
--- a/components/camel-dataformat/src/main/docs/dataformat-component.adoc
+++ b/components/camel-dataformat/src/main/docs/dataformat-component.adoc
@@ -62,6 +62,7 @@ with the following path and query parameters:
 [width="100%",cols="2,5,^1,2",options="header"]
 |===
 | Name | Description | Default | Type
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
 | *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
 |===
diff --git a/components/camel-direct/src/main/docs/direct-component.adoc b/components/camel-direct/src/main/docs/direct-component.adoc
index 0f0b97a..6fa7ecb 100644
--- a/components/camel-direct/src/main/docs/direct-component.adoc
+++ b/components/camel-direct/src/main/docs/direct-component.adoc
@@ -76,6 +76,7 @@ with the following path and query parameters:
 | *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
 | *block* (producer) | If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. | true | boolean
 | *failIfNoConsumers* (producer) | Whether the producer should fail by throwing an exception, when sending to a DIRECT endpoint with no active consumers. | false | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *timeout* (producer) | The timeout value to use if block is enabled. | 30000 | long
 | *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
 | *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
diff --git a/components/camel-directvm/src/main/docs/direct-vm-component.adoc b/components/camel-directvm/src/main/docs/direct-vm-component.adoc
index 6374afd..f05c78d 100644
--- a/components/camel-directvm/src/main/docs/direct-vm-component.adoc
+++ b/components/camel-directvm/src/main/docs/direct-vm-component.adoc
@@ -89,6 +89,7 @@ with the following path and query parameters:
 | *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
 | *block* (producer) | If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. | true | boolean
 | *failIfNoConsumers* (producer) | Whether the producer should fail by throwing an exception, when sending to a Direct-VM endpoint with no active consumers. | false | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *timeout* (producer) | The timeout value to use if block is enabled. | 30000 | long
 | *headerFilterStrategy* (producer) | Sets a HeaderFilterStrategy that will only be applied on producer endpoints (on both directions: request and response). Default value: none. |  | HeaderFilterStrategy
 | *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
diff --git a/components/camel-log/src/main/docs/log-component.adoc b/components/camel-log/src/main/docs/log-component.adoc
index 0bc0ae6..23a7668 100644
--- a/components/camel-log/src/main/docs/log-component.adoc
+++ b/components/camel-log/src/main/docs/log-component.adoc
@@ -103,6 +103,7 @@ with the following path and query parameters:
 | *groupDelay* (producer) | Set the initial delay for stats (in millis) |  | Long
 | *groupInterval* (producer) | If specified will group message stats by this time interval (in millis) |  | Long
 | *groupSize* (producer) | An integer that specifies a group size for throughput logging. |  | Integer
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *level* (producer) | Logging level to use. The default value is INFO. | INFO | String
 | *logMask* (producer) | If true, mask sensitive information like password or passphrase in the log. |  | Boolean
 | *marker* (producer) | An optional Marker name to use. |  | String
diff --git a/components/camel-ref/src/main/docs/ref-component.adoc b/components/camel-ref/src/main/docs/ref-component.adoc
index 670291c..83c8427 100644
--- a/components/camel-ref/src/main/docs/ref-component.adoc
+++ b/components/camel-ref/src/main/docs/ref-component.adoc
@@ -61,6 +61,7 @@ with the following path and query parameters:
 | *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
 | *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
 | *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
 | *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
 |===
diff --git a/components/camel-saga/src/main/docs/saga-component.adoc b/components/camel-saga/src/main/docs/saga-component.adoc
index 001c30c..4db0a8f 100644
--- a/components/camel-saga/src/main/docs/saga-component.adoc
+++ b/components/camel-saga/src/main/docs/saga-component.adoc
@@ -57,6 +57,7 @@ with the following path and query parameters:
 [width="100%",cols="2,5,^1,2",options="header"]
 |===
 | Name | Description | Default | Type
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
 | *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
 |===
diff --git a/components/camel-seda/src/main/docs/seda-component.adoc b/components/camel-seda/src/main/docs/seda-component.adoc
index fc05cbf..37219bd 100644
--- a/components/camel-seda/src/main/docs/seda-component.adoc
+++ b/components/camel-seda/src/main/docs/seda-component.adoc
@@ -93,6 +93,7 @@ with the following path and query parameters:
 | *blockWhenFull* (producer) | Whether a thread that sends messages to a full SEDA queue will block until the queue's capacity is no longer exhausted. By default, an exception will be thrown stating that the queue is full. By enabling this option, the calling thread will instead block and wait until the message can be accepted. | false | boolean
 | *discardIfNoConsumers* (producer) | Whether the producer should discard the message (do not add the message to the queue), when sending to a queue with no active consumers. Only one of the options discardIfNoConsumers and failIfNoConsumers can be enabled at the same time. | false | boolean
 | *failIfNoConsumers* (producer) | Whether the producer should fail by throwing an exception, when sending to a queue with no active consumers. Only one of the options discardIfNoConsumers and failIfNoConsumers can be enabled at the same time. | false | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *offerTimeout* (producer) | offerTimeout (in milliseconds) can be added to the block case when queue is full. You can disable timeout by using 0 or a negative value. |  | long
 | *timeout* (producer) | Timeout (in milliseconds) before a SEDA producer will stop waiting for an asynchronous task to complete. You can disable timeout by using 0 or a negative value. | 30000 | long
 | *waitForTaskToComplete* (producer) | Option to specify whether the caller should wait for the async task to complete or not before continuing. The following three options are supported: Always, Never or IfReplyExpected. The first two values are self-explanatory. The last value, IfReplyExpected, will only wait if the message is Request Reply based. The default option is IfReplyExpected. | IfReplyExpected | WaitForTaskToComplete
diff --git a/components/camel-stub/src/main/docs/stub-component.adoc b/components/camel-stub/src/main/docs/stub-component.adoc
index f3cc091..16e321f 100644
--- a/components/camel-stub/src/main/docs/stub-component.adoc
+++ b/components/camel-stub/src/main/docs/stub-component.adoc
@@ -83,6 +83,7 @@ with the following path and query parameters:
 | *blockWhenFull* (producer) | Whether a thread that sends messages to a full SEDA queue will block until the queue's capacity is no longer exhausted. By default, an exception will be thrown stating that the queue is full. By enabling this option, the calling thread will instead block and wait until the message can be accepted. | false | boolean
 | *discardIfNoConsumers* (producer) | Whether the producer should discard the message (do not add the message to the queue), when sending to a queue with no active consumers. Only one of the options discardIfNoConsumers and failIfNoConsumers can be enabled at the same time. | false | boolean
 | *failIfNoConsumers* (producer) | Whether the producer should fail by throwing an exception, when sending to a queue with no active consumers. Only one of the options discardIfNoConsumers and failIfNoConsumers can be enabled at the same time. | false | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *offerTimeout* (producer) | offerTimeout (in milliseconds) can be added to the block case when queue is full. You can disable timeout by using 0 or a negative value. |  | long
 | *timeout* (producer) | Timeout (in milliseconds) before a SEDA producer will stop waiting for an asynchronous task to complete. You can disable timeout by using 0 or a negative value. | 30000 | long
 | *waitForTaskToComplete* (producer) | Option to specify whether the caller should wait for the async task to complete or not before continuing. The following three options are supported: Always, Never or IfReplyExpected. The first two values are self-explanatory. The last value, IfReplyExpected, will only wait if the message is Request Reply based. The default option is IfReplyExpected. | IfReplyExpected | WaitForTaskToComplete
diff --git a/components/camel-validator/src/main/docs/validator-component.adoc b/components/camel-validator/src/main/docs/validator-component.adoc
index 0bec4d9..50617ce 100644
--- a/components/camel-validator/src/main/docs/validator-component.adoc
+++ b/components/camel-validator/src/main/docs/validator-component.adoc
@@ -80,6 +80,7 @@ with the following path and query parameters:
 | *failOnNullBody* (producer) | Whether to fail if no body exists. | true | boolean
 | *failOnNullHeader* (producer) | Whether to fail if no header exists when validating against a header. | true | boolean
 | *headerName* (producer) | To validate against a header instead of the message body. |  | String
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
 | *errorHandler* (advanced) | To use a custom org.apache.camel.processor.validation.ValidatorErrorHandler. The default error handler captures the errors and throws an exception. |  | ValidatorErrorHandler
 | *resourceResolver* (advanced) | To use a custom LSResourceResolver. See also setResourceResolverFactory(ValidatorResourceResolverFactory) |  | LSResourceResolver
diff --git a/components/camel-vm/src/main/docs/vm-component.adoc b/components/camel-vm/src/main/docs/vm-component.adoc
index ebf0120..dcb1fde 100644
--- a/components/camel-vm/src/main/docs/vm-component.adoc
+++ b/components/camel-vm/src/main/docs/vm-component.adoc
@@ -96,6 +96,7 @@ with the following path and query parameters:
 | *blockWhenFull* (producer) | Whether a thread that sends messages to a full SEDA queue will block until the queue's capacity is no longer exhausted. By default, an exception will be thrown stating that the queue is full. By enabling this option, the calling thread will instead block and wait until the message can be accepted. | false | boolean
 | *discardIfNoConsumers* (producer) | Whether the producer should discard the message (do not add the message to the queue), when sending to a queue with no active consumers. Only one of the options discardIfNoConsumers and failIfNoConsumers can be enabled at the same time. | false | boolean
 | *failIfNoConsumers* (producer) | Whether the producer should fail by throwing an exception, when sending to a queue with no active consumers. Only one of the options discardIfNoConsumers and failIfNoConsumers can be enabled at the same time. | false | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *offerTimeout* (producer) | offerTimeout (in milliseconds) can be added to the block case when queue is full. You can disable timeout by using 0 or a negative value. |  | long
 | *timeout* (producer) | Timeout (in milliseconds) before a SEDA producer will stop waiting for an asynchronous task to complete. You can disable timeout by using 0 or a negative value. | 30000 | long
 | *waitForTaskToComplete* (producer) | Option to specify whether the caller should wait for the async task to complete or not before continuing. The following three options are supported: Always, Never or IfReplyExpected. The first two values are self-explanatory. The last value, IfReplyExpected, will only wait if the message is Request Reply based. The default option is IfReplyExpected. | IfReplyExpected | WaitForTaskToComplete
diff --git a/components/camel-xslt/src/main/docs/xslt-component.adoc b/components/camel-xslt/src/main/docs/xslt-component.adoc
index 13a41c5..e4b1a5218 100644
--- a/components/camel-xslt/src/main/docs/xslt-component.adoc
+++ b/components/camel-xslt/src/main/docs/xslt-component.adoc
@@ -88,6 +88,7 @@ with the following path and query parameters:
 | *contentCache* (producer) | Cache for the resource content (the stylesheet file) when it is loaded. If set to false Camel will reload the stylesheet file on each message processing. This is good for development. A cached stylesheet can be forced to reload at runtime via JMX using the clearCachedStylesheet operation. | true | boolean
 | *deleteOutputFile* (producer) | If you have output=file then this option dictates whether or not the output file should be deleted when the Exchange is done processing. For example suppose the output file is a temporary file, then it can be a good idea to delete it after use. | false | boolean
 | *failOnNullBody* (producer) | Whether or not to throw an exception if the input body is null. | true | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
 | *output* (producer) | Option to specify which output type to use. Possible values are: string, bytes, DOM, file. The first three options are all in memory based, where as file is streamed directly to a java.io.File. For file you must specify the filename in the IN header with the key Exchange.XSLT_FILE_NAME which is also CamelXsltFileName. Also any paths leading to the filename must be created beforehand, otherwise an exception is thrown at runtime. | string | XsltOutput
 | *saxon* (producer) | Whether to use Saxon as the transformerFactoryClass. If enabled then the class net.sf.saxon.TransformerFactoryImpl. You would need to add Saxon to the classpath. | false | boolean
 | *transformerCacheSize* (producer) | The number of javax.xml.transform.Transformer object that are cached for reuse to avoid calls to Template.newTransformer(). | 0 | int
diff --git a/components/readme.adoc b/components/readme.adoc
index 4364608..5043495 100644
--- a/components/readme.adoc
+++ b/components/readme.adoc
@@ -908,7 +908,7 @@ Number of Data Formats: 44 in 36 JAR artifacts (0 deprecated)
 |===
 | Data Format | Available From | Description
 
-| link:camel-any23/src/main/docs/any23-dataformat.adoc[Any23] (camel-any23) | 1.0 | Any23 data format is used for parsing data to RDF.
+| link:camel-any23/src/main/docs/any23-dataformat.adoc[Any23] (camel-any23) | 3.0 | Any23 data format is used for parsing data to RDF.
 
 | link:camel-asn1/src/main/docs/asn1-dataformat.adoc[ASN.1 File] (camel-asn1) | 2.20 | The ASN.1 data format is used for file transfer with telecommunications protocols.
 
diff --git a/core/camel-core/src/main/java/org/apache/camel/builder/DataFormatClause.java b/core/camel-core/src/main/java/org/apache/camel/builder/DataFormatClause.java
index b14d1d4..048a286 100644
--- a/core/camel-core/src/main/java/org/apache/camel/builder/DataFormatClause.java
+++ b/core/camel-core/src/main/java/org/apache/camel/builder/DataFormatClause.java
@@ -17,6 +17,7 @@
 package org.apache.camel.builder;
 
 import java.nio.charset.Charset;
+import java.util.List;
 import java.util.Map;
 
 import org.w3c.dom.Node;
@@ -25,6 +26,7 @@ import org.apache.camel.model.DataFormatDefinition;
 import org.apache.camel.model.ProcessorDefinition;
 import org.apache.camel.model.dataformat.Any23DataFormat;
 import org.apache.camel.model.dataformat.ASN1DataFormat;
+import org.apache.camel.model.dataformat.Any23Type;
 import org.apache.camel.model.dataformat.AvroDataFormat;
 import org.apache.camel.model.dataformat.Base64DataFormat;
 import org.apache.camel.model.dataformat.BeanioDataFormat;
@@ -93,15 +95,15 @@ public class DataFormatClause<T extends ProcessorDefinition<?>> {
     return dataFormat(new Any23DataFormat(baseuri));
   }
 
-  public T any23(String baseuri, String outputformat) {
+  public T any23(String baseuri, Any23Type outputformat) {
     return dataFormat(new Any23DataFormat(baseuri, outputformat));
   }
 
-  public T any23(String baseuri, String outputformat, String configurations) {
+  public T any23(String baseuri, Any23Type outputformat, Map<String, String> configurations) {
     return dataFormat(new Any23DataFormat(baseuri, outputformat, configurations));
   }
 
-  public T any23(String baseuri, String outputformat, String configurations, String extractors) {
+  public T any23(String baseuri, Any23Type outputformat, Map<String, String> configurations, List<String> extractors) {
     return dataFormat(new Any23DataFormat(baseuri, outputformat, configurations, extractors));
   }
 
diff --git a/core/camel-core/src/main/java/org/apache/camel/model/dataformat/Any23DataFormat.java b/core/camel-core/src/main/java/org/apache/camel/model/dataformat/Any23DataFormat.java
index ecfde71..2b9180e 100644
--- a/core/camel-core/src/main/java/org/apache/camel/model/dataformat/Any23DataFormat.java
+++ b/core/camel-core/src/main/java/org/apache/camel/model/dataformat/Any23DataFormat.java
@@ -16,9 +16,12 @@
  */
 package org.apache.camel.model.dataformat;
 
+import java.util.List;
+import java.util.Map;
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlRootElement;
 import org.apache.camel.model.DataFormatDefinition;
 import org.apache.camel.spi.Metadata;
@@ -26,20 +29,20 @@ import org.apache.camel.spi.Metadata;
 /**
  * Any23 data format is used for parsing data to RDF.
  */
-@Metadata(firstVersion = "1.0.0", label = "dataformat,transformation", title = "Any23")
+@Metadata(firstVersion = "3.0.0", label = "dataformat,transformation", title = "Any23")
 @XmlRootElement(name = "any23")
 @XmlAccessorType(XmlAccessType.FIELD)
 public class Any23DataFormat extends DataFormatDefinition {
 
   @XmlAttribute
-  @Metadata(defaultValue = "MODEL")
-  private String outputFormat;
+  @Metadata(defaultValue = "RDFXML")
+  private Any23Type outputFormat;
+  @XmlElement
+  private Map<String, String> configurations;
+  @XmlElement
+  private List<String> extractors;
   @XmlAttribute
-  private String configurations;
-  @XmlAttribute
-  private String extractors;
-  @XmlAttribute
-  private String baseuri;
+  private String baseURI;
 
   public Any23DataFormat() {
     super("any23");
@@ -47,57 +50,58 @@ public class Any23DataFormat extends DataFormatDefinition {
 
   public Any23DataFormat(String baseuri) {
     this();
-    this.baseuri = baseuri;
+    this.baseURI = baseuri;
   }
 
-  public Any23DataFormat(String baseuri, String outputFormat) {
+  public Any23DataFormat(String baseuri, Any23Type outputFormat) {
     this(baseuri);
     this.outputFormat = outputFormat;
   }
 
-  public Any23DataFormat(String baseuri, String outputFormat, String configurations) {
+  public Any23DataFormat(String baseuri, Any23Type outputFormat, Map<String, String> configurations) {
     this(baseuri, outputFormat);
     this.outputFormat = outputFormat;
     this.configurations = configurations;
   }
 
-  public Any23DataFormat(String baseuri, String outputFormat, String configurations, String extractors) {
+  public Any23DataFormat(String baseuri, Any23Type outputFormat, Map<String, String> configurations, List<String> extractors) {
     this(baseuri, outputFormat, configurations);
     this.outputFormat = outputFormat;
     this.configurations = configurations;
     this.extractors = extractors;
   }
 
-  public String getOutputFormat() {
+  public Any23Type getOutputFormat() {
     return outputFormat;
   }
 
-  public void setOutputFormat(String outputFormat) {
+  public void setOutputFormat(Any23Type outputFormat) {
     this.outputFormat = outputFormat;
   }
 
-  public String getConfigurations() {
+  public Map<String, String> getConfigurations() {
     return configurations;
   }
 
-  public void setConfigurations(String configurations) {
+  public void setConfigurations(Map<String, String> configurations) {
     this.configurations = configurations;
   }
 
-  public String getExtractors() {
+  public List<String> getExtractors() {
     return extractors;
   }
 
-  public void setExtractors(String extractors) {
+  public void setExtractors(List<String> extractors) {
     this.extractors = extractors;
   }
 
-  public String getBaseuri() {
-    return baseuri;
+  public String getBaseURI() {
+    return baseURI;
   }
 
-  public void setBaseuri(String baseuri) {
-    this.baseuri = baseuri;
+  public void setBaseURI(String baseURI) {
+    this.baseURI = baseURI;
   }
 
+  
 }
diff --git a/core/camel-core/src/main/java/org/apache/camel/model/dataformat/Any23Type.java b/core/camel-core/src/main/java/org/apache/camel/model/dataformat/Any23Type.java
new file mode 100644
index 0000000..bdd0a59
--- /dev/null
+++ b/core/camel-core/src/main/java/org/apache/camel/model/dataformat/Any23Type.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.model.dataformat;
+
+import javax.xml.bind.annotation.XmlEnum;
+import javax.xml.bind.annotation.XmlType;
+
+/**
+ * Represents the different types of bindy data formats.
+ */
+@XmlType
+@XmlEnum
+public enum Any23Type {
+
+  NTRIPLES, TURTLE, NQUADS, RDFXML, JSONLD, RDFJSON
+}
diff --git a/core/camel-core/src/main/java/org/apache/camel/reifier/dataformat/Any23DataFormatReifier.java b/core/camel-core/src/main/java/org/apache/camel/reifier/dataformat/Any23DataFormatReifier.java
index 72adb99..8f33e6a 100644
--- a/core/camel-core/src/main/java/org/apache/camel/reifier/dataformat/Any23DataFormatReifier.java
+++ b/core/camel-core/src/main/java/org/apache/camel/reifier/dataformat/Any23DataFormatReifier.java
@@ -29,12 +29,18 @@ public class Any23DataFormatReifier extends DataFormatReifier<Any23DataFormat> {
 
   @Override
   protected void configureDataFormat(DataFormat dataFormat, CamelContext camelContext) {
-//    if (definition.getDataObjectType() != null) {
-//      setProperty(camelContext, dataFormat, "dataObjectType", definition.getDataObjectType());
-//    }
-//    if (definition.getOmitXmlDeclaration() != null) {
-//      setProperty(camelContext, dataFormat, "omitXmlDeclaration", definition.getOmitXmlDeclaration());
-//    }
+    if (definition.getOutputFormat() != null) {
+      setProperty(camelContext, dataFormat, "outputFormat", definition.getOutputFormat());
+    }
+    if (definition.getConfigurations() != null) {
+      setProperty(camelContext, dataFormat, "configurations", definition.getConfigurations());
+    }
+    if (definition.getExtractors() != null) {
+      setProperty(camelContext, dataFormat, "extractors", definition.getExtractors());
+    }
+    if (definition.getBaseURI() != null) {
+      setProperty(camelContext, dataFormat, "baseURI", definition.getBaseURI());
+    }
   }
 
 }
diff --git a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/BrowseEndpointBuilderFactory.java b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/BrowseEndpointBuilderFactory.java
index d9c39e6..5e0b7df 100644
--- a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/BrowseEndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/BrowseEndpointBuilderFactory.java
@@ -209,6 +209,46 @@ public interface BrowseEndpointBuilderFactory {
         default AdvancedBrowseEndpointProducerBuilder advanced() {
             return (AdvancedBrowseEndpointProducerBuilder) this;
         }
+        /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option is a: <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default BrowseEndpointProducerBuilder lazyStartProducer(
+                boolean lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option will be converted to a <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default BrowseEndpointProducerBuilder lazyStartProducer(
+                String lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
     }
 
     /**
diff --git a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/DirectEndpointBuilderFactory.java b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/DirectEndpointBuilderFactory.java
index 88ab34d..bb7ca5c 100644
--- a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/DirectEndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/DirectEndpointBuilderFactory.java
@@ -262,6 +262,46 @@ public interface DirectEndpointBuilderFactory {
             return this;
         }
         /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option is a: <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default DirectEndpointProducerBuilder lazyStartProducer(
+                boolean lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option will be converted to a <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default DirectEndpointProducerBuilder lazyStartProducer(
+                String lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
          * The timeout value to use if block is enabled.
          * 
          * The option is a: <code>long</code> type.
diff --git a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/DirectVmEndpointBuilderFactory.java b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/DirectVmEndpointBuilderFactory.java
index 11efea0..8ab01c3 100644
--- a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/DirectVmEndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/DirectVmEndpointBuilderFactory.java
@@ -289,6 +289,46 @@ public interface DirectVmEndpointBuilderFactory {
             return this;
         }
         /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option is a: <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default DirectVmEndpointProducerBuilder lazyStartProducer(
+                boolean lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option will be converted to a <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default DirectVmEndpointProducerBuilder lazyStartProducer(
+                String lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
          * The timeout value to use if block is enabled.
          * 
          * The option is a: <code>long</code> type.
diff --git a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/RefEndpointBuilderFactory.java b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/RefEndpointBuilderFactory.java
index ca6d158..269dfb8 100644
--- a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/RefEndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/RefEndpointBuilderFactory.java
@@ -209,6 +209,46 @@ public interface RefEndpointBuilderFactory {
         default AdvancedRefEndpointProducerBuilder advanced() {
             return (AdvancedRefEndpointProducerBuilder) this;
         }
+        /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option is a: <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default RefEndpointProducerBuilder lazyStartProducer(
+                boolean lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option will be converted to a <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default RefEndpointProducerBuilder lazyStartProducer(
+                String lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
     }
 
     /**
diff --git a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/SedaEndpointBuilderFactory.java b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/SedaEndpointBuilderFactory.java
index 5708c0d..31d6c21 100644
--- a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/SedaEndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/SedaEndpointBuilderFactory.java
@@ -523,6 +523,46 @@ public interface SedaEndpointBuilderFactory {
             return this;
         }
         /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option is a: <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default SedaEndpointProducerBuilder lazyStartProducer(
+                boolean lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option will be converted to a <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default SedaEndpointProducerBuilder lazyStartProducer(
+                String lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
          * offerTimeout (in milliseconds) can be added to the block case when
          * queue is full. You can disable timeout by using 0 or a negative
          * value.
diff --git a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/StubEndpointBuilderFactory.java b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/StubEndpointBuilderFactory.java
index bc923ef..969b9ba 100644
--- a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/StubEndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/StubEndpointBuilderFactory.java
@@ -523,6 +523,46 @@ public interface StubEndpointBuilderFactory {
             return this;
         }
         /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option is a: <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default StubEndpointProducerBuilder lazyStartProducer(
+                boolean lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option will be converted to a <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default StubEndpointProducerBuilder lazyStartProducer(
+                String lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
          * offerTimeout (in milliseconds) can be added to the block case when
          * queue is full. You can disable timeout by using 0 or a negative
          * value.
diff --git a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/VmEndpointBuilderFactory.java b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/VmEndpointBuilderFactory.java
index 9f87f922..b7e9a02 100644
--- a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/VmEndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/VmEndpointBuilderFactory.java
@@ -521,6 +521,46 @@ public interface VmEndpointBuilderFactory {
             return this;
         }
         /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option is a: <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default VmEndpointProducerBuilder lazyStartProducer(
+                boolean lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
+         * Whether the producer should be started lazy (on the first message).
+         * By starting lazy you can use this to allow CamelContext and routes to
+         * startup in situations where a producer may otherwise fail during
+         * starting and cause the route to fail being started. By deferring this
+         * startup to be lazy then the startup failure can be handled during
+         * routing messages via Camel's routing error handlers. Beware that when
+         * the first message is processed then creating and starting the
+         * producer may take a little time and prolong the total processing time
+         * of the processing.
+         * 
+         * The option will be converted to a <code>boolean</code> type.
+         * 
+         * Group: producer
+         */
+        default VmEndpointProducerBuilder lazyStartProducer(
+                String lazyStartProducer) {
+            setProperty("lazyStartProducer", lazyStartProducer);
+            return this;
+        }
+        /**
          * offerTimeout (in milliseconds) can be added to the block case when
          * queue is full. You can disable timeout by using 0 or a negative
          * value.
diff --git a/docs/components/modules/ROOT/pages/any23-dataformat.adoc b/docs/components/modules/ROOT/pages/any23-dataformat.adoc
index 962f3a4..3155e14 100644
--- a/docs/components/modules/ROOT/pages/any23-dataformat.adoc
+++ b/docs/components/modules/ROOT/pages/any23-dataformat.adoc
@@ -32,10 +32,10 @@ The Any23 dataformat supports 5 options, which are listed below.
 [width="100%",cols="2s,1m,1m,6",options="header"]
 |===
 | Name | Default | Java Type | Description
-| outputFormat | MODEL | String | 
-| configurations |  | String | 
-| extractors |  | String | 
-| baseuri |  | String | 
+| outputFormat | MODEL | Any23Type | 
+| configurations |  | Map | 
+| extractors |  | List | 
+| baseURI |  | String | 
 | contentTypeHeader | false | Boolean | Whether the data format should set the Content-Type header with the type from the data format if the data format is capable of doing so. For example application/xml for data formats marshalling to XML, or application/json for data formats marshalling to JSon etc.
 |===
 // dataformat options: END
@@ -55,19 +55,18 @@ When using Spring Boot make sure to use the following Maven dependency to have s
 ----
 
 
-The component supports 6 options, which are listed below.
+The component supports 5 options, which are listed below.
 
 
 
 [width="100%",cols="2,5,^1,2",options="header"]
 |===
 | Name | Description | Default | Type
-| *camel.dataformat.any23.baseuri* |  |  | String
+| *camel.dataformat.any23.base-u-r-i* |  |  | String
 | *camel.dataformat.any23.configurations* |  |  | String
 | *camel.dataformat.any23.content-type-header* | Whether the data format should set the Content-Type header with the type from the data format if the data format is capable of doing so. For example application/xml for data formats marshalling to XML, or application/json for data formats marshalling to JSon etc. | false | Boolean
 | *camel.dataformat.any23.enabled* | Whether to enable auto configuration of the any23 data format. This is enabled by default. |  | Boolean
-| *camel.dataformat.any23.extractors* |  |  | String
-| *camel.dataformat.any23.output-format* |  | MODEL | String
+| *camel.dataformat.any23.extractors* |  |  | List
 |===
 // spring-boot-auto-configure options: END
 
diff --git a/platforms/spring-boot/components-starter/camel-any23-starter/src/main/java/org/apache/camel/dataformat/any23/springboot/Any23DataFormatConfiguration.java b/platforms/spring-boot/components-starter/camel-any23-starter/src/main/java/org/apache/camel/dataformat/any23/springboot/Any23DataFormatConfiguration.java
index fdc80df..058c337 100644
--- a/platforms/spring-boot/components-starter/camel-any23-starter/src/main/java/org/apache/camel/dataformat/any23/springboot/Any23DataFormatConfiguration.java
+++ b/platforms/spring-boot/components-starter/camel-any23-starter/src/main/java/org/apache/camel/dataformat/any23/springboot/Any23DataFormatConfiguration.java
@@ -16,6 +16,7 @@
  */
 package org.apache.camel.dataformat.any23.springboot;
 
+import java.util.List;
 import javax.annotation.Generated;
 import org.apache.camel.spring.boot.DataFormatConfigurationPropertiesCommon;
 import org.springframework.boot.context.properties.ConfigurationProperties;
@@ -36,10 +37,9 @@ public class Any23DataFormatConfiguration
      * enabled by default.
      */
     private Boolean enabled;
-    private String outputFormat = "MODEL";
     private String configurations;
-    private String extractors;
-    private String baseuri;
+    private List<String> extractors;
+    private String baseURI;
     /**
      * Whether the data format should set the Content-Type header with the type
      * from the data format if the data format is capable of doing so. For
@@ -48,14 +48,6 @@ public class Any23DataFormatConfiguration
      */
     private Boolean contentTypeHeader = false;
 
-    public String getOutputFormat() {
-        return outputFormat;
-    }
-
-    public void setOutputFormat(String outputFormat) {
-        this.outputFormat = outputFormat;
-    }
-
     public String getConfigurations() {
         return configurations;
     }
@@ -64,20 +56,20 @@ public class Any23DataFormatConfiguration
         this.configurations = configurations;
     }
 
-    public String getExtractors() {
+    public List<String> getExtractors() {
         return extractors;
     }
 
-    public void setExtractors(String extractors) {
+    public void setExtractors(List<String> extractors) {
         this.extractors = extractors;
     }
 
-    public String getBaseuri() {
-        return baseuri;
+    public String getBaseURI() {
+        return baseURI;
     }
 
-    public void setBaseuri(String baseuri) {
-        this.baseuri = baseuri;
+    public void setBaseURI(String baseURI) {
+        this.baseURI = baseURI;
     }
 
     public Boolean getContentTypeHeader() {


Mime
View raw message