com.rabbitmq.client

Class RpcClient

java.lang.Object

com.rabbitmq.client.RpcClient

Direct Known Subclasses:

JsonRpcClient

public class RpcClient
extends Object

Convenience class which manages simple RPC-style communication. The class is agnostic about the format of RPC arguments / return values. It simply provides a mechanism for sending a message to an exchange with a given routing key, and waiting for a response.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	RpcClient.Response The response object is an envelope that contains all of the data provided to the `handleDelivery` consumer

Field Summary

Fields

Modifier and Type	Field and Description
protected static int	NO_TIMEOUT NO_TIMEOUT value must match convention on BlockingCell.uninterruptibleGet(int)

Constructor Summary

Constructors

Constructor and Description
RpcClient(Channel channel, String exchange, String routingKey) Construct a new RpcClient that will communicate on the given channel, sending requests to the given exchange with the given routing key.
RpcClient(Channel channel, String exchange, String routingKey, int timeout) Construct a new RpcClient that will communicate on the given channel, sending requests to the given exchange with the given routing key.
RpcClient(Channel channel, String exchange, String routingKey, String replyTo) Construct a new RpcClient that will communicate on the given channel, sending requests to the given exchange with the given routing key.
RpcClient(Channel channel, String exchange, String routingKey, String replyTo, int timeout) Construct a new RpcClient that will communicate on the given channel, sending requests to the given exchange with the given routing key.

Method Summary

Modifier and Type	Method and Description
void	checkConsumer() Private API - ensures the RpcClient is correctly open.
void	close() Public API - cancels the consumer, thus deleting the temporary queue, and marks the RpcClient as closed.
RpcClient.Response	doCall(AMQP.BasicProperties props, byte[] message)
Channel	getChannel() Retrieve the channel.
Consumer	getConsumer() Retrieve the consumer.
Map<String,BlockingCell<Object>>	getContinuationMap() Retrieve the continuation map.
int	getCorrelationId() Retrieve the correlation id.
String	getExchange() Retrieve the exchange.
String	getRoutingKey() Retrieve the routing key.
Map<String,Object>	mapCall(Map<String,Object> message) Perform an AMQP wire-protocol-table based RPC roundtrip There are some restrictions on the values appearing in the table: they must be of type String, LongString, Integer, BigDecimal, Date, or (recursively) a Map of the enclosing type.
Map<String,Object>	mapCall(Object[] keyValuePairs) Perform an AMQP wire-protocol-table based RPC roundtrip, first constructing the table from an array of alternating keys (in even-numbered elements, starting at zero) and values (in odd-numbered elements, starting at one) Restrictions on value arguments apply as in mapCall(Map).
byte[]	primitiveCall(AMQP.BasicProperties props, byte[] message)
byte[]	primitiveCall(byte[] message) Perform a simple byte-array-based RPC roundtrip.
void	publish(AMQP.BasicProperties props, byte[] message)
RpcClient.Response	responseCall(byte[] message) Perform a simple byte-array-based RPC roundtrip Useful if you need to get at more than just the body of the message
protected DefaultConsumer	setupConsumer() Registers a consumer on the reply queue.
String	stringCall(String message) Perform a simple string-based RPC roundtrip.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

NO_TIMEOUT

protected static final int NO_TIMEOUT

NO_TIMEOUT value must match convention on BlockingCell.uninterruptibleGet(int)

See Also:

Constant Field Values

Constructor Detail

RpcClient

public RpcClient(Channel channel,
                 String exchange,
                 String routingKey,
                 String replyTo,
                 int timeout)
          throws IOException

Construct a new RpcClient that will communicate on the given channel, sending requests to the given exchange with the given routing key. Causes the creation of a temporary private autodelete queue. The name of this queue can be specified.

Parameters:

channel - the channel to use for communication

exchange - the exchange to connect to

routingKey - the routing key

replyTo - the queue where the server should put the reply

timeout - milliseconds before timing out on wait for response

Throws:

IOException - if an error is encountered

RpcClient

public RpcClient(Channel channel,
                 String exchange,
                 String routingKey,
                 String replyTo)
          throws IOException

