org.springframework.amqp.core.MessageProperties java code examples

Refine search

Message

  @RabbitListener(queues=MQConfig.MIAOSHATEST)
  public void receiveMiaoShaMessage(Message message, Channel channel) throws IOException {
    log.info("接受到的消息为:{}",message);
    String messRegister = new String(message.getBody(), "UTF-8");
    channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
    MiaoShaMessageVo msm  = RedisService.stringToBean(messRegister, MiaoShaMessageVo.class);
    messageService.insertMs(msm);
    }
}

@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)
      && !AmqpHeaders.CONTENT_TYPE.equals(headerName)) {
    amqpMessageProperties.setHeader(headerName, headerValue);
  }
}

  @Override
  public Message postProcessMessage(Message message) throws AmqpException {
    //给消息设置延迟毫秒值
    message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
    return message;
  }
});

void setConsumerSpan(Span span, MessageProperties properties) {
 span.name("next-message").kind(CONSUMER);
 maybeTag(span, RABBIT_EXCHANGE, properties.getReceivedExchange());
 maybeTag(span, RABBIT_ROUTING_KEY, properties.getReceivedRoutingKey());
 maybeTag(span, RABBIT_QUEUE, properties.getConsumerQueue());
 if (remoteServiceName != null) span.remoteServiceName(remoteServiceName);
}

  Object[] args = invocation.getArguments();
  org.springframework.amqp.core.Message amqpRequestMessage = (org.springframework.amqp.core.Message) args[2];
  MessageProperties properties = amqpRequestMessage.getMessageProperties();
  assertNull(properties.getHeaders().get("foo"));
  MessageProperties amqpProperties = new MessageProperties();
  amqpProperties.setAppId("test.appId");
  amqpProperties.setHeader("foobar", "foobar");
  amqpProperties.setHeader("bar", "bar");
  return new org.springframework.amqp.core.Message("hello".getBytes(), amqpProperties);
})
    .when(amqpTemplate).sendAndReceive(Mockito.any(String.class), Mockito.any(String.class),

private void assertLower(MessageProperties properties) {
  assertEquals("appId", properties.getAppId());
  assertEquals("clusterId", properties.getClusterId());
  assertEquals("contentEncoding", properties.getContentEncoding());
  assertEquals(MessageProperties.CONTENT_TYPE_TEXT_PLAIN, properties.getContentType());
  assertEquals(1, properties.getContentLength());
  assertEquals("correlationId", properties.getCorrelationId());
  assertEquals(MessageDeliveryMode.NON_PERSISTENT, properties.getDeliveryMode());
  assertEquals(2, properties.getDeliveryTag());
  assertEquals("expiration", properties.getExpiration());
  assertEquals("bar", properties.getHeaders().get("foo"));
  assertEquals("fiz", properties.getHeaders().get("qux"));
  assertEquals("fuz", properties.getHeaders().get("baz"));
  assertEquals(Integer.valueOf(3), properties.getMessageCount());
  assertEquals("messageId", properties.getMessageId());
  assertEquals(Integer.valueOf(4), properties.getPriority());
  assertEquals("receivedExchange", properties.getReceivedExchange());
  assertEquals("receivedRoutingKey", properties.getReceivedRoutingKey());
  assertTrue(properties.getRedelivered());
  assertTrue(properties.getTimestamp().getTime() > 0);
  assertEquals("type", properties.getType());
  assertEquals("userId", properties.getUserId());
}

String appId = getHeaderIfAvailable(headers, AmqpHeaders.APP_ID, String.class);
if (StringUtils.hasText(appId)) {
  amqpMessageProperties.setAppId(appId);
  amqpMessageProperties.setClusterId(clusterId);
  amqpMessageProperties.setContentEncoding(contentEncoding);
  amqpMessageProperties.setContentLength(contentLength);
  amqpMessageProperties.setContentType(contentType);
  amqpMessageProperties.setCorrelationId(correlationId);
  amqpMessageProperties.setDelay(delay);
  amqpMessageProperties.setDeliveryMode(deliveryMode);
  amqpMessageProperties.setDeliveryTag(deliveryTag);
  amqpMessageProperties.setExpiration(expiration);
  amqpMessageProperties.setMessageCount(messageCount);
  amqpMessageProperties.setMessageId(messageId);
    amqpMessageProperties.setMessageId(id.toString());
  amqpMessageProperties.setPriority(priority);

  /**
   * {@inheritDoc}
   */
  @Override
  public Message postProcessMessage(final Message message) throws AmqpException
  {
    if (message == null)
    {
      return message;
    }

    final MessageProperties messageProperties = message.getMessageProperties();

    messageProperties.setTimestamp(this.properties.getTimestamp());

    final byte[] correlationId = this.properties.getCorrelationId();
    messageProperties.setCorrelationId(correlationId);

    messageProperties.setCorrelationIdString(this.properties.getCorrelationIdString());

    messageProperties.setReplyTo(this.properties.getReplyTo());
    messageProperties.setExpiration(this.properties.getExpiration());

    return message;
  }
}

MessageProperties amqpProperties = new MessageProperties();
headerMapper.fromHeadersToRequest(integrationHeaders, amqpProperties);
Set<String> headerKeys = amqpProperties.getHeaders().keySet();
for (String headerKey : headerKeys) {
  if (headerKey.startsWith(AmqpHeaders.PREFIX) || headerKey.equals("contentType")) {
assertEquals("test.appId", amqpProperties.getAppId());
assertEquals("test.clusterId", amqpProperties.getClusterId());
assertEquals("test.contentEncoding", amqpProperties.getContentEncoding());
assertEquals(99L, amqpProperties.getContentLength());
assertEquals("test.contentType", amqpProperties.getContentType());
assertEquals(testCorrelationId, amqpProperties.getCorrelationId());
assertEquals(Integer.valueOf(1234), amqpProperties.getDelay());
assertEquals(MessageDeliveryMode.NON_PERSISTENT, amqpProperties.getDeliveryMode());
assertEquals(1234L, amqpProperties.getDeliveryTag());
assertEquals("test.expiration", amqpProperties.getExpiration());
assertEquals(new Integer(42), amqpProperties.getMessageCount());
assertEquals("test.messageId", amqpProperties.getMessageId());
assertEquals("test.receivedExchange", amqpProperties.getReceivedExchange());
assertEquals("test.receivedRoutingKey", amqpProperties.getReceivedRoutingKey());
assertEquals("test.replyTo", amqpProperties.getReplyTo());
assertEquals(testTimestamp, amqpProperties.getTimestamp());
assertEquals("test.type", amqpProperties.getType());
assertEquals("test.userId", amqpProperties.getUserId());
assertNull(amqpProperties.getHeaders().get(MessageHeaders.ERROR_CHANNEL));
assertNull(amqpProperties.getHeaders().get(MessageHeaders.REPLY_CHANNEL));

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);
  String correlationId = amqpMessageProperties.getCorrelationId();
  if (StringUtils.hasText(correlationId)) {
    headers.put(AmqpHeaders.CORRELATION_ID, correlationId);
  MessageDeliveryMode receivedDeliveryMode = amqpMessageProperties.getReceivedDeliveryMode();
  if (receivedDeliveryMode != null) {
    headers.put(AmqpHeaders.RECEIVED_DELIVERY_MODE, receivedDeliveryMode);

@Test
public void toHeaders() {
  DefaultAmqpHeaderMapper headerMapper = DefaultAmqpHeaderMapper.inboundMapper();
  MessageProperties amqpProperties = new MessageProperties();
  amqpProperties.setAppId("test.appId");
  amqpProperties.setClusterId("test.clusterId");
  amqpProperties.setContentEncoding("test.contentEncoding");
  amqpProperties.setContentLength(99L);
  amqpProperties.setContentType("test.contentType");
  String testCorrelationId = "foo";
  amqpProperties.setCorrelationId(testCorrelationId);
  amqpProperties.setReceivedDeliveryMode(MessageDeliveryMode.NON_PERSISTENT);
  amqpProperties.setDeliveryTag(1234L);
  amqpProperties.setExpiration("test.expiration");
  amqpProperties.setMessageCount(42);
  amqpProperties.setMessageId("test.messageId");
  amqpProperties.setPriority(22);
  amqpProperties.setReceivedDelay(4567);
  amqpProperties.setReceivedExchange("test.receivedExchange");
  amqpProperties.setReceivedRoutingKey("test.receivedRoutingKey");
  amqpProperties.setRedelivered(true);
  amqpProperties.setReplyTo("test.replyTo");
  Date testTimestamp = new Date();
  amqpProperties.setTimestamp(testTimestamp);
  amqpProperties.setType("test.type");
  amqpProperties.setReceivedUserId("test.userId");
  amqpProperties.setHeader(AmqpHeaders.SPRING_REPLY_CORRELATION, "test.correlation");
  amqpProperties.setHeader(AmqpHeaders.SPRING_REPLY_TO_STACK, "test.replyTo2");
  Map<String, Object> headerMap = headerMapper.toHeadersFromReply(amqpProperties);
  assertEquals("test.appId", headerMap.get(AmqpHeaders.APP_ID));

public static SpringAMQPMessage setBasicPropertiesToHeaders(SpringAMQPMessage msg, Message amqpMessage) {
  msg.getHeaders().put(MESSAGE_ID, amqpMessage.getMessageProperties().getMessageId());
  byte[] correlationId = amqpMessage.getMessageProperties().getCorrelationId();
  msg.getHeaders().put(CORRELATION_ID, correlationId == null ? null : new String(correlationId));
  msg.getHeaders().put(CONTENT_ENCODING, amqpMessage.getMessageProperties().getContentEncoding());
  msg.getHeaders().put(CONTENT_TYPE, amqpMessage.getMessageProperties().getContentType());
  msg.getHeaders().put(EXPIRATION, amqpMessage.getMessageProperties().getExpiration());
  msg.getHeaders().put(PRIORITY, amqpMessage.getMessageProperties().getPriority());
  msg.getHeaders().put(REPLY_TO, amqpMessage.getMessageProperties().getReplyTo());
  msg.getHeaders().put(DELIVERY_MODE, MessageDeliveryMode.toInt(amqpMessage.getMessageProperties().getDeliveryMode()));
  msg.getHeaders().put(TYPE, amqpMessage.getMessageProperties().getType());
  return msg;
}

@Test
public void withHeaderMapperNothingToMap() throws Exception {
  AmqpInboundChannelAdapter adapter = context.getBean("withHeaderMapperNothingToMap",
      AmqpInboundChannelAdapter.class);
  AbstractMessageListenerContainer mlc =
      TestUtils.getPropertyValue(adapter, "messageListenerContainer", AbstractMessageListenerContainer.class);
  ChannelAwareMessageListener listener = TestUtils.getPropertyValue(mlc, "messageListener",
      ChannelAwareMessageListener.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, null);
  QueueChannel requestChannel = context.getBean("requestChannel", QueueChannel.class);
  org.springframework.messaging.Message<?> siMessage = requestChannel.receive(0);
  assertNull(siMessage.getHeaders().get("foo"));
  assertNull(siMessage.getHeaders().get("bar"));
  assertNull(siMessage.getHeaders().get(AmqpHeaders.CONTENT_ENCODING));
  assertNull(siMessage.getHeaders().get(AmqpHeaders.CLUSTER_ID));
  assertNull(siMessage.getHeaders().get(AmqpHeaders.APP_ID));
  assertNull(siMessage.getHeaders().get(AmqpHeaders.CONTENT_TYPE));
}

private org.springframework.messaging.Message<Object> createMessage(Message message, Channel channel) {
  Object payload = AmqpInboundChannelAdapter.this.messageConverter.fromMessage(message);
  Map<String, Object> headers = AmqpInboundChannelAdapter.this.headerMapper
      .toHeadersFromRequest(message.getMessageProperties());
  if (AmqpInboundChannelAdapter.this.messageListenerContainer.getAcknowledgeMode()
      == AcknowledgeMode.MANUAL) {
    headers.put(AmqpHeaders.DELIVERY_TAG, message.getMessageProperties().getDeliveryTag());
    headers.put(AmqpHeaders.CHANNEL, channel);
  }
  if (AmqpInboundChannelAdapter.this.retryTemplate != null) {
    headers.put(IntegrationMessageHeaderAccessor.DELIVERY_ATTEMPT, new AtomicInteger());
  }
  final org.springframework.messaging.Message<Object> messagingMessage = getMessageBuilderFactory()
      .withPayload(payload)
      .copyHeaders(headers)
      .build();
  return messagingMessage;
}

  Object[] args = invocation.getArguments();
  Message amqpReplyMessage = (Message) args[2];
  MessageProperties properties = amqpReplyMessage.getMessageProperties();
  assertEquals("bar", properties.getHeaders().get("bar"));
  return null;
}).when(amqpTemplate).send(Mockito.any(String.class), Mockito.any(String.class),
ChannelAwareMessageListener listener = TestUtils.getPropertyValue(mlc, "messageListener",
    ChannelAwareMessageListener.class);
MessageProperties amqpProperties = new MessageProperties();
amqpProperties.setAppId("test.appId");
amqpProperties.setClusterId("test.clusterId");
amqpProperties.setContentEncoding("test.contentEncoding");
amqpProperties.setContentLength(99L);
amqpProperties.setReplyTo("oleg");
amqpProperties.setContentType("test.contentType");
amqpProperties.setHeader("foo", "foo");
amqpProperties.setHeader("bar", "bar");
Message amqpMessage = new Message("hello".getBytes(), amqpProperties);
listener.onMessage(amqpMessage, null);

@Test
public void adapterWithContentType() throws Exception {
  RabbitTemplate template = new RabbitTemplate(this.connectionFactory);
  template.setDefaultReceiveQueue(this.queue.getName());
  while (template.receive() != null) {
    // drain
  }
  Message<?> message = MessageBuilder.withPayload("hello")
      .setHeader(AmqpHeaders.CONTENT_TYPE, "application/json")
      .build();
  this.ctRequestChannel.send(message);
  org.springframework.amqp.core.Message m = receive(template);
  assertNotNull(m);
  assertEquals("\"hello\"", new String(m.getBody(), "UTF-8"));
  assertEquals("application/json", m.getMessageProperties().getContentType());
  assertEquals("java.lang.String",
      m.getMessageProperties().getHeaders().get(JsonHeaders.TYPE_ID.replaceFirst(JsonHeaders.PREFIX, "")));
  message = MessageBuilder.withPayload("hello")
      .build();
  this.ctRequestChannel.send(message);
  m = receive(template);
  assertNotNull(m);
  assertEquals("hello", new String(m.getBody(), "UTF-8"));
  assertEquals("text/plain", m.getMessageProperties().getContentType());
  while (template.receive() != null) {
    // drain
  }
}

  @Override
  public Object getKey(Message message)
  {
    if (message.getMessageProperties().getMessageId() != null)
    {
      return message.getMessageProperties().getMessageId();
    }
    else
    {
      return UNDEFINED_MESSAGE_KEY;
    }
  }
}

private String getOrSetCorrelationIdAndSetReplyTo(Message message) {
  String correlationId;
  MessageProperties messageProperties = message.getMessageProperties();
  Assert.notNull(messageProperties, "the message properties cannot be null");
  String currentCorrelationId = messageProperties.getCorrelationId();
  if (!StringUtils.hasText(currentCorrelationId)) {
    correlationId = UUID.randomUUID().toString();
    messageProperties.setCorrelationId(correlationId);
    Assert.isNull(messageProperties.getReplyTo(), "'replyTo' property must be null");
  }
  else {
    correlationId = currentCorrelationId;
  }
  messageProperties.setReplyTo(this.replyAddress);
  return correlationId;
}

if (reply != null) {
  Address replyTo;
  String replyToProperty = message.getMessageProperties().getReplyTo();
  if (replyToProperty != null) {
    replyTo = new Address(replyToProperty);
        MessageProperties messageProperties = message1.getMessageProperties();
        String contentEncoding = messageProperties.getContentEncoding();
        long contentLength = messageProperties.getContentLength();
        String contentType = messageProperties.getContentType();
        AmqpInboundGateway.this.headerMapper.fromHeadersToReply(reply.getHeaders(),
            messageProperties);
        messageProperties.setReplyTo(null);
          messageProperties.setContentEncoding(contentEncoding);
        messageProperties.setContentLength(contentLength);
        if (contentType != null) {
          messageProperties.setContentType(contentType);

@Test
public void buildMessageWithStandardMessage() throws Exception {
  Message<String> result = MessageBuilder.withPayload("Response")
      .setHeader("foo", "bar")
      .setHeader(AmqpHeaders.TYPE, "msg_type")
      .setHeader(AmqpHeaders.REPLY_TO, "reply")
      .build();
  Channel session = mock(Channel.class);
  MessagingMessageListenerAdapter listener = getSimpleInstance("echo", Message.class);
  org.springframework.amqp.core.Message replyMessage = listener.buildMessage(session, result, null);
  assertNotNull("reply should never be null", replyMessage);
  assertEquals("Response", new String(replyMessage.getBody()));
  assertEquals("type header not copied", "msg_type", replyMessage.getMessageProperties().getType());
  assertEquals("replyTo header not copied", "reply", replyMessage.getMessageProperties().getReplyTo());
  assertEquals("custom header not copied", "bar", replyMessage.getMessageProperties().getHeaders().get("foo"));
}

How to useMessageProperties in org.springframework.amqp.core

Best Java code snippets using org.springframework.amqp.core.MessageProperties (Showing top 20 results out of 540)

Refine search

How to use
MessageProperties
in
org.springframework.amqp.core