Spring Boot 3 + Apache Camel Hello World Example(2023)

Before we actually look at what is Apache Camel and when to use it, let us first look at other required concepts.

What is Enterprise Application Integration?

Consider a scenario of a big organization like Nike. They will be having different departments each having its own business softwares like supply chain management applications, ERP systems, CRM applications for managing customers, business intelligence applications, payroll and human resources. Such systems cannot communicate with one another in order to share data or business rules. For this reason, such applications are sometimes referred to as islands of automation or information silos. This lack of communication leads to inefficiencies, wherein identical data are stored in multiple locations, or straightforward processes are unable to be automated.

Enterprise application integration is the process of linking such applications within a single organization together in order to simplify and automate business processes to the greatest extent possible, while at the same time avoiding having to make sweeping changes to the existing applications or data structures.

What is Apache Camel?

Implementing communication between the different department is a complex process as each department might have its own process and specifications. They might use different message data format and so communication between departments will require transformation of these messages. Implementing code for point to point communication between the departments is one solution. However this leads to tight coupling between the departments.Any change in one department will cause a lot of refactoring.
The best approach to this type of problem is to use a mediation framework. Mediation reduces complexity and provides a more flexible approach by adding and using a tier between the systems.
Apache Camel is a rule-based routing and mediation engine that provides a Java object-based implementation of the Enterprise Integration Patterns using an API (or declarative Java Domain Specific Language) to configure routing and mediation rules. To better understand what is apache camel, lets first understand what are Enterprise Applications and Enterprise Integration Patterns.

What are EIPs?

When we write Java Code, we follow Design Patterns for better coding practices. Some of the benefits of using design patterns are: Design Patterns are already defined and provides industry standard approach to solve a recurring problem, so it saves time if we sensibly use the design pattern. Similarly for Enterprise Application Integration we use Enterprise Integration Patterns as these are proven solutions for recurring problems during application integration.

Implementation

Go to the Spring Boot Initializer website and create a new spring boot project as follows- Our final maven project will be as follows -

The pom.xml will have the following dependencies-

<?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.3.6</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.java</groupId>
	<artifactId>camel-boot</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>

	<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.8.1</version>
		</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>
			</plugin>
		</plugins>
	</build>

</project>

What are Routes?

Route is the most important unit of Apache Camel. Using Routes we define the message flow and integration logic for our application.
Apache Camel Routes can be written in various Domain Specific Languages(DSL). Most popular are-

• Java DSL - A Java based DSL
• Spring XML - A XML based DSL in Spring XML files

For this example we make use of Java DSL for writing Routes. A Route consists of Message Channel using which applications communicate using Messages. The end points of these message channels either consume or produce messages.

Apache Camel Component

Apache Camel Routes are used to connect different Components together. A route often starts with a Component, which is responsible for creating a message. The message then passes through the Route, where it can be processed, modified, or routed to a different Component. The end result is usually an output from another Component that is sent to a final endpoint.
As we have to transfer file from one location to another so we will be making use of File Component.

So let us create the HelloWorldRouteBuilder class which extends the RouteBuilder class. RouteBuilder is a class from the Apache Camel library that allows us to build a route from a source to a destination. It provides methods to define the source and destination, as well as any necessary processing logic. We have used the RouteBuilder to create a route from 'C://input' to 'C://output'.

package com.javastructures.camelboot;

import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldRouteBuilder extends RouteBuilder {

	@Override
	public void configure() throws Exception {
		from("file:C://input").to("file:C://output");
	}

}

We are done with the changes. Start the Spring Boot Application and we can see that 1 route has been started.

All files from input folder will be automatically copied to the output folder.

Download Source Code

Download it -
Spring Boot + Apache Camel Hello World Example