How to use

getHeaders

method

in

org.springframework.messaging.support.GenericMessage

@Test
public void existingHeadersModification() throws InterruptedException {
  Map<String, Object> map = new HashMap<>();
  map.put("foo", "bar");
  map.put("bar", "baz");
  GenericMessage<String> message = new GenericMessage<>("payload", map);
  Thread.sleep(50);
  MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
  accessor.setHeader("foo", "BAR");
  MessageHeaders actual = accessor.getMessageHeaders();
  assertEquals(3, actual.size());
  assertNotEquals(message.getHeaders().getId(), actual.getId());
  assertEquals("BAR", actual.get("foo"));
  assertEquals("baz", actual.get("bar"));
}

@Override
public GenericMessage<?> convert(Document source) {
  @SuppressWarnings("unchecked")
  Map<String, Object> headers =
      MongoDbMessageStore.this.converter.normalizeHeaders((Map<String, Object>) source.get("headers"));
  GenericMessage<?> message =
      new GenericMessage<>(MongoDbMessageStore.this.converter.extractPayload(source), headers);
  enhanceHeaders(message.getHeaders(), headers);
  return message;
}

@Test
public void testBytesEmbedAll() throws Exception {
  EmbeddedJsonHeadersMessageMapper mapper = new EmbeddedJsonHeadersMessageMapper();
  GenericMessage<byte[]> message = new GenericMessage<>("foo".getBytes());
  Thread.sleep(2);
  byte[] bytes = mapper.fromMessage(message);
  ByteBuffer bb = ByteBuffer.wrap(bytes);
  int headerLen = bb.getInt();
  byte[] headerBytes = new byte[headerLen];
  bb.get(headerBytes);
  String headers = new String(headerBytes);
  assertThat(headers).contains(message.getHeaders().getId().toString());
  assertThat(headers).contains(String.valueOf(message.getHeaders().getTimestamp()));
  assertThat(bb.getInt()).isEqualTo(3);
  assertThat(bb.remaining()).isEqualTo(3);
  assertThat((char) bb.get()).isEqualTo('f');
  assertThat((char) bb.get()).isEqualTo('o');
  assertThat((char) bb.get()).isEqualTo('o');
}

@Test
public void testBytesEmbedSome() throws Exception {
  EmbeddedJsonHeadersMessageMapper mapper = new EmbeddedJsonHeadersMessageMapper("I*");
  GenericMessage<byte[]> message = new GenericMessage<>("foo".getBytes(), Collections.singletonMap("bar", "baz"));
  byte[] bytes = mapper.fromMessage(message);
  ByteBuffer bb = ByteBuffer.wrap(bytes);
  int headerLen = bb.getInt();
  byte[] headerBytes = new byte[headerLen];
  bb.get(headerBytes);
  String headers = new String(headerBytes);
  assertThat(headers).contains(message.getHeaders().getId().toString());
  assertThat(headers).doesNotContain(MessageHeaders.TIMESTAMP);
  assertThat(headers).doesNotContain("bar");
  assertThat(bb.getInt()).isEqualTo(3);
  assertThat(bb.remaining()).isEqualTo(3);
  assertThat((char) bb.get()).isEqualTo('f');
  assertThat((char) bb.get()).isEqualTo('o');
  assertThat((char) bb.get()).isEqualTo('o');
}

@Test
public void testEmbedSome() throws Exception {
  EmbeddedJsonHeadersMessageMapper mapper = new EmbeddedJsonHeadersMessageMapper(MessageHeaders.ID);
  GenericMessage<String> message = new GenericMessage<>("foo");
  byte[] encodedMessage = mapper.fromMessage(message);
  Message<?> decoded = mapper.toMessage(encodedMessage);
  assertThat(decoded.getPayload()).isEqualTo(message.getPayload());
  assertThat(decoded.getHeaders().getTimestamp()).isNotEqualTo(message.getHeaders().getTimestamp());
  ObjectMapper objectMapper = new ObjectMapper();
  Map<String, Object> encodedMessageToCheck =
      objectMapper.readValue(encodedMessage, new TypeReference<Map<String, Object>>() {
      });
  Object headers = encodedMessageToCheck.get("headers");
  assertThat(headers).isNotNull();
  assertThat(headers).isInstanceOf(Map.class);
  @SuppressWarnings("unchecked")
  Map<String, Object> headersToCheck = (Map<String, Object>) headers;
  assertThat(headersToCheck).doesNotContainKey(MessageHeaders.TIMESTAMP);
}

