How to Use Apache Camel ProducerTemplate With Spring Boot

1. Overview

Apache Camel allows us to implement different enterprise integration patterns in Java. It provides the ProducerTemplate interface, which enables us to send messages to the Camel route. Using Spring Boot, we can send messages from REST endpoints to an Apache Camel route for further processing.

In this tutorial, we’ll explore the basics of ProducerTemplate and how it can act as a bridge between Spring Boot endpoints and Apache Camel routes.

2. Understanding ProducerTemplate

Just as JdbcTemplate is used to interact with databases, ProducerTemplate interacts with the Camel route by passing messages to it from different sources. The two most used methods provided by the ProducerTemplate interface are:

• sendBody() – This method sends an inOnly message. It returns void, meaning the sender doesn’t expect a response from the Camel route
• requestBody() – This method allows us to send an inOut message, meaning we get a response from the Camel route when we send a message

Both methods allow us to implement the inOnly and inOut messaging patterns.

3. Maven Dependencies

To see the ProducerTemplate in action, let’s bootstrap a Spring Boot application with Apache Camel by adding the spring-boot-starter and camel-spring-boot-starter dependencies to the pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>3.5.3</version>
</dependency>
<dependency>
    <groupId>org.apache.camel.springboot</groupId>
    <artifactId>camel-spring-boot-starter</artifactId>
    <version>4.12.0</version>
</dependency>

The spring-boot-starter dependency provides classes to write Spring MVC and RESTful applications in Java, while the camel-spring-boot-starter dependency provides seamless integration with Spring Boot.

4. Creating a Route

First, let’s define a Camel route by creating a class  named CamelRoute in our Spring Boot application:

@Component
class CamelRoute extends RouteBuilder {
    @Override
    public void configure() {
        from("direct:start").log("Received: ${body}")
          .transform(simple("Hello ${body}"));
        from("direct:fileRoute").to("file://output?fileName=output.txt&fileExist=Append");
        from("direct:beanRoute").bean(ProcessingBean.class, "process");
    }
    @Bean
    public ProcessingBean processingBean() {
        return new ProcessingBean();
    }
}

In the code above, we annotated the class with the @Commponent annotation and defined three Camel routes. The first route receives a message, logs it to the console, and transforms the original message. The next route appends a message to a file. If the output directory doesn’t exist, Camel creates it automatically.

The final route forwards the message to a bean for further processing. Let’s see the bean class:

class ProcessingBean {
    public String process(String input) {
        return "Bean processed " + input.toUpperCase();
    }
}

Here, the bean processes the message by converting it to uppercase and returns a new message body.

5. Controller and Test Classes

Moving on, let’s create a controller class and inject the ProducerTemplate interface:

@RestController
public class ProducerTemplateController {
    @Autowired
    private ProducerTemplate producerTemplate;
}

We can now use the sendBody() and requestBody() methods to send inOnly or inOut messages, respectively.

Also, let’s create a test class named ProducerTemplateIntegrationTest:

@CamelSpringBootTest
@SpringBootTest(classes = ProducerTemplateApplication.class)
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
class ProducerTemplateIntegrationTest {
    @Autowired
    private ProducerTemplateController producerTemplateController;
    private static final String TEST_MESSAGE = "TestMessage";
    private static final Path OUTPUT_FILE = Paths.get("output/output.txt");
    // ...
}

In the code above, we annotate the test class with @SpringBootTest  and specify the application to be tested. Finally, we define two variables to store a message and the path to a file.

5.1. Sending Message to direct:start Route

Let’s create an endpoint that sends a message to our first Camel route:

@GetMapping("/send/simple/{message}")
public String sendSimpleMessage(@PathVariable String message) {
    String response = producerTemplate.requestBody("direct:start", message, String.class);
    return response;
}

The endpoint above accepts a message passed as a path variable in the URL path. Next, we send a message to direct:start route. Since we invoke requestBody() on producerTemplate, this follows an inOut messaging pattern. Next, we return the transformed message from the Camel route.

Let’s write a test to verify the response:

@Test
void givenMessage_whenSendingSimpleMessage_thenReturnsProcessedMessage() {
    String inputMessage = TEST_MESSAGE;
    String response = producerTemplateController.sendSimpleMessage(inputMessage);
    assertNotNull(response, "Response should not be null");
    assertEquals("Hello " + inputMessage, response);
}

In the code above, we invoke the sendSimpleMessage() method on the producerTemplateController instance. Then we verify that the response is not null. Finally, we ascertain that the response matches the expected response.

5.2. Sending Message to direct:fileRoute Route

Furthermore, let’s write a new Spring Boot endpoint in our controller class:

@GetMapping("/send/file/{message}")
public String sendToFile(@PathVariable String message) {
    producerTemplate.sendBody("direct:fileRoute", message + "\n");
    return "Message appended to output.txt";
}

Here, we append the message from the endpoint to a file. In this case, we use the sendBody() method, meaning we are not expecting a response from the Camel route, since this uses the inOnly messaging pattern.

Next, let’s write a test to confirm if a message is appended to a file:

@Test
void givenMessage_whenSendingToFile_thenFileContainsMessage() throws IOException {
    String inputMessage = TEST_MESSAGE;
    String response = producerTemplateController.sendToFile(inputMessage);
    assertEquals("Message appended to output.txt", response);
    assertTrue(Files.exists(OUTPUT_FILE));
    String fileContent = Files.readString(OUTPUT_FILE);
    assertTrue(fileContent.contains(inputMessage));
}

In the test above, we ascertain that the output file exists and it contains the expected message.

5.3. Sending Message to direct:beanRoute Route

Finally, let’s write a controller method that sends a message to the direct:beanRoute route:

@GetMapping("/send/bean/{message}")
public String sendToBean(@PathVariable String message) {
    String response = producerTemplate.requestBody("direct:beanRoute", message, String.class);
    return response;
}

The endpoint above receives a message that’s passed to a camel route. The Camel route processes the message and returns the processed message.

Let’s confirm that the correct response was returned by writing a test:

@Test
void givenMessage_whenSendingToBean_thenReturnsUppercaseMessage() {
    String inputMessage = TEST_MESSAGE;
    String response = producerTemplateController.sendToBean(inputMessage);
    assertNotNull(response);
    assertEquals("Bean processed " + inputMessage.toUpperCase(), response);
}

The sendToBean() method sends a message to a bean that transforms it to uppercase. We ascertain that the expected response is returned.

6. Conclusion

In this article, we learned how to use the ProducerTemplate in a Spring Boot and Apache Camel application. Also, we demonstrate how to send both inOnly and inOut messages from REST endpoints to Camel routes using practical examples.

As always, the full source code for the examples is available over on GitHub.