Apache Camel with Spring Boot

Apache Camel is a powerful open-source integration framework based on known Enterprise Integration Patterns (EIP). It provides a versatile set of tools to integrate various systems, APIs, and protocols seamlessly. Integrating Apache Camel with Spring Boot makes it easier to create standalone applications that can handle complex routing and mediation scenarios. This tutorial will guide you through the process of setting up Apache Camel with Spring Boot.

Prerequisites

• JDK 17 or later
• Maven or Gradle
• IDE (IntelliJ IDEA, Eclipse, etc.)

Step 1: Set Up a Spring Boot Project

1.1 Create a New Spring Boot Project

Use Spring Initializr to create a new project with the following dependencies:

• Spring Web
• Apache Camel

Download and unzip the project, then open it in your IDE.

1.2 Add Apache Camel Dependencies

If you didn't add the Apache Camel dependency via Spring Initializr, add the following dependencies to your pom.xml (for Maven) or build.gradle (for Gradle).

For Maven:

<dependency>
    <groupId>org.apache.camel.springboot</groupId>
    <artifactId>camel-spring-boot-starter</artifactId>
    <version>3.16.0</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-core</artifactId>
    <version>3.16.0</version>
</dependency>

For Gradle:

implementation 'org.apache.camel.springboot:camel-spring-boot-starter:3.16.0'
implementation 'org.apache.camel:camel-core:3.16.0'

Step 2: Configure Apache Camel in Spring Boot

2.1 Create a Simple Camel Route

Create a Camel route by defining a route builder class. This class will define how messages are routed from one endpoint to another.

package com.example.demo.routes;

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

@Component
public class SimpleRouteBuilder extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("timer:hello?period=1000")
                .log("Hello from Camel!")
                .to("stream:out");
    }
}

Explanation:

• @Component: Marks this class as a Spring component.
• RouteBuilder: A base class for creating Camel routes.
• from("timer:hello?period=1000"): A timer endpoint that triggers every second (1000 milliseconds).
• log("Hello from Camel!"): Logs a message to the console.
• to("stream:out"): Sends the output to the standard output stream (console).

2.2 Configure application.properties

Set up the application properties for your project. This file is located in the src/main/resources directory.

# src/main/resources/application.properties

camel.springboot.name=camel-spring-boot-demo
camel.springboot.main-run-controller=true
camel.springboot.routes-collector-enabled=true

Explanation:

• camel.springboot.name: Sets the name of the Camel application.
• camel.springboot.main-run-controller=true: Allows the application to keep running.
• camel.springboot.routes-collector-enabled=true: Enables route collection from the Spring context.

Step 3: Create a REST Endpoint Using Camel

3.1 Create a REST Route

Create a new Camel route to handle REST requests.

package com.example.demo.routes;

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

@Component
public class RestRouteBuilder extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        restConfiguration().component("servlet").port(8080).bindingMode(RestBindingMode.json);

        rest("/api")
                .get("/hello")
                .to("direct:helloRoute");

        from("direct:helloRoute")
                .setBody(constant("Hello, World from Apache Camel!"))
                .log("Processed REST request to /api/hello");
    }
}

Explanation:

• restConfiguration().component("servlet").port(8080).bindingMode(RestBindingMode.json): Configures the REST component to use the servlet container on port 8080 with JSON binding.
• rest("/api").get("/hello").to("direct:helloRoute"): Defines a REST endpoint at /api/hello that routes requests to direct:helloRoute.
• from("direct:helloRoute").setBody(constant("Hello, World from Apache Camel!")).log("Processed REST request to /api/hello"): Sets up the route to handle requests by setting a constant response body and logging the request.

Step 4: Create a Main Application Class

Ensure your main application class is annotated with @SpringBootApplication.

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Step 5: Running and Testing the Application

5.1 Run the Application

Run the Spring Boot application using your IDE or the command line:

./mvnw spring-boot:run

5.2 Test the Timer Route

Check the console output to see the log messages from the timer route. You should see "Hello from Camel!" logged every second.

5.3 Test the REST Endpoint

Open your browser or use a tool like Postman to test the REST endpoint.

• URL: http://localhost:8080/api/hello
• Method: GET

You should see the following response:

"Hello, World from Apache Camel!"

Step 6: Advanced Camel Features (Optional)

6.1 Using a File Component

You can use the file component to read from and write to files.

package com.example.demo.routes;

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

@Component
public class FileRouteBuilder extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("file:input?noop=true")
                .log("Reading file: ${file:name}")
                .to("file:output");
    }
}

Explanation:

• from("file:input?noop=true"): Reads files from the input directory without deleting them.
• log("Reading file: ${file:name}"): Logs the name of the file being read.
• to("file:output"): Writes the files to the output directory.

6.2 Using a JMS Component

You can use the JMS component to send and receive messages from a JMS queue.

package com.example.demo.routes;

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

@Component
public class JmsRouteBuilder extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("jms:queue:inputQueue")
                .log("Received message: ${body}")
                .to("jms:queue:outputQueue");
    }
}

Explanation:

• from("jms:queue:inputQueue"): Reads messages from the inputQueue.
• log("Received message: ${body}"): Logs the message body.
• to("jms:queue:outputQueue"): Sends the messages to the outputQueue.

Conclusion

In this tutorial, you have learned how to integrate Apache Camel with Spring Boot to create a flexible and powerful integration solution. We covered:

• Setting up a Spring Boot project with Apache Camel.
• Creating simple and REST-based Camel routes.
• Running and testing the application.

By leveraging Apache Camel's powerful integration capabilities within a Spring Boot application, you can handle complex routing and mediation scenarios with ease.