Red Hat SummitChapter 1. Getting Started with Camel Spring Boot 3.18
This guide introduces Camel Spring Boot and demonstrates how to get started building an application using Camel Spring Boot:
- Section 1.1, “Camel Spring Boot starters”
- Section 1.2, “Spring Boot”
- Section 1.3, “Component Starters”
- Section 1.4, “Starter Configuration”
- Section 1.5, “Generating a Camel for Spring Boot application using Maven”
- Section 1.6, “Deploying a Camel Spring Boot application to OpenShift”
- Section 1.7, “Applying patch to Camel Spring Boot”
1.1. Camel Spring Boot starters
Camel support for Spring Boot provides auto-configuration of the Camel and starters for many Camel components. The opinionated auto-configuration of the Camel context auto-detects Camel routes available in the Spring context and registers the key Camel utilities (such as producer template, consumer template and the type converter) as beans.
For information about using a Maven archtype to generate a Camel for Spring Boot application see Generating a Camel for Spring Boot application using Maven.
To get started, you must add the Camel Spring Boot BOM to your Maven pom.xml file.
<dependencyManagement>
<dependencies>
<!-- Camel BOM -->
<dependency>
<groupId>org.apache.camel.springboot</groupId>
<artifactId>camel-spring-boot-bom</artifactId>
<version>3.18.3.redhat-00042</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- ... other BOMs or dependencies ... -->
</dependencies>
</dependencyManagement>
The camel-spring-boot-bom is a basic BOM that contains the list of Camel Spring Boot starter JARs.
Next, add the Camel Spring Boot starter to startup the Camel Context.
<dependencies>
<!-- Camel Starter -->
<dependency>
<groupId>org.apache.camel.springboot</groupId>
<artifactId>camel-spring-boot-starter</artifactId>
</dependency>
<!-- ... other dependencies ... -->
</dependencies>You must also add any component starters that your Spring Boot application requires. The following example shows how to add the auto-configuration starter to the ActiveMQ component
<dependencies>
<!-- ... other dependencies ... -->
<dependency>
<groupId>org.apache.camel.springboot</groupId>
<artifactId>camel-activemq-starter</artifactId>
</dependency>
</dependencies>1.1.1. Camel Spring Boot BOM vs Camel Spring Boot Dependencies BOM
The curated camel-spring-boot-dependencies BOM, which is generated, contains the adjusted JARs that both Spring Boot and Apache Camel use to avoid any conflicts. This BOM is used to test camel-spring-boot itself.
Spring Boot users may choose to use pure Camel dependencies by using the camel-spring-boot-bom that only has the Camel starter JARs as managed dependencies. However, this may lead to a classpath conflict if a third-party JAR from Spring Boot is not compatible with a particular Camel component.
1.1.2. Spring Boot configuration support
Each starter lists configuration parameters you can configure in the standard application.properties or application.yml files. These parameters have the form of camel.component.[component-name].[parameter]. For example to configure the URL of the ActiveMQ broker you can set:
camel.component.activemq.broker-url=tcp://localhost:616161.1.3. Adding Camel routes
Camel routes are detected in the Spring application context, for example a route annotated with org.springframework.stereotype.Component will be loaded, added to the Camel context and run.
import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;
@Component
public class MyRoute extends RouteBuilder {
@Override
public void configure() throws Exception {
from("...")
.to("...");
}
}1.2. Spring Boot
Spring Boot automatically configures Camel for you. The opinionated auto-configuration of the Camel context auto-detects Camel routes available in the Spring context and registers the key Camel utilities (like producer template, consumer template and the type converter) as beans.
Maven users will need to add the following dependency to their pom.xml in order to use this component:
<dependency>
<groupId>org.apache.camel.springboot</groupId>
<artifactId>camel-spring-boot</artifactId>
<version>3.18.3.redhat-00042</version> <!-- use the same version as your Camel core version -->
</dependency>
camel-spring-boot jar comes with the spring.factories file, so as soon as you add that dependency into your classpath, Spring Boot will automatically auto-configure Camel for you.
1.2.1. Camel Spring Boot Starter
Apache Camel ships a Spring Boot Starter module that allows you to develop Spring Boot applications using starters. There is a sample application in the source code also.
To use the starter, add the following to your spring boot pom.xml file:
<dependency>
<groupId>org.apache.camel.springboot</groupId>
<artifactId>camel-spring-boot-bom</artifactId>
<version>3.18.3.redhat-00042</version> <!-- use the same version as your Camel core version -->
</dependency>Then you can just add classes with your Camel routes such as:
package com.example;
import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;
@Component
public class MyRoute extends RouteBuilder {
@Override
public void configure() throws Exception {
from("timer:foo").to("log:bar");
}
}Then these routes will be started automatically.
You can customize the Camel application in the application.properties or application.yml file.
1.2.2. Spring Boot Auto-configuration
When using spring-boot with Spring Boot make sure to use the following Maven dependency to have support for auto configuration:
<dependency>
<groupId>org.apache.camel.springboot</groupId>
<artifactId>camel-spring-boot-starter</artifactId>
<version>3.18.3.redhat-00042</version> <!-- use the same version as your Camel core version -->
</dependency>1.2.3. Auto-configured Camel context
The most important piece of functionality provided by the Camel auto-configuration is the CamelContext instance. Camel auto-configuration creates a SpringCamelContext for you and takes care of the proper initialization and shutdown of that context. The created Camel context is also registered in the Spring application context (under the camelContext bean name), so you can access it like any other Spring bean.
@Configuration
public class MyAppConfig {
@Autowired
CamelContext camelContext;
@Bean
MyService myService() {
return new DefaultMyService(camelContext);
}
}1.2.4. Auto-detecting Camel routes
Camel auto-configuration collects all the RouteBuilder instances from the Spring context and automatically injects them into the provided CamelContext. This means that creating new Camel routes with the Spring Boot starter is as simple as adding the @Component annotated class to your classpath:
@Component
public class MyRouter extends RouteBuilder {
@Override
public void configure() throws Exception {
from("jms:invoices").to("file:/invoices");
}
}
Or creating a new route RouteBuilder bean in your @Configuration class:
@Configuration
public class MyRouterConfiguration {
@Bean
RoutesBuilder myRouter() {
return new RouteBuilder() {
@Override
public void configure() throws Exception {
from("jms:invoices").to("file:/invoices");
}
};
}
}1.2.5. Camel properties
Spring Boot auto-configuration automatically connects to Spring Boot external configuration (which may contain properties placeholders, OS environment variables or system properties) with the Camel properties support. It basically means that any property defined in application.properties file:
route.from = jms:invoicesOr set via system property:
java -Droute.to=jms:processed.invoices -jar mySpringApp.jarcan be used as placeholders in Camel route:
@Component
public class MyRouter extends RouteBuilder {
@Override
public void configure() throws Exception {
from("{{route.from}}").to("{{route.to}}");
}
}1.2.6. Custom Camel context configuration
If you want to perform some operations on CamelContext bean created by Camel auto-configuration, register CamelContextConfiguration instance in your Spring context:
@Configuration
public class MyAppConfig {
@Bean
CamelContextConfiguration contextConfiguration() {
return new CamelContextConfiguration() {
@Override
void beforeApplicationStart(CamelContext context) {
// your custom configuration goes here
}
};
}
}
The method beforeApplicationStart will be called just before the Spring context is started, so the CamelContext instance passed to this callback is fully auto-configured. If you add multiple instances of CamelContextConfiguration into your Spring context, each instance is executed.
1.2.7. Auto-configured consumer and producer templates
Camel auto-configuration provides pre-configured ConsumerTemplate and ProducerTemplate instances. You can simply inject them into your Spring-managed beans:
@Component
public class InvoiceProcessor {
@Autowired
private ProducerTemplate producerTemplate;
@Autowired
private ConsumerTemplate consumerTemplate;
public void processNextInvoice() {
Invoice invoice = consumerTemplate.receiveBody("jms:invoices", Invoice.class);
...
producerTemplate.sendBody("netty-http:http://invoicing.com/received/" + invoice.id());
}
}By default, consumer templates and producer templates come with the endpoint cache sizes set to 1000. You can change these values by modifying the following Spring properties:
camel.springboot.consumer-template-cache-size = 100
camel.springboot.producer-template-cache-size = 2001.2.8. Auto-configured TypeConverter
Camel auto-configuration registers a TypeConverter instance named typeConverter in the Spring context.
@Component
public class InvoiceProcessor {
@Autowired
private TypeConverter typeConverter;
public long parseInvoiceValue(Invoice invoice) {
String invoiceValue = invoice.grossValue();
return typeConverter.convertTo(Long.class, invoiceValue);
}
}1.2.8.1. Spring type conversion API bridge
Spring comes with the powerful type conversion API. The Spring API is similar to the Camel type converter API. As both APIs are so similar, Camel Spring Boot automatically registers a bridge converter (SpringTypeConverter) that delegates to the Spring conversion API. This means that out-of-the-box Camel will treat Spring Converters like Camel ones. With this approach you can use both Camel and Spring converters accessed via Camel TypeConverter API:
@Component
public class InvoiceProcessor {
@Autowired
private TypeConverter typeConverter;
public UUID parseInvoiceId(Invoice invoice) {
// Using Spring's StringToUUIDConverter
UUID id = invoice.typeConverter.convertTo(UUID.class, invoice.getId());
}
}
Under the hood Camel Spring Boot delegates conversion to the Spring’s ConversionService instances available in the application context. If no ConversionService instance is available, Camel Spring Boot auto-configuration will create one for you.
1.2.9. Keeping the application alive
Camel applications which have this feature enabled launch a new thread on startup for the sole purpose of keeping the application alive by preventing JVM termination. This means that after you start a Camel application with Spring Boot, your application waits for a Ctrl+C signal and does not exit immediately.
The controller thread can be activated using the camel.springboot.main-run-controller to true.
camel.springboot.main-run-controller = true
Applications using web modules (for example, applications that import the org.springframework.boot:spring-boot-web-starter module), usually don’t need to use this feature because the application is kept alive by the presence of other non-daemon threads.
1.2.10. Adding XML routes
By default, you can put Camel XML routes in the classpath under the directory camel, which camel-spring-boot will auto-detect and include. You can configure the directory name or turn this off using the configuration option:
# turn off
camel.springboot.routes-include-pattern = false# scan only in the com/foo/routes classpath
camel.springboot.routes-include-pattern = classpath:com/foo/routes/*.xml
The XML files should be Camel XML routes (not <CamelContext>) such as:
<routes xmlns="http://camel.apache.org/schema/spring">
<route id="test">
<from uri="timer://trigger"/>
<transform>
<simple>ref:myBean</simple>
</transform>
<to uri="log:out"/>
</route>
</routes>1.2.11. Testing the JUnit 5 way
For testing, Maven users will need to add the following dependencies to their pom.xml:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>2.7.12</version> <!-- Use the same version as your Spring Boot version -->
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
<artifactId>camel-test-spring-junit5</artifactId>
<version>3.18.3.redhat-00034</version> <!-- use the same version as your Camel core version -->
<scope>test</scope>
</dependency>
To test a Camel Spring Boot application, annotate your test class(es) with @CamelSpringBootTest. This brings Camel’s Spring Test support to your application, so that you can write tests using Spring Boot test conventions.
To get the CamelContext or ProducerTemplate, you can inject them into the class in the normal Spring manner, using @Autowired.
You can also use camel-test-spring-junit5 to configure tests declaratively. This example uses the @MockEndpoints annotation to auto-mock an endpoint:
@CamelSpringBootTest
@SpringBootApplication
@MockEndpoints("direct:end")
public class MyApplicationTest {
@Autowired
private ProducerTemplate template;
@EndpointInject("mock:direct:end")
private MockEndpoint mock;
@Test
public void testReceive() throws Exception {
mock.expectedBodiesReceived("Hello");
template.sendBody("direct:start", "Hello");
mock.assertIsSatisfied();
}
}1.3. Component Starters
Camel Spring Boot supports the following Camel artifacts as Spring Boot Starters:
Reference documentation is not yet available for some of the artifacts listed below. This documentation will be released as soon as it is available.
| Component | Artifact | Description |
|---|---|---|
| camel-amqp-starter | Messaging with AMQP protocol using Apache QPid Client. | |
| camel-aws2-cw-starter | Sending metrics to AWS CloudWatch using AWS SDK version 2.x. | |
| camel-aws2-ddb-starter | Store and retrieve data from AWS DynamoDB service using AWS SDK version 2.x. | |
| camel-aws2-kinesis-starter | Consume and produce records from and to AWS Kinesis Streams using AWS SDK version 2.x. | |
| camel-aws2-lambda-starter | Manage and invoke AWS Lambda functions using AWS SDK version 2.x. | |
| camel-aws2-s3-starter | Store and retrieve objects from AWS S3 Storage Service using AWS SDK version 2.x. | |
| camel-aws2-sns-starter | Send messages to an AWS Simple Notification Topic using AWS SDK version 2.x. | |
| camel-aws2-sqs-starter | Send and receive messages to/from AWS SQS service using AWS SDK version 2.x. | |
| camel-azure-storage-blob-starter | Store and retrieve blobs from Azure Storage Blob Service using SDK v12. | |
| camel-azure-storage-queue-starter | The azure-storage-queue component is used for storing and retrieving the messages to/from Azure Storage Queue using Azure SDK v12. | |
| camel-bean-starter | Invoke methods of Java beans stored in Camel registry. | |
| camel-bean-validator-starter | Validate the message body using the Java Bean Validation API. | |
| camel-browse-starter | Inspect the messages received on endpoints supporting BrowsableEndpoint. | |
| camel-cassandraql-starter | Integrate with Cassandra 2.0 using the CQL3 API (not the Thrift API). Based on Cassandra Java Driver provided by DataStax. | |
| camel-controlbus-starter | Manage and monitor Camel routes. | |
| camel-cron-starter | A generic interface for triggering events at times specified through the Unix cron syntax. | |
| camel-cxf-soap-starter | Expose SOAP WebServices using Apache CXF or connect to external WebServices using CXF WS client. | |
| camel-dataformat-starter | Use a Camel Data Format as a regular Camel Component. | |
| camel-dataset-starter | Provide data for load and soak testing of your Camel application. | |
| camel-direct-starter | Call another endpoint from the same Camel Context synchronously. | |
| link:https://access.redhat.com/documentation/en-us/red_hat_integration/2023.q2/html-single/camel_spring_boot_reference_guide_3.18/index#csb-camel-elasticsearch-component-starter | camel-elasticsearch-starter | Send requests to ElasticSearch via Java Client API. |
| camel-fhir-starter | Exchange information in the healthcare domain using the FHIR (Fast Healthcare Interoperability Resources) standard. | |
| camel-file-starter | Read and write files. | |
| camel-ftp-starter | Upload and download files to/from FTP servers. | |
| camel-http-starter | Send requests to external HTTP servers using Apache HTTP Client 4.x. | |
| camel-infinispan-starter | Read and write from/to Infinispan distributed key/value store and data grid. | |
| camel-jira-starter | Interact with JIRA issue tracker. | |
| camel-jms-starter | Sent and receive messages to/from a JMS Queue or Topic. | |
| camel-kafka-starter | Sent and receive messages to/from an Apache Kafka broker. | |
| camel-kamelet-starter | To call Kamelets | |
| camel-language-starter | Execute scripts in any of the languages supported by Camel. | |
| camel-log-starter | Log messages to the underlying logging mechanism. | |
| camel-mail-starter | Send and receive emails using imap, pop3 and smtp protocols. | |
| camel-master-starter | Have only a single consumer in a cluster consuming from a given endpoint; with automatic failover if the JVM dies. | |
| camel-minio-starter | Store and retrieve objects from Minio Storage Service using Minio SDK. | |
| camel-mllp-starter | Communicate with external systems using the MLLP protocol. | |
| camel-mock-starter | Test routes and mediation rules using mocks. | |
| camel-mongodb-starter | Perform operations on MongoDB documents and collections. | |
| camel-netty-starter | Socket level networking using TCP or UDP with Netty 4.x. | |
| camel-paho-starter | Communicate with MQTT message brokers using Eclipse Paho MQTT Client. | |
| camel-paho-mqtt5-starter | Communicate with MQTT message brokers using Eclipse Paho MQTT v5 Client. | |
| camel-quartz-starter | Schedule sending of messages using the Quartz 2.x scheduler. | |
| camel-ref-starter | Route messages to an endpoint looked up dynamically by name in the Camel Registry. | |
| camel-rest-starter | Expose REST services or call external REST services. | |
| camel-salesforce-starter | Communicate with Salesforce using Java DTOs. | |
| camel-scheduler-starter | Generate messages in specified intervals using java.util.concurrent.ScheduledExecutorService. | |
| camel-seda-starter | Asynchronously call another endpoint from any Camel Context in the same JVM. | |
| camel-servlet-starter | Serve HTTP requests by a Servlet. | |
| camel-slack-starter | Send and receive messages to/from Slack. | |
| camel-sql-starter | Perform SQL queries using Spring JDBC. | |
| camel-stub-starter | Stub out any physical endpoints while in development or testing. | |
| camel-telegram-starter | Send and receive messages acting as a Telegram Bot Telegram Bot API. | |
| camel-timer-starter | Generate messages in specified intervals using java.util.Timer. | |
| camel-validator-starter | Validate the payload using XML Schema and JAXP Validation. | |
| camel-webhook-starter | Expose webhook endpoints to receive push notifications for other Camel components. | |
| camel-xslt-starter | Transforms XML payload using an XSLT template. |
| Component | Artifact | Description |
|---|---|---|
| camel-avro-starter | Serialize and deserialize messages using Apache Avro binary data format. | |
| camel-jackson-avro-starter | Marshal POJOs to Avro and back using Jackson. | |
| camel-bindy-starter | Marshal and unmarshal between POJOs and key-value pair (KVP) format using Camel Bindy | |
| camel-hl7-starter | Marshal and unmarshal HL7 (Health Care) model objects using the HL7 MLLP codec. | |
| camel-jacksonxml-starter | Unmarshal a XML payloads to POJOs and back using XMLMapper extension of Jackson. | |
| camel-jaxb-starter | Unmarshal XML payloads to POJOs and back using JAXB2 XML marshalling standard. | |
| camel-gson-starter | Marshal POJOs to JSON and back using Gson | |
| camel-jackson-starter | Marshal POJOs to JSON and back using Jackson | |
| camel-jackson-protobuf-starter | Marshal POJOs to Protobuf and back using Jackson. | |
| camel-soap-starter | Marshal Java objects to SOAP messages and back. | |
| camel-zipfile-starter | Compression and decompress streams using java.util.zip.ZipStream. |
| Language | Artifact | Description |
|---|---|---|
| camel-core-starter | A fixed value set only once during the route startup. | |
| camel-core-starter | Evaluate a compiled simple expression. | |
| camel-core-starter | Gets a property from the Exchange. | |
| camel-core-starter | File related capabilities for the Simple language. | |
| camel-core-starter | Gets a header from the Exchange. | |
| camel-jsonpath-starter | Evaluates a JSONPath expression against a JSON message body. | |
| camel-core-starter | Uses an existing expression from the registry. | |
| camel-core-starter | Evaluates a Camel simple expression. | |
| camel-core-starter | Tokenize text payloads using delimiter patterns. | |
| camel-xml-jaxp-starter | Tokenize XML payloads. | |
| camel-xpath-starter | Evaluates an XPath expression against an XML payload. | |
| camel-saxon-starter | Query and/or transform XML payloads using XQuery and Saxon. |
| Extensions | Artifact | Description |
|---|---|---|
| camel-openapi-java-starter | Rest-dsl support for using openapi doc |
1.4. Starter Configuration
Clear and accessible configuration is a crucial part of any application. Camel starters fully support Spring Boot’s external configuration mechanism. You can also configure them through Spring Beans for more complex use cases.
1.4.1. Using External Configuration
Internally, every starter is configured through Spring Boot’s ConfigurationProperties. Each configuration parameter can be set in various ways (application.[properties|json|yaml] files, command line arguments, environments variables etc.). Parameters have the form of camel.[component|language|dataformat].[name].[parameter]
For example to configure the URL of the ActiveMQ broker you can set:
camel.component.activemq.broker-url=tcp://localhost:61616
Or to configure the delimeter of the CSV dataformat to be a semicolon(;) you can set:
camel.dataformat.csv.delimiter=;Camel will use the Type Converter mechanism when setting properties to the desired type.
You can refer to beans in the Registry using the #bean:name:
camel.component.jms.transactionManager=#bean:myjtaTransactionManager
The Bean would be typically created in Java:
@Bean("myjtaTransactionManager")
public JmsTransactionManager myjtaTransactionManager(PooledConnectionFactory pool) {
JmsTransactionManager manager = new JmsTransactionManager(pool);
manager.setDefaultTimeout(45);
return manager;
}Beans can also be created in configuration files but this is not recommended for complex use cases.
1.4.2. Using Beans
Starters can also be created and configured via Spring Beans. Before creating a starter , Camel will first lookup it up in the Registry by it’s name if it already exists. For example to configure a Kafka component:
@Bean("kafka")
public KafkaComponent kafka(KafkaConfiguration kafkaconfiguration){
return ComponentsBuilderFactory.kafka()
.brokers("{{kafka.host}}:{{kafka.port}}")
.build();
}
The Bean name has to be equal to that of the Component, Dataformat or Language that you are configuring. If the Bean name isn’t specified in the annotation it will be set to the method name.
Typical Camel Spring Boot projects will use a combination of external configuration and Beans to configure an application. For more examples on how to configure your Camel Spring Boot project, please see the example repository.
1.5. Generating a Camel for Spring Boot application using Maven
You can generate a Camel Spring Boot application using the Maven archetype org.apache.camel.archetypes:camel-archetype-spring-boot:3.18.3.redhat-00042.
Procedure
Run the following command:
mvn archetype:generate \ -DarchetypeGroupId=org.apache.camel.archetypes \ -DarchetypeArtifactId=camel-archetype-spring-boot \ -DarchetypeVersion=3.18.3.redhat-00042 \ -DgroupId=com.redhat \ -DartifactId=csb-app \ -Dversion=1.0-SNAPSHOT \ -DinteractiveMode=falseBuild the application:
mvn package -f csb-app/pom.xmlRun the application:
java -jar csb-app/target/csb-app-1.0-SNAPSHOT.jarVerify that the application is running by examining the console log for the Hello World output which is generated by the application.
com.redhat.MySpringBootApplication : Started MySpringBootApplication in 3.514 seconds (JVM running for 4.006) Hello World Hello World
1.6. Deploying a Camel Spring Boot application to OpenShift
This guide demonstrates how to deploy a Camel Spring Boot application to OpenShift.
Prerequisites
- You have access to the OpenShift cluster.
-
The OpenShift
ocCLI client is installed or you have access to the OpenShift Container Platform web console.
The certified OpenShift Container platforms are listed in the Camel for Spring Boot Supported Configurations. The Red Hat OpenJDK 11 (ubi8/openjdk-11) container image is used in the following example.
Procedure
- Generate a Camel for Spring Boot application using Maven by following the instructions in section 1.5 Generating a Camel for Spring Boot application using Maven of this guide.
Under the directory which the modified pom.xml exists, execute the following command.
mvn clean -DskipTests oc:deploy -PopenshiftVerify that the CSB application is running on the pod.
oc logs -f dc/csb-app
1.7. Applying patch to Camel Spring Boot
Using the new patch-maven-plugin mechanism, you can apply a patch to your Red Hat Camel Spring Boot application. This mechanism allows you to change the individual versions provided by different Red Hat application BOMS, for example, camel-spring-boot-bom.
The purpose of the patch-maven-plugin is to update the versions of the dependencies listed in the Camel on Spring Boot BOM to the versions specified in the patch metadata that you wish to apply to your applications.
The patch-maven-plugin performs the following operations:
- Retrieve the patch metadata related to current Red Hat application BOMs.
- Apply the version changes to <dependencyManagement> imported from the BOMs.
After the patch-maven-plugin fetches the metadata, it iterates through all managed and direct dependencies of the project where the plugin was declared and replaces the dependency versions (if they match) using CVE/patch metadata. After the versions are replaced, the Maven build continues and progresses through standard Maven project stages.
Procedure
The following procedure explains how to apply the patch to your application.
Add
patch-maven-pluginto your project’spom.xmlfile. The version of thepatch-maven-pluginmust be the same as the version of the Camel on Spring Boot BOM.<build> <plugins> <<plugin> <groupId>com.redhat.camel.springboot.platform</groupId> <artifactId>patch-maven-plugin</artifactId> <version>${camel-spring-boot-version}</version> <extensions>true</extensions> </plugin> </plugins> </build>When you run any of the
mvn clean deploy,mvn validate, ormvn dependency:treecommands, the plugin searches through the project modules to check if the modules use the Red Hat Camel Spring Boot BOM. Only the following is the supported BOM:-
com.redhat.camel.springboot.platform:camel-spring-boot-bom: for Camel Spring Boot BOM
-
If the plugin does not find the above BOM, the plugin displays the following messages:
$ mvn clean install [INFO] Scanning for projects... [INFO] ========== Red Hat Maven patching ========== [INFO] [PATCH] No project in the reactor uses Camel on Spring Boot product BOM. Skipping patch processing. [INFO] [PATCH] Done in 7ms =================================================If the correct BOM is used, the patch metadata is found, but without any patches.
$ mvn clean install [INFO] Scanning for projects... [INFO] ========== Red Hat Maven patching ========== [INFO] [PATCH] Reading patch metadata and artifacts from 2 project repositories [INFO] [PATCH] - redhat-ga-repository: http://maven.repository.redhat.com/ga/ [INFO] [PATCH] - central: https://repo.maven.apache.org/maven2 Downloading from redhat-ga-repository: http://maven.repository.redhat.com/ga/com/redhat/camel/springboot/platform/redhat-camel-spring-boot-patch-metadata/maven-metadata.xml Downloading from central: https://repo.maven.apache.org/maven2/com/redhat/camel/springboot/platform/redhat-camel-spring-boot-patch-metadata/maven-metadata.xml [INFO] [PATCH] Resolved patch descriptor: /path/to/.m2/repository/com/redhat/camel/springboot/platform/redhat-camel-spring-boot-patch-metadata/3.18.3.redhat-00035/redhat-camel-spring-boot-patch-metadata-3.18.3.redhat-00035.xml [INFO] [PATCH] Patch metadata found for com.redhat.camel.springboot.platform/camel-spring-boot-bom/[3.18) [INFO] [PATCH] Done in 938ms =================================================The
patch-maven-pluginattempts to fetch this Maven metadata.For the projects with Camel Spring Boot BOM, the
com.redhat.camel.springboot.platform:redhat-camel-spring-boot-patch-metadata/maven-metadata.xmlis resolved. This XML data is the metadata for the artifact with thecom.redhat.camel.springboot.platform:redhat-camel-spring-boot-patch-metadata:RELEASEcoordinates.Example metadata generated by Maven
<?xml version="1.0" encoding="UTF-8"?> <metadata> <groupId>com.redhat.camel.springboot.platform</groupId> <artifactId>redhat-camel-spring-boot-patch-metadata</artifactId> <versioning> <release>3.18.3.redhat-00035</release> <versions> <version>3.18.3.redhat-00035</version> </versions> <lastUpdated>20230322103858</lastUpdated> </versioning> </metadata>
-
The
patch-maven-pluginparses the metadata to select the version which applies to the current project. This action is possible only for the Maven projects using Camel on Spring Boot BOM with the specific version. Only the metadata that matches the version range or later is applicable, and it fetches only the latest version of the metadata. The
patch-maven-plugincollects a list of remote Maven repositories for downloading the patch metadata identified bygroupId,artifactId, andversionfound in previous steps. These Maven repositories are listed in the project’s<repositories>elements in the active profiles, and also the repositories from thesettings.xmlfile.$ mvn clean install [INFO] Scanning for projects... [INFO] ========== Red Hat Maven patching ========== [INFO] [PATCH] Reading patch metadata and artifacts from 2 project repositories [INFO] [PATCH] - MRRC-GA: https://maven.repository.redhat.com/ga [INFO] [PATCH] - central: https://repo.maven.apache.org/maven2Whether the metadata comes from a remote repository, local repository, or ZIP file, it is analyzed by the
patch-maven-plugin. The fetched metadata contains a list of CVEs, and for each CVE, we have a list of the affected Maven artifacts (specified by glob patterns and version ranges) together with a version that contains a fix for a given CVE. For example,<?xml version="1.0" encoding="UTF-8" ?> <<metadata xmlns="urn:redhat:patch-metadata:1"> <product-bom groupId="com.redhat.camel.springboot.platform" artifactId="camel-spring-boot-bom" versions="[3.18)" /> <cves> </cves> <fixes> <fix id="HF0-1" description="logback-classic (Example) - Version Bump"> <affects groupId="ch.qos.logback" artifactId="logback-classic" versions="[1.0,1.3.0)" fix="1.3.0" /> </fix> </fixes> </metadata>Finally a list of fixes specified in patch metadata is consulted when iterating over all managed dependencies in the current project. These dependencies (and managed dependencies) that match are changed to fixed versions. For example:
$ mvn dependency:tree [INFO] Scanning for projects... [INFO] ========== Red Hat Maven patching ========== [INFO] [PATCH] Reading patch metadata and artifacts from 3 project repositories [INFO] [PATCH] - redhat-ga-repository: http://maven.repository.redhat.com/ga/ [INFO] [PATCH] - local: file:///path/to/.m2/repository [INFO] [PATCH] - central: https://repo.maven.apache.org/maven2 [INFO] [PATCH] Resolved patch descriptor:/path/to/.m2/repository/com/redhat/camel/springboot/platform/redhat-camel-spring-boot-patch-metadata/3.18.3.redhat-00035/redhat-camel-spring-boot-patch-metadata-3.20.1.redhat-00043.xml [INFO] [PATCH] Patch metadata found for com.redhat.camel.springboot.platform/camel-spring-boot-bom/[3.20,3.21) [INFO] [PATCH] - patch contains 1 patch fix [INFO] [PATCH] Processing managed dependencies to apply patch fixes... [INFO] [PATCH] - HF0-1: logback-classic (Example) - Version Bump [INFO] [PATCH] Applying change ch.qos.logback/logback-classic/[1.0,1.3.0) -> 1.3.0 [INFO] [PATCH] Project com.test:yaml-routes [INFO] [PATCH] - managed dependency: ch.qos.logback/logback-classic/1.2.11 -> 1.3.0 [INFO] [PATCH] Done in 39ms =================================================
Skipping the patch
If you do not wish to apply a specific patch to your project, the patch-maven-plugin provides a skip option. Assuming that you have already added the patch-maven-plugin to the project’s pom.xml file, and you do not wish to alter the versions, you can use one of the following method to skip the patch.
-
Add the skip option to your project’s
pom.xmlfile as follows.
<build>
<plugins>
<plugin>
<groupId>com.redhat.camel.springboot.platform</groupId>
<artifactId>patch-maven-plugin</artifactId>
<version>${camel-spring-boot-version}</version>
<extensions>true</extensions>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
</plugins>
</build>-
Or use the
-DskipPatchoption when running themvncommand as follows.
$ mvn clean install -DskipPatch
[INFO] Scanning for projects...
[INFO]
[INFO] -------------------------< com.example:test-csb >-------------------------
[INFO] Building A Camel Spring Boot Route 1.0-SNAPSHOT
...
As shown in the above output, the patch-maven-plugin was not invoked, which resulted in the patch not being applied to the application.
'%20d='M201.5%20305.5c-13.8%200-24.9-11.1-24.9-24.6%200-13.8%2011.1-24.9%2024.9-24.9%2013.6%200%2024.6%2011.1%2024.6%2024.9%200%2013.6-11.1%2024.6-24.6%2024.6zM504%20256c0%20137-111%20248-248%20248S8%20393%208%20256%20119%208%20256%208s248%20111%20248%20248zm-132.3-41.2c-9.4%200-17.7%203.9-23.8%2010-22.4-15.5-52.6-25.5-86.1-26.6l17.4-78.3%2055.4%2012.5c0%2013.6%2011.1%2024.6%2024.6%2024.6%2013.8%200%2024.9-11.3%2024.9-24.9s-11.1-24.9-24.9-24.9c-9.7%200-18%205.8-22.1%2013.8l-61.2-13.6c-3-.8-6.1%201.4-6.9%204.4l-19.1%2086.4c-33.2%201.4-63.1%2011.3-85.5%2026.8-6.1-6.4-14.7-10.2-24.1-10.2-34.9%200-46.3%2046.9-14.4%2062.8-1.1%205-1.7%2010.2-1.7%2015.5%200%2052.6%2059.2%2095.2%20132%2095.2%2073.1%200%20132.3-42.6%20132.3-95.2%200-5.3-.6-10.8-1.9-15.8%2031.3-16%2019.8-62.5-14.9-62.5zM302.8%20331c-18.2%2018.2-76.1%2017.9-93.6%200-2.2-2.2-6.1-2.2-8.3%200-2.5%202.5-2.5%206.4%200%208.6%2022.8%2022.8%2087.3%2022.8%20110.2%200%202.5-2.2%202.5-6.1%200-8.6-2.2-2.2-6.1-2.2-8.3%200zm7.7-75c-13.6%200-24.6%2011.1-24.6%2024.9%200%2013.6%2011.1%2024.6%2024.6%2024.6%2013.8%200%2024.9-11.1%2024.9-24.6%200-13.8-11-24.9-24.9-24.9z'/%3e%3c/svg%3e){kind=small}