@Override
public MessageProperties toMessageProperties(
AMQP.BasicProperties source, Envelope envelope, String charset) {
MessageProperties properties = super.toMessageProperties(source, envelope, charset);
properties.setDeliveryMode(null);
return properties;
}
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
String id = null;
Message message = null;
boolean redelivered = false;
try {
message = (Message) invocation.getArguments()[1];
MessageProperties messageProperties = message.getMessageProperties();
if (messageProperties.getMessageId() == null) {
id = UUID.randomUUID().toString();
messageProperties.setMessageId(id);
}
redelivered = messageProperties.isRedelivered();
return invocation.proceed();
} catch (Exception e) {
if (id != null && redelivered) {
if (logger.isDebugEnabled()) {
logger.debug("Canceling delivery of retried message that has no ID");
}
throw new ListenerExecutionFailedException(
"Cannot retry message without an ID",
new AmqpRejectAndDontRequeueException(e),
message);
} else {
throw e;
}
} finally {
if (id != null) {
retryContextCache.remove(id);
}
}
}
@Override
protected void populateUserDefinedHeader(
String headerName, Object headerValue, MessageProperties amqpMessageProperties) {
// do not overwrite an existing header with the same key
// TODO: do we need to expose a boolean 'overwrite' flag?
if (!amqpMessageProperties.getHeaders().containsKey(headerName)) {
amqpMessageProperties.setHeader(headerName, headerValue);
}
}
private static MessageProperties createConnectorMessageProperties(
final String tenant, final String controllerId, final EventTopic topic) {
final MessageProperties messageProperties = createMessageProperties();
messageProperties.setHeader(MessageHeaderKey.TOPIC, topic);
messageProperties.setHeader(MessageHeaderKey.THING_ID, controllerId);
messageProperties.setHeader(MessageHeaderKey.TENANT, tenant);
messageProperties.setHeader(MessageHeaderKey.TYPE, MessageType.EVENT);
return messageProperties;
}
@Test
public void testReplyToOneDeepCustomCorrelationKey() throws Exception {
ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
Connection mockConnection = mock(Connection.class);
Channel mockChannel = mock(Channel.class);
when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
when(mockConnection.isOpen()).thenReturn(true);
when(mockConnection.createChannel()).thenReturn(mockChannel);
final RabbitTemplate template =
new RabbitTemplate(new SingleConnectionFactory(mockConnectionFactory));
template.setCorrelationKey(CORRELATION_HEADER);
Queue replyQueue = new Queue("new.replyTo");
template.setReplyQueue(replyQueue);
MessageProperties messageProperties = new MessageProperties();
messageProperties.setReplyTo("replyTo1");
messageProperties.setCorrelationId("saveThis".getBytes());
Message message = new Message("Hello, world!".getBytes(), messageProperties);
final AtomicReference<String> replyTo = new AtomicReference<String>();
final AtomicReference<String> correlationId = new AtomicReference<String>();
doAnswer(
new Answer<Object>() {
public Object answer(InvocationOnMock invocation) throws Throwable {
BasicProperties basicProps = (BasicProperties) invocation.getArguments()[4];
replyTo.set(basicProps.getReplyTo());
correlationId.set((String) basicProps.getHeaders().get(CORRELATION_HEADER));
MessageProperties springProps =
new DefaultMessagePropertiesConverter()
.toMessageProperties(basicProps, null, "UTF-8");
Message replyMessage = new Message("!dlrow olleH".getBytes(), springProps);
template.onMessage(replyMessage);
return null;
}
})
.when(mockChannel)
.basicPublish(
Mockito.any(String.class),
Mockito.any(String.class),
Mockito.anyBoolean(),
Mockito.anyBoolean(),
Mockito.any(BasicProperties.class),
Mockito.any(byte[].class));
Message reply = template.sendAndReceive(message);
assertNotNull(reply);
assertNotNull(replyTo.get());
assertEquals("new.replyTo", replyTo.get());
assertNotNull(correlationId.get());
assertEquals("replyTo1", reply.getMessageProperties().getReplyTo());
assertTrue(!"saveThis".equals(correlationId.get()));
assertEquals("replyTo1", reply.getMessageProperties().getReplyTo());
}
@Override
protected Object extractPayload(org.springframework.amqp.core.Message message) {
MessageProperties messageProperties = message.getMessageProperties();
if (this.bean != null) {
messageProperties.setTargetBean(this.bean);
}
if (this.method != null) {
messageProperties.setTargetMethod(this.method);
if (this.inferredArgumentType != null) {
messageProperties.setInferredArgumentType(this.inferredArgumentType);
}
}
return extractMessage(message);
}
@Override
protected Message createMessage(Object object, MessageProperties messageProperties) {
byte[] bytes = null;
try {
bytes = converter.serialize(object);
} catch (Exception e) {
throw new MessageConversionException("Failed to convert Message content", e);
}
messageProperties.setContentType("appication/protobuf");
if (bytes != null) {
messageProperties.setContentLength(bytes.length);
}
messageProperties.getHeaders().put("__TypeId__", object.getClass().getName());
return new Message(bytes, messageProperties);
}
@Override
public Object fromMessage(Message message) throws MessageConversionException {
Object content = null;
try {
MessageProperties properties = message.getMessageProperties();
String encoding = properties.getContentEncoding();
if (encoding == null) {
encoding = this.defaultCharset;
}
content = new String(message.getBody(), encoding);
content = JSONObject.parse((String) content);
} catch (UnsupportedEncodingException e) {
throw new MessageConversionException("failed to convert text-based Message content", e);
}
return content;
}
protected Message createMessage(Object objectToConvert, MessageProperties messageProperties)
throws MessageConversionException {
byte[] bytes;
try {
String jsonString = JSON.toJSONString(objectToConvert);
bytes = jsonString.getBytes(this.defaultCharset);
} catch (Exception e) {
throw new MessageConversionException("Failed to convert Message content", e);
}
messageProperties.setContentType(MessageProperties.CONTENT_TYPE_JSON);
messageProperties.setContentEncoding(this.defaultCharset);
if (bytes != null) {
messageProperties.setContentLength(bytes.length);
}
return new Message(bytes, messageProperties);
}
/** Extract user-defined headers from an AMQP MessageProperties instance. */
@Override
protected Map<String, Object> extractUserDefinedHeaders(MessageProperties amqpMessageProperties) {
Map<String, Object> headers = amqpMessageProperties.getHeaders();
headers.remove(AmqpHeaders.STACKED_CORRELATION_HEADER);
headers.remove(AmqpHeaders.STACKED_REPLY_TO_HEADER);
return headers;
}
@Override
protected Message createMessage(Object objectToConvert, MessageProperties messageProperties) {
byte[] bytes = null;
try {
String jsonString = JSONObject.toJSONString(objectToConvert);
bytes = jsonString.getBytes(getDefaultCharset());
} catch (IOException e) {
throw new MessageConversionException("Failed to convert Message content", e);
}
messageProperties.setContentType(MessageProperties.CONTENT_TYPE_JSON);
messageProperties.setContentEncoding(getDefaultCharset());
if (bytes != null) {
messageProperties.setContentLength(bytes.length);
}
// 不要使用,会丢掉对象属性,缺少实现
return new Message(bytes, messageProperties);
}
@Test
public void withHeaderMapperStandardAndCustomHeaders() {
AmqpInboundChannelAdapter adapter =
context.getBean(
"withHeaderMapperStandardAndCustomHeaders", AmqpInboundChannelAdapter.class);
AbstractMessageListenerContainer mlc =
TestUtils.getPropertyValue(
adapter, "messageListenerContainer", AbstractMessageListenerContainer.class);
MessageListener listener =
TestUtils.getPropertyValue(mlc, "messageListener", MessageListener.class);
MessageProperties amqpProperties = new MessageProperties();
amqpProperties.setAppId("test.appId");
amqpProperties.setClusterId("test.clusterId");
amqpProperties.setContentEncoding("test.contentEncoding");
amqpProperties.setContentLength(99L);
amqpProperties.setContentType("test.contentType");
amqpProperties.setHeader("foo", "foo");
amqpProperties.setHeader("bar", "bar");
Message amqpMessage = new Message("hello".getBytes(), amqpProperties);
listener.onMessage(amqpMessage);
QueueChannel requestChannel = context.getBean("requestChannel", QueueChannel.class);
org.springframework.integration.Message<?> siMessage = requestChannel.receive(0);
assertEquals("foo", siMessage.getHeaders().get("foo"));
assertNull(siMessage.getHeaders().get("bar"));
assertNotNull(siMessage.getHeaders().get(AmqpHeaders.CONTENT_ENCODING));
assertNotNull(siMessage.getHeaders().get(AmqpHeaders.CLUSTER_ID));
assertNotNull(siMessage.getHeaders().get(AmqpHeaders.APP_ID));
assertNotNull(siMessage.getHeaders().get(AmqpHeaders.CONTENT_TYPE));
}
public Object invoke(MethodInvocation invocation) throws Throwable {
String id = null;
try {
Message message = (Message) invocation.getArguments()[1];
MessageProperties messageProperties = message.getMessageProperties();
if (messageProperties.getMessageId() == null) {
id = UUID.randomUUID().toString();
messageProperties.setMessageId(id);
}
return invocation.proceed();
} catch (Throwable t) {
throw new AmqpRejectAndDontRequeueException("Cannot retry message without an ID", t);
} finally {
if (id != null) {
retryContextCache.remove(id);
}
}
}
@Override
protected Message createMessage(Object object, MessageProperties messageProperties) {
try {
byte[] body = null;
if (object != null) {
body = object.toString().getBytes(this.encoding);
}
String msgContentType = this.contentType == null ? DEFAULT_CONTENT_TYPE : this.contentType;
messageProperties.setContentType(msgContentType);
messageProperties.setContentEncoding(this.encoding);
messageProperties.setContentLength(body != null ? body.length : 0);
return new Message(body, messageProperties);
} catch (UnsupportedEncodingException ex) {
LOG.error("Cannot encode strings as {}", this.encoding, ex);
throw new MessageConversionException("Cannot encode strings as " + this.encoding, ex);
}
}
@Override
public Object fromMessage(Message message) throws MessageConversionException {
Object content = null;
MessageProperties properties = message.getMessageProperties();
if (properties != null) {
String contentType = properties.getContentType();
if (contentType != null && contentType.contains("protobuf")) {
try {
String classId = (String) message.getMessageProperties().getHeaders().get("__TypeId__");
if (classId == null) throw new Exception("no classId found");
Class<?> targetClass = Class.forName(classId);
content = converter.deserialize(message.getBody(), targetClass);
} catch (Exception e) {
throw new MessageConversionException("Failed to convert json-based Message content", e);
}
}
}
if (content == null) {
content = message.getBody();
}
return content;
}
@Override
public Object fromMessage(Message message) throws MessageConversionException {
MessageProperties messageProperties = message.getMessageProperties();
if (messageProperties == null)
throw new MessageConversionException("Cannot decode a message with no properties!");
byte[] body = message.getBody();
if (body == null) return null;
String messageEncoding = messageProperties.getContentEncoding();
if (messageEncoding == null) messageEncoding = this.encoding;
String messageContentType = messageProperties.getContentType();
if (this.contentType != null && !this.contentType.equalsIgnoreCase(messageContentType))
throw new MessageConversionException(
"Cannot understand a message of type " + messageContentType);
try {
return new String(body, messageEncoding);
} catch (UnsupportedEncodingException ex) {
LOG.error("Cannot dencode strings as {}", this.encoding, ex);
throw new MessageConversionException("Cannot dencode strings as " + this.encoding, ex);
}
}
@Override
public void run() {
logger.info("Running...");
while (!stopped) {
if (generating) {
Order order = generateOrder();
logger.info("Sending order: " + order.toString());
// Create Message
MessageProperties mp = new MessageProperties();
mp.setMessageId(order.getTransactionId());
Message message = new Message(order.toBytes(), mp);
// Send order
ApplicationContext ctx = CcDemoAppApplication.getApplicationContext();
RabbitTemplate rabbitTemplate = ctx.getBean(RabbitTemplate.class);
rabbitTemplate.convertAndSend(message);
OrderRepository orderRepository = ctx.getBean(OrderRepository.class);
orderRepository.save(order);
logger.info("Sent order: " + order.toString());
} else {
logger.info("Not generating...");
try {
Thread.sleep(500);
} catch (Exception e) {
return;
}
}
try {
Thread.sleep(100);
} catch (Exception e) {
return;
}
}
}
private static MessageProperties createMessageProperties() {
final MessageProperties messageProperties = new MessageProperties();
messageProperties.setContentType(MessageProperties.CONTENT_TYPE_JSON);
messageProperties.setHeader(MessageHeaderKey.CONTENT_TYPE, MessageProperties.CONTENT_TYPE_JSON);
return messageProperties;
}
public MessageProperties toMessageProperties(
final BasicProperties source, final Envelope envelope, final String charset) {
MessageProperties target = new MessageProperties();
Map<String, Object> headers = source.getHeaders();
if (!CollectionUtils.isEmpty(headers)) {
for (Map.Entry<String, Object> entry : headers.entrySet()) {
String key = entry.getKey();
if (MessageProperties.X_DELAY.equals(key)) {
Object value = entry.getValue();
if (value instanceof Integer) {
target.setReceivedDelay((Integer) value);
}
} else {
target.setHeader(key, convertLongStringIfNecessary(entry.getValue(), charset));
}
}
}
target.setTimestamp(source.getTimestamp());
target.setMessageId(source.getMessageId());
target.setReceivedUserId(source.getUserId());
target.setAppId(source.getAppId());
target.setClusterId(source.getClusterId());
target.setType(source.getType());
Integer deliveryMode = source.getDeliveryMode();
if (deliveryMode != null) {
target.setReceivedDeliveryMode(MessageDeliveryMode.fromInt(deliveryMode));
}
target.setDeliveryMode(null);
target.setExpiration(source.getExpiration());
target.setPriority(source.getPriority());
target.setContentType(source.getContentType());
target.setContentEncoding(source.getContentEncoding());
String correlationId = source.getCorrelationId();
if (StringUtils.hasText(correlationId)) {
target.setCorrelationId(source.getCorrelationId());
}
String replyTo = source.getReplyTo();
if (replyTo != null) {
target.setReplyTo(replyTo);
}
if (envelope != null) {
target.setReceivedExchange(envelope.getExchange());
target.setReceivedRoutingKey(envelope.getRoutingKey());
target.setRedelivered(envelope.isRedeliver());
target.setDeliveryTag(envelope.getDeliveryTag());
}
return target;
}
public BasicProperties fromMessageProperties(
final MessageProperties source, final String charset) {
BasicProperties.Builder target = new BasicProperties.Builder();
target
.headers(this.convertHeadersIfNecessary(source.getHeaders()))
.timestamp(source.getTimestamp())
.messageId(source.getMessageId())
.userId(source.getUserId())
.appId(source.getAppId())
.clusterId(source.getClusterId())
.type(source.getType());
MessageDeliveryMode deliveryMode = source.getDeliveryMode();
if (deliveryMode != null) {
target.deliveryMode(MessageDeliveryMode.toInt(deliveryMode));
}
target
.expiration(source.getExpiration())
.priority(source.getPriority())
.contentType(source.getContentType())
.contentEncoding(source.getContentEncoding());
String correlationId = source.getCorrelationId();
if (StringUtils.hasText(correlationId)) {
target.correlationId(correlationId);
}
String replyTo = source.getReplyTo();
if (replyTo != null) {
target.replyTo(replyTo);
}
return target.build();
}
@Override
public void run() {
try {
RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
while (true) {
final Event event = events.take();
LoggingEvent logEvent = event.getEvent();
String name = logEvent.getLogger().getName();
Level level = logEvent.getLevel();
MessageProperties amqpProps = new MessageProperties();
amqpProps.setDeliveryMode(deliveryMode);
amqpProps.setContentType(contentType);
if (null != contentEncoding) {
amqpProps.setContentEncoding(contentEncoding);
}
amqpProps.setHeader(CATEGORY_NAME, name);
amqpProps.setHeader(CATEGORY_LEVEL, level.toString());
if (generateId) {
amqpProps.setMessageId(UUID.randomUUID().toString());
}
// Set applicationId, if we're using one
if (null != applicationId) {
amqpProps.setAppId(applicationId);
}
// Set timestamp
Calendar tstamp = Calendar.getInstance();
tstamp.setTimeInMillis(logEvent.getTimeStamp());
amqpProps.setTimestamp(tstamp.getTime());
// Copy properties in from MDC
@SuppressWarnings("rawtypes")
Map props = event.getProperties();
@SuppressWarnings("unchecked")
Set<Entry<?, ?>> entrySet = props.entrySet();
for (Entry<?, ?> entry : entrySet) {
amqpProps.setHeader(entry.getKey().toString(), entry.getValue());
}
LocationInfo locInfo = logEvent.getLocationInformation();
if (!"?".equals(locInfo.getClassName())) {
amqpProps.setHeader(
"location",
String.format(
"%s.%s()[%s]",
locInfo.getClassName(), locInfo.getMethodName(), locInfo.getLineNumber()));
}
StringBuilder msgBody;
String routingKey;
synchronized (layoutMutex) {
msgBody = new StringBuilder(layout.format(logEvent));
routingKey = routingKeyLayout.format(logEvent);
}
if (layout.ignoresThrowable() && null != logEvent.getThrowableInformation()) {
ThrowableInformation tinfo = logEvent.getThrowableInformation();
for (String line : tinfo.getThrowableStrRep()) {
msgBody.append(String.format("%s%n", line));
}
}
// Send a message
try {
Message message = null;
if (AmqpAppender.this.charset != null) {
try {
message =
new Message(msgBody.toString().getBytes(AmqpAppender.this.charset), amqpProps);
} catch (UnsupportedEncodingException e) {
/* fall back to default */
}
}
if (message == null) {
message =
new Message(
msgBody.toString().getBytes(), amqpProps); // NOSONAR (default charset)
}
message = postProcessMessageBeforeSend(message, event);
rabbitTemplate.send(exchangeName, routingKey, message);
} catch (AmqpException e) {
int retries = event.incrementRetries();
if (retries < maxSenderRetries) {
// Schedule a retry based on the number of times I've tried to re-send this
retryTimer.schedule(
new TimerTask() {
@Override
public void run() {
events.add(event);
}
},
(long) (Math.pow(retries, Math.log(retries)) * 1000));
} else {
errorHandler.error(
"Could not send log message "
+ logEvent.getRenderedMessage()
+ " after "
+ maxSenderRetries
+ " retries",
e,
ErrorCode.WRITE_FAILURE,
logEvent);
}
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
/** Extract "standard" headers from an AMQP MessageProperties instance. */
@Override
protected Map<String, Object> extractStandardHeaders(MessageProperties amqpMessageProperties) {
Map<String, Object> headers = new HashMap<String, Object>();
try {
String appId = amqpMessageProperties.getAppId();
if (StringUtils.hasText(appId)) {
headers.put(AmqpHeaders.APP_ID, appId);
}
String clusterId = amqpMessageProperties.getClusterId();
if (StringUtils.hasText(clusterId)) {
headers.put(AmqpHeaders.CLUSTER_ID, clusterId);
}
String contentEncoding = amqpMessageProperties.getContentEncoding();
if (StringUtils.hasText(contentEncoding)) {
headers.put(AmqpHeaders.CONTENT_ENCODING, contentEncoding);
}
long contentLength = amqpMessageProperties.getContentLength();
if (contentLength > 0) {
headers.put(AmqpHeaders.CONTENT_LENGTH, contentLength);
}
String contentType = amqpMessageProperties.getContentType();
if (StringUtils.hasText(contentType)) {
headers.put(AmqpHeaders.CONTENT_TYPE, contentType);
}
byte[] correlationId = amqpMessageProperties.getCorrelationId();
if (correlationId != null && correlationId.length > 0) {
headers.put(AmqpHeaders.CORRELATION_ID, correlationId);
}
MessageDeliveryMode deliveryMode = amqpMessageProperties.getDeliveryMode();
if (deliveryMode != null) {
headers.put(AmqpHeaders.DELIVERY_MODE, deliveryMode);
}
long deliveryTag = amqpMessageProperties.getDeliveryTag();
if (deliveryTag > 0) {
headers.put(AmqpHeaders.DELIVERY_TAG, deliveryTag);
}
String expiration = amqpMessageProperties.getExpiration();
if (StringUtils.hasText(expiration)) {
headers.put(AmqpHeaders.EXPIRATION, expiration);
}
Integer messageCount = amqpMessageProperties.getMessageCount();
if (messageCount != null && messageCount > 0) {
headers.put(AmqpHeaders.MESSAGE_COUNT, messageCount);
}
String messageId = amqpMessageProperties.getMessageId();
if (StringUtils.hasText(messageId)) {
headers.put(AmqpHeaders.MESSAGE_ID, messageId);
}
Integer priority = amqpMessageProperties.getPriority();
if (priority != null && priority > 0) {
headers.put(MessageHeaders.PRIORITY, priority);
}
String receivedExchange = amqpMessageProperties.getReceivedExchange();
if (StringUtils.hasText(receivedExchange)) {
headers.put(AmqpHeaders.RECEIVED_EXCHANGE, receivedExchange);
}
String receivedRoutingKey = amqpMessageProperties.getReceivedRoutingKey();
if (StringUtils.hasText(receivedRoutingKey)) {
headers.put(AmqpHeaders.RECEIVED_ROUTING_KEY, receivedRoutingKey);
}
Boolean redelivered = amqpMessageProperties.isRedelivered();
if (redelivered != null) {
headers.put(AmqpHeaders.REDELIVERED, redelivered);
}
String replyTo = amqpMessageProperties.getReplyTo();
if (replyTo != null) {
headers.put(AmqpHeaders.REPLY_TO, replyTo);
}
Date timestamp = amqpMessageProperties.getTimestamp();
if (timestamp != null) {
headers.put(AmqpHeaders.TIMESTAMP, timestamp);
}
String type = amqpMessageProperties.getType();
if (StringUtils.hasText(type)) {
headers.put(AmqpHeaders.TYPE, type);
}
String userId = amqpMessageProperties.getUserId();
if (StringUtils.hasText(userId)) {
headers.put(AmqpHeaders.USER_ID, userId);
}
Object replyCorrelation =
amqpMessageProperties.getHeaders().get(AmqpHeaders.STACKED_CORRELATION_HEADER);
if (replyCorrelation instanceof String) {
if (StringUtils.hasText((String) replyCorrelation)) {
headers.put(AmqpHeaders.SPRING_REPLY_CORRELATION, replyCorrelation);
}
}
Object replyToStack =
amqpMessageProperties.getHeaders().get(AmqpHeaders.STACKED_REPLY_TO_HEADER);
if (replyToStack instanceof String) {
if (StringUtils.hasText((String) replyToStack)) {
headers.put(AmqpHeaders.SPRING_REPLY_TO_STACK, replyToStack);
}
}
} catch (Exception e) {
if (logger.isWarnEnabled()) {
logger.warn("error occurred while mapping from AMQP properties to MessageHeaders", e);
}
}
return headers;
}
/**
* Maps headers from a Spring Integration MessageHeaders instance to the MessageProperties of an
* AMQP Message.
*/
@Override
protected void populateStandardHeaders(
Map<String, Object> headers, MessageProperties amqpMessageProperties) {
String appId = getHeaderIfAvailable(headers, AmqpHeaders.APP_ID, String.class);
if (StringUtils.hasText(appId)) {
amqpMessageProperties.setAppId(appId);
}
String clusterId = getHeaderIfAvailable(headers, AmqpHeaders.CLUSTER_ID, String.class);
if (StringUtils.hasText(clusterId)) {
amqpMessageProperties.setClusterId(clusterId);
}
String contentEncoding =
getHeaderIfAvailable(headers, AmqpHeaders.CONTENT_ENCODING, String.class);
if (StringUtils.hasText(contentEncoding)) {
amqpMessageProperties.setContentEncoding(contentEncoding);
}
Long contentLength = getHeaderIfAvailable(headers, AmqpHeaders.CONTENT_LENGTH, Long.class);
if (contentLength != null) {
amqpMessageProperties.setContentLength(contentLength);
}
String contentType = this.extractContentTypeAsString(headers);
if (StringUtils.hasText(contentType)) {
amqpMessageProperties.setContentType(contentType);
}
Object correlationId = headers.get(AmqpHeaders.CORRELATION_ID);
if (correlationId instanceof byte[]) {
amqpMessageProperties.setCorrelationId((byte[]) correlationId);
}
MessageDeliveryMode deliveryMode =
getHeaderIfAvailable(headers, AmqpHeaders.DELIVERY_MODE, MessageDeliveryMode.class);
if (deliveryMode != null) {
amqpMessageProperties.setDeliveryMode(deliveryMode);
}
Long deliveryTag = getHeaderIfAvailable(headers, AmqpHeaders.DELIVERY_TAG, Long.class);
if (deliveryTag != null) {
amqpMessageProperties.setDeliveryTag(deliveryTag);
}
String expiration = getHeaderIfAvailable(headers, AmqpHeaders.EXPIRATION, String.class);
if (StringUtils.hasText(expiration)) {
amqpMessageProperties.setExpiration(expiration);
}
Integer messageCount = getHeaderIfAvailable(headers, AmqpHeaders.MESSAGE_COUNT, Integer.class);
if (messageCount != null) {
amqpMessageProperties.setMessageCount(messageCount);
}
String messageId = getHeaderIfAvailable(headers, AmqpHeaders.MESSAGE_ID, String.class);
if (StringUtils.hasText(messageId)) {
amqpMessageProperties.setMessageId(messageId);
}
Integer priority = getHeaderIfAvailable(headers, MessageHeaders.PRIORITY, Integer.class);
if (priority != null) {
amqpMessageProperties.setPriority(priority);
}
String receivedExchange =
getHeaderIfAvailable(headers, AmqpHeaders.RECEIVED_EXCHANGE, String.class);
if (StringUtils.hasText(receivedExchange)) {
amqpMessageProperties.setReceivedExchange(receivedExchange);
}
String receivedRoutingKey =
getHeaderIfAvailable(headers, AmqpHeaders.RECEIVED_ROUTING_KEY, String.class);
if (StringUtils.hasText(receivedRoutingKey)) {
amqpMessageProperties.setReceivedRoutingKey(receivedRoutingKey);
}
Boolean redelivered = getHeaderIfAvailable(headers, AmqpHeaders.REDELIVERED, Boolean.class);
if (redelivered != null) {
amqpMessageProperties.setRedelivered(redelivered);
}
String replyTo = getHeaderIfAvailable(headers, AmqpHeaders.REPLY_TO, String.class);
if (replyTo != null) {
amqpMessageProperties.setReplyTo(replyTo);
}
Date timestamp = getHeaderIfAvailable(headers, AmqpHeaders.TIMESTAMP, Date.class);
if (timestamp != null) {
amqpMessageProperties.setTimestamp(timestamp);
}
String type = getHeaderIfAvailable(headers, AmqpHeaders.TYPE, String.class);
if (type != null) {
amqpMessageProperties.setType(type);
}
String userId = getHeaderIfAvailable(headers, AmqpHeaders.USER_ID, String.class);
if (StringUtils.hasText(userId)) {
amqpMessageProperties.setUserId(userId);
}
String replyCorrelation =
getHeaderIfAvailable(headers, AmqpHeaders.SPRING_REPLY_CORRELATION, String.class);
if (StringUtils.hasLength(replyCorrelation)) {
amqpMessageProperties.setHeader("spring_reply_correlation", replyCorrelation);
}
String replyToStack =
getHeaderIfAvailable(headers, AmqpHeaders.SPRING_REPLY_TO_STACK, String.class);
if (StringUtils.hasLength(replyToStack)) {
amqpMessageProperties.setHeader("spring_reply_to", replyToStack);
}
}
@Test
public void testReplyToThreeDeepCustomCorrelationKey() throws Exception {
ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class);
Connection mockConnection = mock(Connection.class);
Channel mockChannel = mock(Channel.class);
when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection);
when(mockConnection.isOpen()).thenReturn(true);
when(mockConnection.createChannel()).thenReturn(mockChannel);
final RabbitTemplate template =
new RabbitTemplate(new SingleConnectionFactory(mockConnectionFactory));
template.setCorrelationKey(CORRELATION_HEADER);
Queue replyQueue = new Queue("replyTo2");
template.setReplyQueue(replyQueue);
MessageProperties messageProperties = new MessageProperties();
messageProperties.setReplyTo("replyTo1");
messageProperties.setCorrelationId("a".getBytes());
Message message = new Message("Hello, world!".getBytes(), messageProperties);
final AtomicInteger count = new AtomicInteger();
final List<String> nestedReplyTo = new ArrayList<String>();
final List<String> nestedCorrelation = new ArrayList<String>();
doAnswer(
new Answer<Object>() {
public Object answer(InvocationOnMock invocation) throws Throwable {
BasicProperties basicProps = (BasicProperties) invocation.getArguments()[4];
nestedReplyTo.add(basicProps.getReplyTo());
nestedCorrelation.add(basicProps.getCorrelationId());
MessageProperties springProps =
new DefaultMessagePropertiesConverter()
.toMessageProperties(basicProps, null, "UTF-8");
Message replyMessage = new Message("!dlrow olleH".getBytes(), springProps);
if (count.incrementAndGet() < 2) {
Message anotherMessage = new Message("Second".getBytes(), springProps);
template.setReplyQueue(new Queue("replyTo3"));
replyMessage = template.sendAndReceive(anotherMessage);
nestedReplyTo.add(replyMessage.getMessageProperties().getReplyTo());
nestedCorrelation.add(
(String)
replyMessage.getMessageProperties().getHeaders().get(CORRELATION_HEADER));
}
template.onMessage(replyMessage);
return null;
}
})
.when(mockChannel)
.basicPublish(
Mockito.any(String.class),
Mockito.any(String.class),
Mockito.anyBoolean(),
Mockito.anyBoolean(),
Mockito.any(BasicProperties.class),
Mockito.any(byte[].class));
Message reply = template.sendAndReceive(message);
assertNotNull(reply);
assertEquals(3, nestedReplyTo.size());
assertEquals("replyTo2", nestedReplyTo.get(0));
assertEquals("replyTo3", nestedReplyTo.get(1));
assertEquals("replyTo2", nestedReplyTo.get(2)); // intermediate reply
assertEquals("replyTo1", reply.getMessageProperties().getReplyTo());
assertEquals("a", new String(reply.getMessageProperties().getCorrelationId(), "UTF-8"));
}
@Override
public void run() {
try {
RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
while (true) {
final Event event = events.take();
ILoggingEvent logEvent = event.getEvent();
String name = logEvent.getLoggerName();
Level level = logEvent.getLevel();
MessageProperties amqpProps = new MessageProperties();
amqpProps.setDeliveryMode(deliveryMode);
amqpProps.setContentType(contentType);
if (null != contentEncoding) {
amqpProps.setContentEncoding(contentEncoding);
}
amqpProps.setHeader(CATEGORY_NAME, name);
amqpProps.setHeader(CATEGORY_LEVEL, level.toString());
if (generateId) {
amqpProps.setMessageId(UUID.randomUUID().toString());
}
// Set timestamp
Calendar tstamp = Calendar.getInstance();
tstamp.setTimeInMillis(logEvent.getTimeStamp());
amqpProps.setTimestamp(tstamp.getTime());
// Copy properties in from MDC
Map<String, String> props = event.getProperties();
Set<Entry<String, String>> entrySet = props.entrySet();
for (Entry<String, String> entry : entrySet) {
amqpProps.setHeader(entry.getKey(), entry.getValue());
}
String[] location = locationLayout.doLayout(logEvent).split("\\|");
if (!"?".equals(location[0])) {
amqpProps.setHeader(
"location", String.format("%s.%s()[%s]", location[0], location[1], location[2]));
}
String msgBody;
String routingKey = routingKeyLayout.doLayout(logEvent);
// Set applicationId, if we're using one
if (applicationId != null) {
amqpProps.setAppId(applicationId);
}
if (abbreviator != null && logEvent instanceof LoggingEvent) {
((LoggingEvent) logEvent).setLoggerName(abbreviator.abbreviate(name));
msgBody = layout.doLayout(logEvent);
((LoggingEvent) logEvent).setLoggerName(name);
} else {
msgBody = layout.doLayout(logEvent);
}
// Send a message
try {
Message message = null;
if (AmqpAppender.this.charset != null) {
try {
message = new Message(msgBody.getBytes(AmqpAppender.this.charset), amqpProps);
} catch (UnsupportedEncodingException e) {
message = new Message(msgBody.getBytes(), amqpProps); // NOSONAR (default charset)
}
}
message = postProcessMessageBeforeSend(message, event);
rabbitTemplate.send(exchangeName, routingKey, message);
} catch (AmqpException e) {
int retries = event.incrementRetries();
if (retries < maxSenderRetries) {
// Schedule a retry based on the number of times I've tried to re-send this
retryTimer.schedule(
new TimerTask() {
@Override
public void run() {
events.add(event);
}
},
(long) (Math.pow(retries, Math.log(retries)) * 1000));
} else {
addError(
"Could not send log message "
+ logEvent.getMessage()
+ " after "
+ maxSenderRetries
+ " retries",
e);
}
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
private void checkDeliveryMode(Message<?> requestMessage, MessageProperties messageProperties) {
if (this.defaultDeliveryMode != null
&& requestMessage.getHeaders().get(AmqpHeaders.DELIVERY_MODE) == null) {
messageProperties.setDeliveryMode(this.defaultDeliveryMode);
}
}
