Spring Boot – Using Spring Boot with Apache Camel
Apache Camel and Spring Boot are two powerful frameworks that can be seamlessly integrated to build robust, scalable, and efficient applications. Apache Camel is an open-source integration framework that provides an extensive range of components and connectors, enabling developers to integrate different systems, APIs, and applications. It simplifies complex enterprise integration patterns, allowing developers to focus more on business logic rather than the intricacies of integration.
This article will guide you on how to use Apache Camel within a Spring Boot application. We will walk through setting up a simple Camel route using Spring Boot, demonstrating how to leverage the strengths of both frameworks for effective application integration.
Apache Camel
Apache Camel is an open-source integration framework that enables developers to integrate various systems, APIs, and applications using a variety of protocols and technologies. It offers a set of predefined patterns and connectors to handle integration logic efficiently.
Use Apache Camel with Spring Boot
Combining Apache Camel with Spring Boot offers a powerful toolkit for developing robust, scalable, and maintainable integration solutions. Camel's routing capabilities and Spring Boot's auto-configuration support work together to create a seamless development experience.
Camel Route
A Camel route defines the flow of messages between different components in an application. Routes are defined using domain-specific languages (DSL) like Java, XML, or YAML. Camel provides various components like Direct, File, HTTP, JMS, and more for routing messages.
Integration Patterns
Camel provides various enterprise integration patterns (EIPs) such as message routing, filtering, transformation, and aggregation. These patterns help in solving complex integration problems efficiently.
Camel Context
The Camel context is the runtime environment where the routes are executed. It acts as the central point of configuration, allowing developers to manage routes, components, and services.
Implementation of Spring Boot with Apache Camel
Step 1: Create a New Spring Boot Project
Create a new Spring Boot project using IntelliJ IDEA. Choose the following options:
- Name:
spring-boot-camel-integration
- Language:
Java
- Type:
Maven
- Packaging:
Jar
Click on the "Next" button.

Step 2: Add Dependencies
Add the following dependencies into the Spring Boot project.

Project Structure
Once the project is created, the file structure will look like this:

Step 3: Configure Application Properties
Open the application.properties
file and add the following configuration:
# Application name
spring.application.name=spring-boot-camel-integration
# Log level for Apache Camel
logging.level.org.apache.camel=INFO
# Log file name
logging.file.name=application.log
Step 4: Define the Camel Route
Create a Java file named FileMoveRoute.java
. This class defines a simple route that moves files from one directory to another in the Spring Boot application.
package com.gfg.springbootcamelintegration;
import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;
/**
* FileMoveRoute class defines a simple Camel route that moves files
* from a source directory to a destination directory.
*/
@Component
public class FileMoveRoute extends RouteBuilder {
@Override
public void configure() throws Exception {
// Define the route starting from a direct component
from("direct:fileMoveRoute")
.log("Processing file: ${file:name}") // Log the name of the file being processed
.to("file:C:/Users/Syam/OneDrive/Desktop/Testing Folder/destination?fileName=${file:name.noext}.bak"); // Move the file to the destination directory and rename it with a .bak extension
}
}
- The
FileMoveRoute
class extendsRouteBuilder
and overrides theconfigure()
method to define the route. - The route starts from the
direct:fileMoveRoute
endpoint, logs the file name being processed, and moves the file to the specified destination directory.
Step 5: Create the Controller to Trigger the Camel Route
Create a Java file named FileController.java
. This controller exposes a REST endpoint to trigger the Camel route.
package com.gfg.springbootcamelintegration;
import org.apache.camel.ProducerTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* FileController class provides a REST endpoint to trigger the Camel route.
*/
@RestController
public class FileController {
@Autowired
private ProducerTemplate producerTemplate; // Inject ProducerTemplate to send messages to Camel routes
/**
* This endpoint starts the file move process by triggering the Camel route.
*
* @return String message indicating the start of the process
*/
@GetMapping("/startFileMove")
public String startFileMove() {
producerTemplate.sendBody("direct:fileMoveRoute", "Sample content"); // Trigger the Camel route with sample content
return "File move process started!";
}
}
- The
FileController
class is annotated with@RestController
, making it a Spring MVC controller. - It uses
ProducerTemplate
to send messages to the Camel route. - The
startFileMove()
method triggers the Camel route by sending a message to thedirect:fileMoveRoute
endpoint.
Step 6: Main class
No changes are required in the main class. This is the entry point of the Spring Boot application.
package com.gfg.springbootcamelintegration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* SpringBootCamelIntegrationApplication class serves as the entry point of the Spring Boot application.
*/
@SpringBootApplication
public class SpringBootCamelIntegrationApplication {
public static void main(String[] args) {
SpringApplication.run(SpringBootCamelIntegrationApplication.class, args); // Start the Spring Boot application
}
}
pom.xml File:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.9</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.gfg</groupId>
<artifactId>spring-boot-camel-integration</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot-camel-integration</name>
<description>spring-boot-camel-integration</description>
<url/>
<licenses>
<license/>
</licenses>
<developers>
<developer/>
</developers>
<scm>
<connection/>
<developerConnection/>
<tag/>
<url/>
</scm>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.apache.camel.springboot</groupId>
<artifactId>camel-spring-boot-starter</artifactId>
<version>4.6.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>
Step 7: Run the Application
Once the project is completed, you can start the Spring Boot application. The application will run on port 8080.

Step 8: Testing the Application
To test the application, open a web browser or use a tool like Postman to send a GET request to the following URL:
http://localhost:8080/startFileMove
Output:

Verify the Output
After sending the request, check the destination directory to verify that the file has been moved and renamed with a .bak
extension.

Conclusion
Using Apache Camel with Spring Boot provides a powerful, flexible, and scalable solution for building integration and message routing applications. With Camel's rich set of components and Spring Boot's auto-configuration capabilities, developers can easily implement complex routing logic and integrate various systems. This tutorial demonstrated how to set up a simple file-moving route, but Apache Camel offers much more, including support for complex enterprise integration patterns.