The consumer template provides methods for polling a consumer endpoint in order to receive incoming messages. You can choose to receive the incoming message either in the form of an exchange object or in the form of a message body (where the message body can be cast to a particular type using a built-in type converter).
You can use a consumer template to poll a consumer endpoint for exchanges using
one of the following polling methods: blocking receive()
;
receive()
with a timeout; or receiveNoWait()
, which
returns immediately. Because a consumer endpoint represents a service, it is also
essential to start the service thread by calling start()
before you
attempt to poll for exchanges.
The following example shows how to poll an exchange from the seda:foo
consumer endpoint using the blocking receive()
method:
import org.apache.camel.ProducerTemplate; import org.apache.camel.ConsumerTemplate; import org.apache.camel.Exchange; ... ProducerTemplate template = context.createProducerTemplate(); ConsumerTemplate consumer = context.createConsumerTemplate(); // Start the consumer service consumer.start(); ... template.sendBody("seda:foo", "Hello"); Exchange out = consumer.receive("seda:foo"); ... // Stop the consumer service consumer.stop();
Where the consumer template instance, consumer
, is instantiated using
the CamelContext.createConsumerTemplate()
method and the consumer
service thread is started by calling ConsumerTemplate.start()
.
You can also poll a consumer endpoint for incoming message bodies using one of the
following methods: blocking receiveBody()
; receiveBody()
with a timeout; or receiveBodyNoWait()
, which returns immediately. As
in the previous example, it is also essential to start the service thread by calling
start()
before you attempt to poll for exchanges.
The following example shows how to poll an incoming message body from the
seda:foo
consumer endpoint using the blocking
receiveBody()
method:
import org.apache.camel.ProducerTemplate; import org.apache.camel.ConsumerTemplate; ... ProducerTemplate template = context.createProducerTemplate(); ConsumerTemplate consumer = context.createConsumerTemplate(); // Start the consumer service consumer.start(); ... template.sendBody("seda:foo", "Hello"); Object body = consumer.receiveBody("seda:foo"); ... // Stop the consumer service consumer.stop();
There are three basic methods for polling exchanges from a
consumer endpoint: receive()
without a timeout blocks indefinitely;
receive()
with a timeout blocks for the specified period of
milliseconds; and receiveNoWait()
is non-blocking. You can specify the
consumer endpoint either as an endpoint URI or as an Endpoint
instance.
Exchange receive(String endpointUri); Exchange receive(String endpointUri, long timeout); Exchange receiveNoWait(String endpointUri); Exchange receive(Endpoint endpoint); Exchange receive(Endpoint endpoint, long timeout); Exchange receiveNoWait(Endpoint endpoint);
There are three basic methods for polling message bodies from
a consumer endpoint: receiveBody()
without a timeout blocks
indefinitely; receiveBody()
with a timeout blocks for the specified
period of milliseconds; and receiveBodyNoWait()
is non-blocking. You
can specify the consumer endpoint either as an endpoint URI or as an
Endpoint
instance. Moreover, by calling the templating forms of
these methods, you can convert the returned body to a particular type,
T
, using a built-in type converter.
Object receiveBody(String endpointUri); Object receiveBody(String endpointUri, long timeout); Object receiveBodyNoWait(String endpointUri); Object receiveBody(Endpoint endpoint); Object receiveBody(Endpoint endpoint, long timeout); Object receiveBodyNoWait(Endpoint endpoint); <T> T receiveBody(String endpointUri, Class<T> type); <T> T receiveBody(String endpointUri, long timeout, Class<T> type); <T> T receiveBodyNoWait(String endpointUri, Class<T> type); <T> T receiveBody(Endpoint endpoint, Class<T> type); <T> T receiveBody(Endpoint endpoint, long timeout, Class<T> type); <T> T receiveBodyNoWait(Endpoint endpoint, Class<T> type);