@Test
public void testMessageHeadersCopiedFromMap() {
  Map<String, Object> headerMap = new HashMap<String, Object>();
  headerMap.put("testAttribute", Integer.valueOf(123));
  headerMap.put("testProperty", "foo");
  headerMap.put(IntegrationMessageHeaderAccessor.SEQUENCE_SIZE, 42);
  headerMap.put(IntegrationMessageHeaderAccessor.SEQUENCE_NUMBER, 24);
  GenericMessage<String> message = new GenericMessage<String>("test", headerMap);
  assertEquals(123, message.getHeaders().get("testAttribute"));
  assertEquals("foo", message.getHeaders().get("testProperty", String.class));
  assertEquals(42, new IntegrationMessageHeaderAccessor(message).getSequenceSize());
  assertEquals(24, new IntegrationMessageHeaderAccessor(message).getSequenceNumber());
}

@Test
public void testDontMapIdButOthers() throws Exception {
  EmbeddedJsonHeadersMessageMapper mapper = new EmbeddedJsonHeadersMessageMapper("!" + MessageHeaders.ID, "*");
  GenericMessage<String> message = new GenericMessage<>("foo",  Collections.singletonMap("bar", "baz"));
  byte[] encodedMessage = mapper.fromMessage(message);
  ObjectMapper objectMapper = new ObjectMapper();
  Map<String, Object> encodedMessageToCheck =
      objectMapper.readValue(encodedMessage, new TypeReference<Map<String, Object>>() {
      });
  Object headers = encodedMessageToCheck.get("headers");
  assertThat(headers).isNotNull();
  assertThat(headers).isInstanceOf(Map.class);
  @SuppressWarnings("unchecked")
  Map<String, Object> headersToCheck = (Map<String, Object>) headers;
  assertThat(headersToCheck).doesNotContainKey(MessageHeaders.ID);
  assertThat(headersToCheck).containsKey(MessageHeaders.TIMESTAMP);
  assertThat(headersToCheck).containsKey("bar");
  Message<?> decoded = mapper.toMessage(mapper.fromMessage(message));
  assertThat(decoded.getHeaders().getTimestamp()).isEqualTo(message.getHeaders().getTimestamp());
  assertThat(decoded.getHeaders().getId()).isNotEqualTo(message.getHeaders().getId());
  assertThat(decoded.getHeaders().get("bar")).isEqualTo("baz");
}

@Test
public void testProxyAndHeaderAnnotation() {
  final AtomicReference<Object> payloadReference = new AtomicReference<>();
  final AtomicReference<UUID> idReference = new AtomicReference<>();
  class MyHandler {
    public void handle(@Header(MessageHeaders.ID) UUID id, @Payload Object payload) {
      idReference.set(id);
      payloadReference.set(payload);
    }
  }
  MyHandler service = new MyHandler();
  final AtomicBoolean adviceCalled = new AtomicBoolean();
  ProxyFactory proxyFactory = new ProxyFactory(service);
  proxyFactory.addAdvice((MethodInterceptor) i -> {
    adviceCalled.set(true);
    return i.proceed();
  });
  service = (MyHandler) proxyFactory.getProxy(getClass().getClassLoader());
  GenericMessage<String> testMessage = new GenericMessage<>("foo");
  MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, "handle");
  processor.setBeanFactory(mock(BeanFactory.class));
  processor.processMessage(testMessage);
  assertEquals(testMessage.getPayload(), payloadReference.get());
  assertEquals(testMessage.getHeaders().getId(), idReference.get());
  assertTrue(adviceCalled.get());
}