Construct a new RpcClient that will communicate on the given channel, sending requests to the given exchange with the given routing key. Causes the creation of a temporary private autodelete queue. The name of the queue can be provided (only relevant for RabbitMQ servers that do not support Direct Reply-to. Waits forever for responses (that is, no timeout).

Parameters:

channel - the channel to use for communication

exchange - the exchange to connect to

routingKey - the routing key

replyTo - the queue where the server should put the reply

Throws:

IOException - if an error is encountered

RpcClient

public RpcClient(Channel channel,
                 String exchange,
                 String routingKey)
          throws IOException

Construct a new RpcClient that will communicate on the given channel, sending requests to the given exchange with the given routing key. Direct Reply-to will be used for response propagation. Waits forever for responses (that is, no timeout).

Parameters:

channel - the channel to use for communication

exchange - the exchange to connect to

routingKey - the routing key

Throws:

IOException - if an error is encountered

RpcClient

public RpcClient(Channel channel,
                 String exchange,
                 String routingKey,
                 int timeout)
          throws IOException

Construct a new RpcClient that will communicate on the given channel, sending requests to the given exchange with the given routing key.

Causes the creation of a temporary private autodelete queue. The name of this queue will be "amq.rabbitmq.reply-to".

Parameters:

channel - the channel to use for communication

exchange - the exchange to connect to

routingKey - the routing key

timeout - milliseconds before timing out on wait for response

Throws:

IOException - if an error is encountered

Method Detail

checkConsumer

public void checkConsumer()
                   throws IOException

Private API - ensures the RpcClient is correctly open.

Throws:

IOException - if an error is encountered

close

public void close()
           throws IOException

Public API - cancels the consumer, thus deleting the temporary queue, and marks the RpcClient as closed.

Throws:

IOException - if an error is encountered

setupConsumer

protected DefaultConsumer setupConsumer()
                                 throws IOException

Registers a consumer on the reply queue.

Returns:

the newly created and registered consumer

Throws:

IOException - if an error is encountered

publish

public void publish(AMQP.BasicProperties props,
                    byte[] message)
             throws IOException

Throws:

IOException

doCall

public RpcClient.Response doCall(AMQP.BasicProperties props,
                                 byte[] message)
                          throws IOException,
                                 ShutdownSignalException,
                                 TimeoutException

Throws:

IOException

ShutdownSignalException

TimeoutException

primitiveCall

public byte[] primitiveCall(AMQP.BasicProperties props,
                            byte[] message)
                     throws IOException,
                            ShutdownSignalException,
                            TimeoutException

Throws:

IOException

ShutdownSignalException

TimeoutException

primitiveCall

public byte[] primitiveCall(byte[] message)
                     throws IOException,
                            ShutdownSignalException,
                            TimeoutException

Perform a simple byte-array-based RPC roundtrip.

Parameters:

message - the byte array request message to send

Returns:

the byte array response received

Throws:

ShutdownSignalException - if the connection dies during our wait

IOException - if an error is encountered

TimeoutException - if a response is not received within the configured timeout

responseCall

public RpcClient.Response responseCall(byte[] message)
                                throws IOException,
                                       ShutdownSignalException,
                                       TimeoutException

Perform a simple byte-array-based RPC roundtrip Useful if you need to get at more than just the body of the message

Parameters:

message - the byte array request message to send

Returns:

The response object is an envelope that contains all of the data provided to the `handleDelivery` consumer

Throws:

ShutdownSignalException - if the connection dies during our wait

IOException - if an error is encountered

TimeoutException - if a response is not received within the configured timeout

stringCall

public String stringCall(String message)
                  throws IOException,
                         ShutdownSignalException,
                         TimeoutException

Perform a simple string-based RPC roundtrip.

Parameters:

message - the string request message to send

Returns:

the string response received

Throws:

ShutdownSignalException - if the connection dies during our wait

IOException - if an error is encountered

TimeoutException - if a timeout occurs before the response is received

mapCall

public Map<String,Object> mapCall(Map<String,Object> message)
                           throws IOException,
                                  ShutdownSignalException,
                                  TimeoutException

Perform an AMQP wire-protocol-table based RPC roundtrip

There are some restrictions on the values appearing in the table:
they must be of type String, LongString, Integer, BigDecimal, Date, or (recursively) a Map of the enclosing type.

Parameters:

message - the table to send

Returns:

the table received

Throws:

ShutdownSignalException - if the connection dies during our wait

IOException - if an error is encountered

TimeoutException - if a timeout occurs before a response is received

mapCall

public Map<String,Object> mapCall(Object[] keyValuePairs)
                           throws IOException,
                                  ShutdownSignalException,
                                  TimeoutException

Perform an AMQP wire-protocol-table based RPC roundtrip, first constructing the table from an array of alternating keys (in even-numbered elements, starting at zero) and values (in odd-numbered elements, starting at one)
Restrictions on value arguments apply as in mapCall(Map).

Parameters:

keyValuePairs - alternating {key, value, key, value, ...} data to send

Returns:

the table received

Throws:

ShutdownSignalException - if the connection dies during our wait

IOException - if an error is encountered

TimeoutException - if a timeout occurs before a response is received

getChannel

public Channel getChannel()

Retrieve the channel.

Returns:

the channel to which this client is connected

getExchange

public String getExchange()

Retrieve the exchange.

Returns:

the exchange to which this client is connected

getRoutingKey

public String getRoutingKey()

Retrieve the routing key.

Returns:

the routing key for messages to this client

getContinuationMap

public Map<String,BlockingCell<Object>> getContinuationMap()

Retrieve the continuation map.

Returns:

the map of objects to blocking cells for this client

getCorrelationId

public int getCorrelationId()

Retrieve the correlation id.

Returns:

the most recently used correlation id

getConsumer

public Consumer getConsumer()

Retrieve the consumer.

Returns:

an interface to the client's consumer object