Apache Camel provides templates so your Java code can easily send to and receive from endpoints without dealing with low‑level Exchange and Endpoint APIs.
What is a ProducerTemplate?
ProducerTemplate is a helper that lets your Java code send messages into Camel endpoints. It wraps the producer side of the Camel API behind simple methods so you can focus on business logic instead of message plumbing.
Key points:
- Created from a
CamelContextusingcontext.createProducerTemplate(). - Supports one‑way and request–reply interactions (
send*vsrequest*methods). - Manages producers and thread usage internally, so you should create it once and reuse it.
The rationale is to decouple your application logic from route definitions: routes describe how data flows, while templates describe when your code chooses to send something into those flows.
ProducerTemplate Example
import org.apache.camel.CamelContext;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;
void main() throws Exception {
CamelContext context = new DefaultCamelContext();
// Define a simple echo route
context.addRoutes(new RouteBuilder() {
@Override
public void configure() {
from("direct:echo")
.setBody(simple("Echo: ${body}"));
}
});
context.start();
// Create and reuse a ProducerTemplate
ProducerTemplate producer = context.createProducerTemplate();
// Fire-and-forget: send a message into the route
producer.sendBody("direct:echo", "Hello (InOnly)");
// Request-reply: get a response from the echo route
String reply = producer.requestBody("direct:echo",
"Hello (InOut)",
String.class);
System.out.println("Reply from direct:echo = " + reply);
context.stop();
}Why this structure:
- The route
from("direct:echo")declares the integration behavior once. ProducerTemplatelets any Java code call that route as if it were a function, with a minimal API.- Reusing one template instance avoids creating many producers and threads, which is better for performance and resource usage.
What is a ConsumerTemplate?
ConsumerTemplate is the receiving counterpart: it lets Java code poll an endpoint and retrieve messages on demand. Instead of defining a continuously running from(...) route for everything, you can occasionally pull messages when your logic needs them.
Key points:
- Created from a
CamelContextusingcontext.createConsumerTemplate(). - Provides blocking (
receiveBody), timed (receiveBody(uri, timeout)), and non‑blocking (receiveBodyNoWait) methods. - Returns
nullwhen a timed or non‑blocking call finds no message.
The rationale is to support imperative “give me at most one message now” patterns, which fit tests, command‑style tools, or workflows controlled by your own scheduler.
ConsumerTemplate Example
The following example uses both templates with the same seda:inbox endpoint, so you can see how sending and receiving fit together.
import org.apache.camel.CamelContext;
import org.apache.camel.ConsumerTemplate;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;
void main() throws Exception {
CamelContext context = new DefaultCamelContext();
// Route just logs anything arriving on seda:inbox
context.addRoutes(new RouteBuilder() {
@Override
public void configure() {
from("seda:inbox")
.log("Route saw: ${body}");
}
});
context.start();
// Create and reuse templates
ProducerTemplate producer = context.createProducerTemplate();
ConsumerTemplate consumer = context.createConsumerTemplate();
// 1) Send a message into the SEDA endpoint
producer.sendBody("seda:inbox", "Hello from ProducerTemplate");
// 2) Poll the same endpoint using ConsumerTemplate (blocking receive)
Object body = consumer.receiveBody("seda:inbox");
System.out.println("ConsumerTemplate received = " + body);
// 3) Timed receive: wait up to 2 seconds for another message
Object maybeBody = consumer.receiveBody("seda:inbox", 2000);
if (maybeBody == null) {
System.out.println("No more messages within 2 seconds");
}
context.stop();
}Why this structure:
- Both templates share the same context, so they see the same routes and endpoints.
ProducerTemplatepushes a message toseda:inbox, andConsumerTemplatepulls from that sameseda:inbox, clearly demonstrating their complementary roles.- The timed receive shows how you can avoid blocking forever, which is important when you control thread lifecycles yourself.
FluentProducerTemplate: an optional fluent variant
FluentProducerTemplate is a fluent wrapper around the producer concept, giving a builder‑like syntax for setting body, headers, and endpoint
Example:
import org.apache.camel.CamelContext;
import org.apache.camel.FluentProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;
void main() throws Exception {
CamelContext context = new DefaultCamelContext();
context.addRoutes(new RouteBuilder() {
@Override
public void configure() {
from("direct:greet")
.setBody(simple("Hi ${header.name}, body was: ${body}"));
}
});
context.start();
FluentProducerTemplate fluent = context.createFluentProducerTemplate();
String result = fluent
.to("direct:greet")
.withHeader("name", "Alice")
.withBody("Sample body")
.request(String.class);
System.out.println("Fluent reply = " + result);
context.stop();
}Why this exists:
- It makes the send configuration self‑describing at the call site (endpoint, headers, body are all visible in one fluent chain).
- It is especially handy when constructing slightly different calls to the same route, since you can reuse the template and vary the fluent chain arguments.
Recent Comments