@Test
public void testProcessMessageWithStaticKey() {
  Expression expression = expressionParser.parseExpression("headers[headers.ID]");
  ExpressionEvaluatingMessageProcessor<UUID> processor = new ExpressionEvaluatingMessageProcessor<>(expression);
  processor.setBeanFactory(mock(BeanFactory.class));
  GenericMessage<String> message = new GenericMessage<>("foo");
  assertEquals(message.getHeaders().getId(), processor.processMessage(message));
}

@Test
public void testMessageHeadersNotConverted() {
  BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter();
  typeConverter.setBeanFactory(new DefaultListableBeanFactory());
  MessageHeaders headers = new GenericMessage<>("foo").getHeaders();
  assertSame(headers, typeConverter.convertValue(headers, TypeDescriptor.valueOf(MessageHeaders.class),
      TypeDescriptor.valueOf(MessageHeaders.class)));
}

@Test
public void headerForObjectReturnValues() throws Exception {
  GenericMessage<String> message = new GenericMessage<>("foo.bar");
  MethodInvokingSplitter splitter = this.getSplitter("stringToStringArray");
  QueueChannel replyChannel = new QueueChannel();
  splitter.setOutputChannel(replyChannel);
  splitter.handleMessage(message);
  List<Message<?>> replies = replyChannel.clear();
  Message<?> reply1 = replies.get(0);
  assertNotNull(reply1);
  assertEquals(2, new IntegrationMessageHeaderAccessor(reply1).getSequenceSize());
  assertEquals(1, new IntegrationMessageHeaderAccessor(reply1).getSequenceNumber());
  assertEquals(message.getHeaders().getId(), new IntegrationMessageHeaderAccessor(reply1).getCorrelationId());
  Message<?> reply2 = replies.get(1);
  assertNotNull(reply2);
  assertEquals(2, new IntegrationMessageHeaderAccessor(reply2).getSequenceSize());
  assertEquals(2, new IntegrationMessageHeaderAccessor(reply2).getSequenceNumber());
  assertEquals(message.getHeaders().getId(), new IntegrationMessageHeaderAccessor(reply2).getCorrelationId());
}

@Test
public void headerForMessageReturnValues() throws Exception {
  GenericMessage<String> message = new GenericMessage<>("foo.bar");
  MethodInvokingSplitter splitter = this.getSplitter("messageToMessageList");
  QueueChannel replyChannel = new QueueChannel();
  splitter.setOutputChannel(replyChannel);
  splitter.handleMessage(message);
  List<Message<?>> replies = replyChannel.clear();
  Message<?> reply1 = replies.get(0);
  assertNotNull(reply1);
  assertEquals(2, new IntegrationMessageHeaderAccessor(reply1).getSequenceSize());
  assertEquals(1, new IntegrationMessageHeaderAccessor(reply1).getSequenceNumber());
  assertEquals(message.getHeaders().getId(), new IntegrationMessageHeaderAccessor(reply1).getCorrelationId());
  Message<?> reply2 = replies.get(1);
  assertNotNull(reply2);
  assertEquals(2, new IntegrationMessageHeaderAccessor(reply2).getSequenceSize());
  assertEquals(2, new IntegrationMessageHeaderAccessor(reply2).getSequenceNumber());
  assertEquals(message.getHeaders().getId(), new IntegrationMessageHeaderAccessor(reply2).getCorrelationId());
}

@Override
public GenericMessage<?> convert(Document source) {
  @SuppressWarnings("unchecked")
  Map<String, Object> headers =
      MongoDbMessageStore.this.converter.normalizeHeaders((Map<String, Object>) source.get("headers"));
  GenericMessage<?> message =
      new GenericMessage<>(MongoDbMessageStore.this.converter.extractPayload(source), headers);
  enhanceHeaders(message.getHeaders(), headers);
  return message;
}