This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch CAMEL-17061
in repository https://gitbox.apache.org/repos/asf/camel-spring-boot.git
commit 8d5ea59e3aa8f102ae7e93a4f0a4275e1e06d458
Author: Claus Ibsen <claus.ib...@gmail.com>
AuthorDate: Sun Oct 10 14:14:03 2021 +0200
CAMEL-17061: camel-openapi-java-starter - Integrate with springdoc. WIP.
Should be moved to a new -starter JAR instead.
---
.../camel-openapi-java-starter/pom.xml | 5 +
.../src/main/docs/openapi-java-starter.adoc | 29 +++
.../openapi/OpenApiAutoConfiguration.java | 219 +++++++++++++++++++++
.../springboot/openapi/OpenApiConfiguration.java | 40 ++++
.../src/main/resources/META-INF/spring.factories | 18 ++
.../spring-boot/partials/hazelcast-starter.adoc | 24 +--
.../spring-boot/partials/openapi-java-starter.adoc | 29 +++
7 files changed, 341 insertions(+), 23 deletions(-)
diff --git a/components-starter/camel-openapi-java-starter/pom.xml
b/components-starter/camel-openapi-java-starter/pom.xml
index f600709..e38734d 100644
--- a/components-starter/camel-openapi-java-starter/pom.xml
+++ b/components-starter/camel-openapi-java-starter/pom.xml
@@ -39,6 +39,11 @@
<artifactId>camel-openapi-java</artifactId>
<version>${camel-version}</version>
</dependency>
+ <dependency>
+ <groupId>io.swagger.parser.v3</groupId>
+ <artifactId>swagger-parser-v3</artifactId>
+ <version>2.0.28</version>
+ </dependency>
<!--START OF GENERATED CODE-->
<dependency>
<groupId>org.apache.camel.springboot</groupId>
diff --git
a/components-starter/camel-openapi-java-starter/src/main/docs/openapi-java-starter.adoc
b/components-starter/camel-openapi-java-starter/src/main/docs/openapi-java-starter.adoc
new file mode 100644
index 0000000..4306df8
--- /dev/null
+++
b/components-starter/camel-openapi-java-starter/src/main/docs/openapi-java-starter.adoc
@@ -0,0 +1,29 @@
+// spring-boot-auto-configure options: START
+:page-partial:
+:doctitle: Camel Spring Boot Starter for openapi-java
+
+== Spring Boot Auto-Configuration
+
+When using openapi-java with Spring Boot make sure to use the following Maven
dependency to have support for auto configuration:
+
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.camel.springboot</groupId>
+ <artifactId>camel-openapi-java-starter</artifactId>
+ <version>x.x.x</version>
+ <!-- use the same version as your Camel core version -->
+</dependency>
+----
+
+
+The component supports 1 options, which are listed below.
+
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *camel.openapi.enabled* | Enables Camel Rest DSL to automatic register its
OpenAPI (eg swagger doc) in Spring Boot which allows tooling such as SpringDoc
to integrate with Camel. | true | Boolean
+|===
+// spring-boot-auto-configure options: END
diff --git
a/components-starter/camel-openapi-java-starter/src/main/java/org/apache/camel/springboot/openapi/OpenApiAutoConfiguration.java
b/components-starter/camel-openapi-java-starter/src/main/java/org/apache/camel/springboot/openapi/OpenApiAutoConfiguration.java
new file mode 100644
index 0000000..c0f728a
--- /dev/null
+++
b/components-starter/camel-openapi-java-starter/src/main/java/org/apache/camel/springboot/openapi/OpenApiAutoConfiguration.java
@@ -0,0 +1,219 @@
+/*
+ * 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.springboot.openapi;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;
+import io.apicurio.datamodels.openapi.models.OasDocument;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Contact;
+import io.swagger.v3.oas.models.info.Info;
+import io.swagger.v3.parser.OpenAPIV3Parser;
+import io.swagger.v3.parser.core.models.SwaggerParseResult;
+import org.apache.camel.CamelContext;
+import org.apache.camel.model.rest.RestDefinition;
+import org.apache.camel.openapi.BeanConfig;
+import org.apache.camel.openapi.DefaultRestDefinitionsResolver;
+import org.apache.camel.openapi.RestDefinitionsResolver;
+import org.apache.camel.openapi.RestOpenApiReader;
+import org.apache.camel.spi.RestConfiguration;
+import org.apache.camel.spring.boot.CamelContextConfiguration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.AutoConfigureBefore;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import
org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.support.GenericApplicationContext;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.apache.camel.openapi.OpenApiHelper.clearVendorExtensions;
+
+/**
+ * Open API auto-configuration.
+ */
+@Configuration(proxyBeanMethods = false)
+@EnableConfigurationProperties({OpenApiConfiguration.class})
+@ConditionalOnBean(type =
"org.apache.camel.spring.boot.CamelAutoConfiguration")
+@ConditionalOnProperty(name = "camel.openapi.enabled", matchIfMissing = true)
+@AutoConfigureAfter(name =
"org.apache.camel.spring.boot.CamelAutoConfiguration")
+@AutoConfigureBefore(name = "org.springdoc.core.SpringDocConfiguration")
+public class OpenApiAutoConfiguration {
+
+ private static final Logger LOG =
LoggerFactory.getLogger(OpenApiAutoConfiguration.class);
+
+ private final RestOpenApiReader reader = new RestOpenApiReader();
+ private final RestDefinitionsResolver resolver = new
DefaultRestDefinitionsResolver();
+ private final OpenAPI openAPI = new OpenAPI();
+
+ @Bean
+ CamelContextConfiguration onBeforeStart(GenericApplicationContext ac,
CamelContext camelContext, OpenApiConfiguration config) {
+ return new CamelContextConfiguration() {
+ @Override
+ public void beforeApplicationStart(CamelContext camelContext) {
+ // routes have now been loaded, so we need to detect rest-dsl
APIs in Camel
+ // this will trigger spring boot to create the bean which
springdoc can detect
+ try {
+ OpenAPI created = createOpenAPI(camelContext);
+ if (created != null) {
+ LOG.info("OpenAPI ({}) created from Camel Rest-DSL v{}
- {}", created.getOpenapi(), created.getInfo().getVersion(),
created.getInfo().getTitle());
+ // transfer data to the existing
+ openAPI.setInfo(created.getInfo());
+ openAPI.setOpenapi(created.getOpenapi());
+ if (created.getComponents() != null) {
+ openAPI.setComponents(created.getComponents());
+ }
+ if (created.getExtensions() != null) {
+ openAPI.setExtensions(created.getExtensions());
+ }
+ if (created.getSecurity() != null) {
+ openAPI.setSecurity(created.getSecurity());
+ }
+ if (created.getExternalDocs() != null) {
+ openAPI.setExternalDocs(created.getExternalDocs());
+ }
+ if (created.getPaths() != null) {
+ openAPI.setPaths(created.getPaths());
+ }
+ // TODO: servers is not correct
+// if (created.getServers() != null) {
+// openAPI.setServers(created.getServers());
+// }
+ if (created.getTags() != null) {
+ openAPI.setTags(created.getTags());
+ }
+ }
+ } catch (Exception e) {
+ LOG.warn("Error generating OpenAPI from Camel Rest DSL due
to: " + e.getMessage() + ". This exception is ignored.", e);
+ }
+ }
+
+ @Override
+ public void afterApplicationStart(CamelContext camelContext) {
+ // noop
+ }
+ };
+ }
+
+ @Bean
+ OpenAPI camelRestDSLOpenApi() {
+ // due to ordering how beans are resolved and setup in spring boot,
then we need to create
+ // this provisional bean which is later updated with the actual Rest
DSL APIs after the routes has been loaded
+ // into Camel
+ return openAPI;
+ }
+
+ private OpenAPI createOpenAPI(CamelContext camelContext) throws Exception {
+ List<RestDefinition> rests = resolver.getRestDefinitions(camelContext,
null);
+ if (rests == null || rests.isEmpty()) {
+ return null;
+ }
+
+ BeanConfig bc = new BeanConfig();
+ Info info = new Info();
+
+ RestConfiguration rc = camelContext.getRestConfiguration();
+ initOpenApi(bc, info, rc.getApiProperties());
+
+ OasDocument openApi = reader.read(camelContext, rests, "", bc, null,
camelContext.getClassResolver());
+ if (!rc.isApiVendorExtension()) {
+ clearVendorExtensions(openApi);
+ }
+
+ // dump to json
+ ObjectMapper mapper = new ObjectMapper();
+ mapper.enable(SerializationFeature.INDENT_OUTPUT);
+ mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+ Object dump = io.apicurio.datamodels.Library.writeNode(openApi);
+ byte[] jsonData = mapper.writeValueAsBytes(dump);
+ // json to yaml
+ JsonNode node = mapper.readTree(jsonData);
+ String yaml = new YAMLMapper().writeValueAsString(node);
+
+ // parse bytes into swagger
+ OpenAPIV3Parser parser = new OpenAPIV3Parser();
+ SwaggerParseResult spr = parser.readContents(yaml);
+ OpenAPI answer = spr.getOpenAPI();
+ if (answer != null) {
+ answer.setInfo(info);
+ }
+ return answer;
+ }
+
+ private static void initOpenApi(BeanConfig bc, Info info, Map<String,
Object> config) {
+ // configure openApi options
+ String s = (String) config.get("openapi.version");
+ if (s != null) {
+ bc.setVersion(s);
+ }
+ s = (String) config.get("base.path");
+ if (s != null) {
+ bc.setBasePath(s);
+ }
+ s = (String) config.get("host");
+ if (s != null) {
+ bc.setHost(s);
+ }
+ s = (String) config.get("schemes");
+ if (s == null) {
+ // deprecated due typo
+ s = (String) config.get("schemas");
+ }
+ if (s != null) {
+ String[] schemes = s.split(",");
+ bc.setSchemes(schemes);
+ } else {
+ // assume http by default
+ bc.setSchemes(new String[] { "http" });
+ }
+
+ String version = (String) config.get("api.version");
+ String title = (String) config.get("api.title");
+ String description = (String) config.get("api.description");
+ String termsOfService = (String) config.get("api.termsOfService");
+ String licenseName = (String) config.get("api.license.name");
+ String licenseUrl = (String) config.get("api.license.url");
+ String contactName = (String) config.get("api.contact.name");
+ String contactUrl = (String) config.get("api.contact.url");
+ String contactEmail = (String) config.get("api.contact.email");
+
+ bc.setTitle(title);
+ bc.setLicense(licenseName);
+ bc.setLicenseUrl(licenseUrl);
+
+ info.setTitle(title);
+ info.setVersion(version);
+ info.setDescription(description);
+ info.setTermsOfService(termsOfService);
+ if (contactName != null) {
+ Contact contact = new Contact();
+ contact.setName(contactName);
+ contact.setEmail(contactEmail);
+ contact.setUrl(contactUrl);
+ info.setContact(contact);
+ }
+ }
+
+}
diff --git
a/components-starter/camel-openapi-java-starter/src/main/java/org/apache/camel/springboot/openapi/OpenApiConfiguration.java
b/components-starter/camel-openapi-java-starter/src/main/java/org/apache/camel/springboot/openapi/OpenApiConfiguration.java
new file mode 100644
index 0000000..6556ade
--- /dev/null
+++
b/components-starter/camel-openapi-java-starter/src/main/java/org/apache/camel/springboot/openapi/OpenApiConfiguration.java
@@ -0,0 +1,40 @@
+/*
+ * 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.springboot.openapi;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * Mapping settings for the Camel Open API
+ */
+@ConfigurationProperties(prefix = "camel.openapi")
+public class OpenApiConfiguration {
+
+ /**
+ * Enables Camel Rest DSL to automatic register its OpenAPI (eg swagger
doc) in Spring Boot
+ * which allows tooling such as SpringDoc to integrate with Camel.
+ */
+ private Boolean enabled = true;
+
+ public Boolean getEnabled() {
+ return enabled;
+ }
+
+ public void setEnabled(Boolean enabled) {
+ this.enabled = enabled;
+ }
+}
diff --git
a/components-starter/camel-openapi-java-starter/src/main/resources/META-INF/spring.factories
b/components-starter/camel-openapi-java-starter/src/main/resources/META-INF/spring.factories
new file mode 100644
index 0000000..2b188dc
--- /dev/null
+++
b/components-starter/camel-openapi-java-starter/src/main/resources/META-INF/spring.factories
@@ -0,0 +1,18 @@
+## ---------------------------------------------------------------------------
+## 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.
+## ---------------------------------------------------------------------------
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+org.apache.camel.springboot.openapi.OpenApiAutoConfiguration
\ No newline at end of file
diff --git
a/docs/components/modules/spring-boot/partials/hazelcast-starter.adoc
b/docs/components/modules/spring-boot/partials/hazelcast-starter.adoc
index 46c801c..2679f0a 100644
--- a/docs/components/modules/spring-boot/partials/hazelcast-starter.adoc
+++ b/docs/components/modules/spring-boot/partials/hazelcast-starter.adoc
@@ -17,7 +17,7 @@ When using hazelcast with Spring Boot make sure to use the
following Maven depen
----
-The component supports 85 options, which are listed below.
+The component supports 63 options, which are listed below.
@@ -25,8 +25,6 @@ The component supports 85 options, which are listed below.
|===
| Name | Description | Default | Type
| *camel.component.hazelcast-atomicvalue.autowired-enabled* | Whether
autowiring is enabled. This is used for automatic autowiring options (the
option must be marked as autowired) by looking up in the registry to find if
there is a single instance of matching type, which then gets configured on the
component. This can be used for automatic configuring JDBC data sources, JMS
connection factories, AWS Clients, etc. | true | Boolean
-|
*camel.component.hazelcast-atomicvalue.customizer.hazelcast-instance.enabled* |
Enable or disable the cache-manager customizer. | true | Boolean
-|
*camel.component.hazelcast-atomicvalue.customizer.hazelcast-instance.override*
| Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
| *camel.component.hazelcast-atomicvalue.enabled* | Whether to enable auto
configuration of the hazelcast-atomicvalue component. This is enabled by
default. | | Boolean
| *camel.component.hazelcast-atomicvalue.hazelcast-instance* | The hazelcast
instance reference which can be used for hazelcast endpoint. If you don't
specify the instance reference, camel use the default hazelcast instance from
the camel-hazelcast instance. The option is a
com.hazelcast.core.HazelcastInstance type. | | HazelcastInstance
| *camel.component.hazelcast-atomicvalue.hazelcast-mode* | The hazelcast mode
reference which kind of instance should be used. If you don't specify the mode,
then the node mode will be the default. | node | String
@@ -38,73 +36,53 @@ The component supports 85 options, which are listed below.
| *camel.component.hazelcast-instance.hazelcast-mode* | The hazelcast mode
reference which kind of instance should be used. If you don't specify the mode,
then the node mode will be the default. | node | String
| *camel.component.hazelcast-list.autowired-enabled* | Whether autowiring is
enabled. This is used for automatic autowiring options (the option must be
marked as autowired) by looking up in the registry to find if there is a single
instance of matching type, which then gets configured on the component. This
can be used for automatic configuring JDBC data sources, JMS connection
factories, AWS Clients, etc. | true | Boolean
| *camel.component.hazelcast-list.bridge-error-handler* | 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
-| *camel.component.hazelcast-list.customizer.hazelcast-instance.enabled* |
Enable or disable the cache-manager customizer. | true | Boolean
-| *camel.component.hazelcast-list.customizer.hazelcast-instance.override* |
Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
| *camel.component.hazelcast-list.enabled* | Whether to enable auto
configuration of the hazelcast-list component. This is enabled by default. | |
Boolean
| *camel.component.hazelcast-list.hazelcast-instance* | The hazelcast instance
reference which can be used for hazelcast endpoint. If you don't specify the
instance reference, camel use the default hazelcast instance from the
camel-hazelcast instance. The option is a com.hazelcast.core.HazelcastInstance
type. | | HazelcastInstance
| *camel.component.hazelcast-list.hazelcast-mode* | The hazelcast mode
reference which kind of instance should be used. If you don't specify the mode,
then the node mode will be the default. | node | String
| *camel.component.hazelcast-list.lazy-start-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 proce [...]
| *camel.component.hazelcast-map.autowired-enabled* | Whether autowiring is
enabled. This is used for automatic autowiring options (the option must be
marked as autowired) by looking up in the registry to find if there is a single
instance of matching type, which then gets configured on the component. This
can be used for automatic configuring JDBC data sources, JMS connection
factories, AWS Clients, etc. | true | Boolean
| *camel.component.hazelcast-map.bridge-error-handler* | 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
-| *camel.component.hazelcast-map.customizer.hazelcast-instance.enabled* |
Enable or disable the cache-manager customizer. | true | Boolean
-| *camel.component.hazelcast-map.customizer.hazelcast-instance.override* |
Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
| *camel.component.hazelcast-map.enabled* | Whether to enable auto
configuration of the hazelcast-map component. This is enabled by default. | |
Boolean
| *camel.component.hazelcast-map.hazelcast-instance* | The hazelcast instance
reference which can be used for hazelcast endpoint. If you don't specify the
instance reference, camel use the default hazelcast instance from the
camel-hazelcast instance. The option is a com.hazelcast.core.HazelcastInstance
type. | | HazelcastInstance
| *camel.component.hazelcast-map.hazelcast-mode* | The hazelcast mode
reference which kind of instance should be used. If you don't specify the mode,
then the node mode will be the default. | node | String
| *camel.component.hazelcast-map.lazy-start-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 proces [...]
| *camel.component.hazelcast-multimap.autowired-enabled* | Whether autowiring
is enabled. This is used for automatic autowiring options (the option must be
marked as autowired) by looking up in the registry to find if there is a single
instance of matching type, which then gets configured on the component. This
can be used for automatic configuring JDBC data sources, JMS connection
factories, AWS Clients, etc. | true | Boolean
| *camel.component.hazelcast-multimap.bridge-error-handler* | 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
-| *camel.component.hazelcast-multimap.customizer.hazelcast-instance.enabled* |
Enable or disable the cache-manager customizer. | true | Boolean
-| *camel.component.hazelcast-multimap.customizer.hazelcast-instance.override*
| Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
| *camel.component.hazelcast-multimap.enabled* | Whether to enable auto
configuration of the hazelcast-multimap component. This is enabled by default.
| | Boolean
| *camel.component.hazelcast-multimap.hazelcast-instance* | The hazelcast
instance reference which can be used for hazelcast endpoint. If you don't
specify the instance reference, camel use the default hazelcast instance from
the camel-hazelcast instance. The option is a
com.hazelcast.core.HazelcastInstance type. | | HazelcastInstance
| *camel.component.hazelcast-multimap.hazelcast-mode* | The hazelcast mode
reference which kind of instance should be used. If you don't specify the mode,
then the node mode will be the default. | node | String
| *camel.component.hazelcast-multimap.lazy-start-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 p [...]
| *camel.component.hazelcast-queue.autowired-enabled* | Whether autowiring is
enabled. This is used for automatic autowiring options (the option must be
marked as autowired) by looking up in the registry to find if there is a single
instance of matching type, which then gets configured on the component. This
can be used for automatic configuring JDBC data sources, JMS connection
factories, AWS Clients, etc. | true | Boolean
| *camel.component.hazelcast-queue.bridge-error-handler* | 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
-| *camel.component.hazelcast-queue.customizer.hazelcast-instance.enabled* |
Enable or disable the cache-manager customizer. | true | Boolean
-| *camel.component.hazelcast-queue.customizer.hazelcast-instance.override* |
Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
| *camel.component.hazelcast-queue.enabled* | Whether to enable auto
configuration of the hazelcast-queue component. This is enabled by default. |
| Boolean
| *camel.component.hazelcast-queue.hazelcast-instance* | The hazelcast
instance reference which can be used for hazelcast endpoint. If you don't
specify the instance reference, camel use the default hazelcast instance from
the camel-hazelcast instance. The option is a
com.hazelcast.core.HazelcastInstance type. | | HazelcastInstance
| *camel.component.hazelcast-queue.hazelcast-mode* | The hazelcast mode
reference which kind of instance should be used. If you don't specify the mode,
then the node mode will be the default. | node | String
| *camel.component.hazelcast-queue.lazy-start-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 proc [...]
| *camel.component.hazelcast-replicatedmap.autowired-enabled* | Whether
autowiring is enabled. This is used for automatic autowiring options (the
option must be marked as autowired) by looking up in the registry to find if
there is a single instance of matching type, which then gets configured on the
component. This can be used for automatic configuring JDBC data sources, JMS
connection factories, AWS Clients, etc. | true | Boolean
| *camel.component.hazelcast-replicatedmap.bridge-error-handler* | 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
-|
*camel.component.hazelcast-replicatedmap.customizer.hazelcast-instance.enabled*
| Enable or disable the cache-manager customizer. | true | Boolean
-|
*camel.component.hazelcast-replicatedmap.customizer.hazelcast-instance.override*
| Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
| *camel.component.hazelcast-replicatedmap.enabled* | Whether to enable auto
configuration of the hazelcast-replicatedmap component. This is enabled by
default. | | Boolean
| *camel.component.hazelcast-replicatedmap.hazelcast-instance* | The hazelcast
instance reference which can be used for hazelcast endpoint. If you don't
specify the instance reference, camel use the default hazelcast instance from
the camel-hazelcast instance. The option is a
com.hazelcast.core.HazelcastInstance type. | | HazelcastInstance
| *camel.component.hazelcast-replicatedmap.hazelcast-mode* | The hazelcast
mode reference which kind of instance should be used. If you don't specify the
mode, then the node mode will be the default. | node | String
| *camel.component.hazelcast-replicatedmap.lazy-start-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 [...]
| *camel.component.hazelcast-ringbuffer.autowired-enabled* | Whether
autowiring is enabled. This is used for automatic autowiring options (the
option must be marked as autowired) by looking up in the registry to find if
there is a single instance of matching type, which then gets configured on the
component. This can be used for automatic configuring JDBC data sources, JMS
connection factories, AWS Clients, etc. | true | Boolean
-| *camel.component.hazelcast-ringbuffer.customizer.hazelcast-instance.enabled*
| Enable or disable the cache-manager customizer. | true | Boolean
-|
*camel.component.hazelcast-ringbuffer.customizer.hazelcast-instance.override* |
Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
| *camel.component.hazelcast-ringbuffer.enabled* | Whether to enable auto
configuration of the hazelcast-ringbuffer component. This is enabled by
default. | | Boolean
| *camel.component.hazelcast-ringbuffer.hazelcast-instance* | The hazelcast
instance reference which can be used for hazelcast endpoint. If you don't
specify the instance reference, camel use the default hazelcast instance from
the camel-hazelcast instance. The option is a
com.hazelcast.core.HazelcastInstance type. | | HazelcastInstance
| *camel.component.hazelcast-ringbuffer.hazelcast-mode* | The hazelcast mode
reference which kind of instance should be used. If you don't specify the mode,
then the node mode will be the default. | node | String
| *camel.component.hazelcast-ringbuffer.lazy-start-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 [...]
| *camel.component.hazelcast-seda.autowired-enabled* | Whether autowiring is
enabled. This is used for automatic autowiring options (the option must be
marked as autowired) by looking up in the registry to find if there is a single
instance of matching type, which then gets configured on the component. This
can be used for automatic configuring JDBC data sources, JMS connection
factories, AWS Clients, etc. | true | Boolean
| *camel.component.hazelcast-seda.bridge-error-handler* | 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
-| *camel.component.hazelcast-seda.customizer.hazelcast-instance.enabled* |
Enable or disable the cache-manager customizer. | true | Boolean
-| *camel.component.hazelcast-seda.customizer.hazelcast-instance.override* |
Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
| *camel.component.hazelcast-seda.enabled* | Whether to enable auto
configuration of the hazelcast-seda component. This is enabled by default. | |
Boolean
| *camel.component.hazelcast-seda.hazelcast-instance* | The hazelcast instance
reference which can be used for hazelcast endpoint. If you don't specify the
instance reference, camel use the default hazelcast instance from the
camel-hazelcast instance. The option is a com.hazelcast.core.HazelcastInstance
type. | | HazelcastInstance
| *camel.component.hazelcast-seda.hazelcast-mode* | The hazelcast mode
reference which kind of instance should be used. If you don't specify the mode,
then the node mode will be the default. | node | String
| *camel.component.hazelcast-seda.lazy-start-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 proce [...]
| *camel.component.hazelcast-set.autowired-enabled* | Whether autowiring is
enabled. This is used for automatic autowiring options (the option must be
marked as autowired) by looking up in the registry to find if there is a single
instance of matching type, which then gets configured on the component. This
can be used for automatic configuring JDBC data sources, JMS connection
factories, AWS Clients, etc. | true | Boolean
| *camel.component.hazelcast-set.bridge-error-handler* | 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
-| *camel.component.hazelcast-set.customizer.hazelcast-instance.enabled* |
Enable or disable the cache-manager customizer. | true | Boolean
-| *camel.component.hazelcast-set.customizer.hazelcast-instance.override* |
Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
| *camel.component.hazelcast-set.enabled* | Whether to enable auto
configuration of the hazelcast-set component. This is enabled by default. | |
Boolean
| *camel.component.hazelcast-set.hazelcast-instance* | The hazelcast instance
reference which can be used for hazelcast endpoint. If you don't specify the
instance reference, camel use the default hazelcast instance from the
camel-hazelcast instance. The option is a com.hazelcast.core.HazelcastInstance
type. | | HazelcastInstance
| *camel.component.hazelcast-set.hazelcast-mode* | The hazelcast mode
reference which kind of instance should be used. If you don't specify the mode,
then the node mode will be the default. | node | String
| *camel.component.hazelcast-set.lazy-start-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 proces [...]
| *camel.component.hazelcast-topic.autowired-enabled* | Whether autowiring is
enabled. This is used for automatic autowiring options (the option must be
marked as autowired) by looking up in the registry to find if there is a single
instance of matching type, which then gets configured on the component. This
can be used for automatic configuring JDBC data sources, JMS connection
factories, AWS Clients, etc. | true | Boolean
| *camel.component.hazelcast-topic.bridge-error-handler* | 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
-| *camel.component.hazelcast-topic.customizer.hazelcast-instance.enabled* |
Enable or disable the cache-manager customizer. | true | Boolean
-| *camel.component.hazelcast-topic.customizer.hazelcast-instance.enabled* |
Enable or disable the cache-manager customizer. | true | Boolean
-| *camel.component.hazelcast-topic.customizer.hazelcast-instance.override* |
Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
-| *camel.component.hazelcast-topic.customizer.hazelcast-instance.override* |
Configure if the cache manager eventually set on the component should be
overridden by the customizer. | false | Boolean
| *camel.component.hazelcast-topic.enabled* | Whether to enable auto
configuration of the hazelcast-topic component. This is enabled by default. |
| Boolean
| *camel.component.hazelcast-topic.hazelcast-instance* | The hazelcast
instance reference which can be used for hazelcast endpoint. If you don't
specify the instance reference, camel use the default hazelcast instance from
the camel-hazelcast instance. The option is a
com.hazelcast.core.HazelcastInstance type. | | HazelcastInstance
| *camel.component.hazelcast-topic.hazelcast-mode* | The hazelcast mode
reference which kind of instance should be used. If you don't specify the mode,
then the node mode will be the default. | node | String
diff --git
a/docs/components/modules/spring-boot/partials/openapi-java-starter.adoc
b/docs/components/modules/spring-boot/partials/openapi-java-starter.adoc
new file mode 100644
index 0000000..4306df8
--- /dev/null
+++ b/docs/components/modules/spring-boot/partials/openapi-java-starter.adoc
@@ -0,0 +1,29 @@
+// spring-boot-auto-configure options: START
+:page-partial:
+:doctitle: Camel Spring Boot Starter for openapi-java
+
+== Spring Boot Auto-Configuration
+
+When using openapi-java with Spring Boot make sure to use the following Maven
dependency to have support for auto configuration:
+
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.camel.springboot</groupId>
+ <artifactId>camel-openapi-java-starter</artifactId>
+ <version>x.x.x</version>
+ <!-- use the same version as your Camel core version -->
+</dependency>
+----
+
+
+The component supports 1 options, which are listed below.
+
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *camel.openapi.enabled* | Enables Camel Rest DSL to automatic register its
OpenAPI (eg swagger doc) in Spring Boot which allows tooling such as SpringDoc
to integrate with Camel. | true | Boolean
+|===
+// spring-boot-auto-configure options: END
