org.springframework.messaging.MessageHeaders.get()

@Test
public void resolveArgumentMessageHeaders() throws Exception {
    Object resolved = this.resolver.resolveArgument(this.resolvable.arg(MessageHeaders.clreplaced), this.message);
    replacedertTrue(resolved instanceof MessageHeaders);
    MessageHeaders headers = (MessageHeaders) resolved;
    replacedertEquals("bar", headers.get("foo"));
}

@Test
public void resolveArgumentMessageHeaders() {
    MessageHeaders headers = resolveArgument(this.resolvable.arg(MessageHeaders.clreplaced));
    replacedertEquals("bar", headers.get("foo"));
}

@Test
public void resolveArgumentMessageHeaders() throws Exception {
    Object resolved = this.resolver.resolveArgument(this.paramMessageHeaders, this.message);
    replacedertTrue(resolved instanceof MessageHeaders);
    MessageHeaders headers = (MessageHeaders) resolved;
    replacedertEquals("bar", headers.get("foo"));
}

public static String getCorrelationId(Message<?> message) {
    MessageHeaders headers = message.getHeaders();
    String serviceFullName = headers.get(SERVICE_FULL_NAME, String.clreplaced);
    String messageEventName = headers.get(MESSAGE_EVENT_NAME, String.clreplaced);
    String messageCorrelationKey = headers.get(MESSAGE_EVENT_CORRELATION_KEY, String.clreplaced);
    StringBuilder builder = new StringBuilder();
    builder.append(serviceFullName).append(":").append(messageEventName);
    if (messageCorrelationKey != null) {
        builder.append(":").append(messageCorrelationKey);
    }
    return builder.toString();
}

@Override
@Nullable
public MimeType resolve(@Nullable MessageHeaders headers) {
    if (headers == null || headers.get(MessageHeaders.CONTENT_TYPE) == null) {
        return this.defaultMimeType;
    }
    Object value = headers.get(MessageHeaders.CONTENT_TYPE);
    if (value == null) {
        return null;
    } else if (value instanceof MimeType) {
        return (MimeType) value;
    } else if (value instanceof String) {
        return MimeType.valueOf((String) value);
    } else {
        throw new IllegalArgumentException("Unknown type for contentType header value: " + value.getClreplaced());
    }
}

private static Message<?> buildBinaryMessageFromStructuredMap(Map<String, Object> structuredCloudEvent, MessageHeaders originalHeaders) {
    Object payload = structuredCloudEvent.remove(DATA);
    if (payload == null) {
        payload = Collections.emptyMap();
    }
    CloudEventMessageBuilder<?> messageBuilder = CloudEventMessageBuilder.withData(payload).copyHeaders(structuredCloudEvent);
    for (String key : originalHeaders.keySet()) {
        if (!MessageHeaders.ID.equals(key)) {
            messageBuilder.setHeader(key, originalHeaders.get(key));
        }
    }
    return messageBuilder.build();
}

@Test
public void resolveArgumentMessageHeaders() throws Exception {
    Object resolved = this.resolver.resolveArgument(this.resolvable.arg(MessageHeaders.clreplaced), this.message);
    boolean condition = resolved instanceof MessageHeaders;
    replacedertThat(condition).isTrue();
    MessageHeaders headers = (MessageHeaders) resolved;
    replacedertThat(headers.get("foo")).isEqualTo("bar");
}

@Test
public void resolveArgumentMessageHeaders() {
    MessageHeaders headers = resolveArgument(this.resolvable.arg(MessageHeaders.clreplaced));
    replacedertThat(headers.get("foo")).isEqualTo("bar");
}

/**
 * rocketmq 消息发送成功之后，提交本地事务
 *
 * @param message 消息
 * @param o       　args
 * @return RocketMQLocalTransactionState
 */
@Override
public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
    MessageHeaders headers = message.getHeaders();
    String transactionId = String.valueOf(headers.get(RocketMQHeaders.TRANSACTION_ID));
    Long shareId = Long.valueOf(String.valueOf(headers.get("share_id")));
    Order order = null;
    try {
        order = JSONObject.parseObject(new String((byte[]) message.getPayload()), Order.clreplaced);
    } catch (Exception e) {
        e.printStackTrace();
    }
    Long args = (Long) o;
    log.info(String.format("half message\npayload:%s, arg:%s, transactionId:%s", order, args, message.getHeaders().get(RocketMQHeaders.TRANSACTION_ID)));
    return RocketMQLocalTransactionState.COMMIT;
}

@Override
public MimeType resolve(MessageHeaders headers) {
    if (headers == null || headers.get(MessageHeaders.CONTENT_TYPE) == null) {
        return this.defaultMimeType;
    }
    Object value = headers.get(MessageHeaders.CONTENT_TYPE);
    if (value instanceof MimeType) {
        return (MimeType) value;
    } else if (value instanceof String) {
        return MimeType.valueOf((String) value);
    } else {
        throw new IllegalArgumentException("Unknown type for contentType header value: " + value.getClreplaced());
    }
}

@Test
public void leaveMutableDefaultBehavior() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setHeader("foo", "bar");
    MessageHeaders headers = accessor.getMessageHeaders();
    Message<?> message = MessageBuilder.createMessage("payload", headers);
    replacedertThatIllegalStateException().isThrownBy(() -> accessor.setLeaveMutable(true)).withMessageContaining("Already immutable");
    replacedertThatIllegalStateException().isThrownBy(() -> accessor.setHeader("foo", "baz")).withMessageContaining("Already immutable");
    replacedertEquals("bar", headers.get("foo"));
    replacedertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.clreplaced));
}

@Test
public void leaveMutable() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setHeader("foo", "bar");
    accessor.setLeaveMutable(true);
    MessageHeaders headers = accessor.getMessageHeaders();
    Message<?> message = MessageBuilder.createMessage("payload", headers);
    accessor.setHeader("foo", "baz");
    replacedertEquals("baz", headers.get("foo"));
    replacedertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.clreplaced));
}

@Test
public void testBuildMessageWithMutableHeaders() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setLeaveMutable(true);
    MessageHeaders headers = accessor.getMessageHeaders();
    Message<?> message = MessageBuilder.createMessage("payload", headers);
    accessor.setHeader("foo", "bar");
    replacedertEquals("bar", headers.get("foo"));
    replacedertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.clreplaced));
}

@Test
public void leaveMutableDefaultBehavior() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setHeader("foo", "bar");
    MessageHeaders headers = accessor.getMessageHeaders();
    Message<?> message = MessageBuilder.createMessage("payload", headers);
    replacedertThatIllegalStateException().isThrownBy(() -> accessor.setLeaveMutable(true)).withMessageContaining("Already immutable");
    replacedertThatIllegalStateException().isThrownBy(() -> accessor.setHeader("foo", "baz")).withMessageContaining("Already immutable");
    replacedertThat(headers.get("foo")).isEqualTo("bar");
    replacedertThat(MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.clreplaced)).isSameAs(accessor);
}

@Test
public void leaveMutable() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setHeader("foo", "bar");
    accessor.setLeaveMutable(true);
    MessageHeaders headers = accessor.getMessageHeaders();
    Message<?> message = MessageBuilder.createMessage("payload", headers);
    accessor.setHeader("foo", "baz");
    replacedertThat(headers.get("foo")).isEqualTo("baz");
    replacedertThat(MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.clreplaced)).isSameAs(accessor);
}

@Test
public void testBuildMessageWithMutableHeaders() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setLeaveMutable(true);
    MessageHeaders headers = accessor.getMessageHeaders();
    Message<?> message = MessageBuilder.createMessage("payload", headers);
    accessor.setHeader("foo", "bar");
    replacedertThat(headers.get("foo")).isEqualTo("bar");
    replacedertThat(MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.clreplaced)).isSameAs(accessor);
}

/**
 * Convert spring message to rocketMQ message
 *
 * @param destination formats: `topicName:tags`
 * @param message     {@link org.springframework.messaging.Message}
 * @return instance of {@link org.apache.rocketmq.common.message.Message}
 */
private org.apache.rocketmq.common.message.Message convertToRocketMsg(String destination, Message<?> message) {
    Object payloadObj = message.getPayload();
    byte[] payloads;
    if (payloadObj instanceof String) {
        payloads = ((String) payloadObj).getBytes(Charset.forName(charset));
    } else {
        try {
            String jsonObj = this.objectMapper.writeValuereplacedtring(payloadObj);
            payloads = jsonObj.getBytes(Charset.forName(charset));
        } catch (Exception e) {
            throw new RuntimeException("convert to RocketMQ message failed.", e);
        }
    }
    String[] tempArr = destination.split(":", 2);
    String topic = tempArr[0];
    String tags = "";
    if (tempArr.length > 1) {
        tags = tempArr[1];
    }
    org.apache.rocketmq.common.message.Message rocketMsg = new org.apache.rocketmq.common.message.Message(topic, tags, payloads);
    MessageHeaders headers = message.getHeaders();
    if (Objects.nonNull(headers) && !headers.isEmpty()) {
        Object keys = headers.get(MessageConst.PROPERTY_KEYS);
        if (!StringUtils.isEmpty(keys)) {
            // if headers has 'KEYS', set rocketMQ message key
            rocketMsg.setKeys(keys.toString());
        }
        // set rocketMQ message flag
        Object flagObj = headers.getOrDefault("FLAG", "0");
        int flag = 0;
        try {
            flag = Integer.parseInt(flagObj.toString());
        } catch (NumberFormatException e) {
            // ignore
            log.info("flag must be integer, flagObj:{}", flagObj);
        }
        rocketMsg.setFlag(flag);
        // set rocketMQ message waitStoreMsgOkObj
        Object waitStoreMsgOkObj = headers.getOrDefault("WAIT_STORE_MSG_OK", "true");
        boolean waitStoreMsgOK = Boolean.TRUE.equals(waitStoreMsgOkObj);
        rocketMsg.setWaitStoreMsgOK(waitStoreMsgOK);
        headers.entrySet().stream().filter(entry -> !Objects.equals(entry.getKey(), MessageConst.PROPERTY_KEYS) && !Objects.equals(entry.getKey(), "FLAG") && // exclude "KEYS", "FLAG", "WAIT_STORE_MSG_OK"
        !Objects.equals(entry.getKey(), "WAIT_STORE_MSG_OK")).forEach(entry -> {
            // add other properties with prefix "USERS_"
            rocketMsg.putUserProperty("USERS_" + entry.getKey(), String.valueOf(entry.getValue()));
        });
    }
    return rocketMsg;
}

@Test
public void leaveMutableDefaultBehavior() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setHeader("foo", "bar");
    MessageHeaders headers = accessor.getMessageHeaders();
    Message<?> message = MessageBuilder.createMessage("payload", headers);
    this.thrown.expect(IllegalStateException.clreplaced);
    this.thrown.expectMessage("Already immutable");
    accessor.setLeaveMutable(true);
    this.thrown.expect(IllegalStateException.clreplaced);
    this.thrown.expectMessage("Already immutable");
    accessor.setHeader("foo", "baz");
    replacedertEquals("bar", headers.get("foo"));
    replacedertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.clreplaced));
}

private String version(MessageHeaders message) {
    if (message.containsKey(CloudEventsHeaders.SPEC_VERSION)) {
        return message.get(CloudEventsHeaders.SPEC_VERSION).toString();
    }
    return null;
}

@Test
public void copyHeadersIfAbsent() {
    Map<String, Object> map1 = new HashMap<>();
    map1.put("foo", "bar");
    GenericMessage<String> message = new GenericMessage<>("payload", map1);
    MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
    Map<String, Object> map2 = new HashMap<>();
    map2.put("foo", "BAR");
    map2.put("bar", "baz");
    accessor.copyHeadersIfAbsent(map2);
    MessageHeaders actual = accessor.getMessageHeaders();
    replacedertEquals(3, actual.size());
    replacedertEquals("bar", actual.get("foo"));
    replacedertEquals("baz", actual.get("bar"));
}

@Test
public void existingHeaders() throws InterruptedException {
    Map<String, Object> map = new HashMap<>();
    map.put("foo", "bar");
    map.put("bar", "baz");
    GenericMessage<String> message = new GenericMessage<>("payload", map);
    MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
    MessageHeaders actual = accessor.getMessageHeaders();
    replacedertEquals(3, actual.size());
    replacedertEquals("bar", actual.get("foo"));
    replacedertEquals("baz", actual.get("bar"));
}

@Test
public void copyHeaders() {
    Map<String, Object> map1 = new HashMap<>();
    map1.put("foo", "bar");
    GenericMessage<String> message = new GenericMessage<>("payload", map1);
    MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
    Map<String, Object> map2 = new HashMap<>();
    map2.put("foo", "BAR");
    map2.put("bar", "baz");
    accessor.copyHeaders(map2);
    MessageHeaders actual = accessor.getMessageHeaders();
    replacedertEquals(3, actual.size());
    replacedertEquals("BAR", actual.get("foo"));
    replacedertEquals("baz", actual.get("bar"));
}

@Test
public void removeHeaders() {
    Map<String, Object> map = new HashMap<>();
    map.put("foo", "bar");
    map.put("bar", "baz");
    GenericMessage<String> message = new GenericMessage<>("payload", map);
    MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
    accessor.removeHeaders("fo*");
    MessageHeaders actual = accessor.getMessageHeaders();
    replacedertEquals(2, actual.size());
    replacedertNull(actual.get("foo"));
    replacedertEquals("baz", actual.get("bar"));
}

public static HttpHeaders fromMessage(MessageHeaders headers) {
    HttpHeaders result = new HttpHeaders();
    for (String name : headers.keySet()) {
        Object value = headers.get(name);
        name = name.toLowerCase();
        if (!IGNORED.containsKey(name)) {
            Collection<?> values = multi(value);
            for (Object object : values) {
                result.set(name, object.toString());
            }
        }
    }
    return result;
}

@Test
public void copyHeaders() {
    Map<String, Object> map1 = new HashMap<>();
    map1.put("foo", "bar");
    GenericMessage<String> message = new GenericMessage<>("payload", map1);
    MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
    Map<String, Object> map2 = new HashMap<>();
    map2.put("foo", "BAR");
    map2.put("bar", "baz");
    accessor.copyHeaders(map2);
    MessageHeaders actual = accessor.getMessageHeaders();
    replacedertThat(actual.size()).isEqualTo(3);
    replacedertThat(actual.get("foo")).isEqualTo("BAR");
    replacedertThat(actual.get("bar")).isEqualTo("baz");
}

@Test
public void removeHeaders() {
    Map<String, Object> map = new HashMap<>();
    map.put("foo", "bar");
    map.put("bar", "baz");
    GenericMessage<String> message = new GenericMessage<>("payload", map);
    MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
    accessor.removeHeaders("fo*");
    MessageHeaders actual = accessor.getMessageHeaders();
    replacedertThat(actual.size()).isEqualTo(2);
    replacedertThat(actual.get("foo")).isNull();
    replacedertThat(actual.get("bar")).isEqualTo("baz");
}

@Test
public void existingHeaders() throws InterruptedException {
    Map<String, Object> map = new HashMap<>();
    map.put("foo", "bar");
    map.put("bar", "baz");
    GenericMessage<String> message = new GenericMessage<>("payload", map);
    MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
    MessageHeaders actual = accessor.getMessageHeaders();
    replacedertThat(actual.size()).isEqualTo(3);
    replacedertThat(actual.get("foo")).isEqualTo("bar");
    replacedertThat(actual.get("bar")).isEqualTo("baz");
}

@Test
public void copyHeadersIfAbsent() {
    Map<String, Object> map1 = new HashMap<>();
    map1.put("foo", "bar");
    GenericMessage<String> message = new GenericMessage<>("payload", map1);
    MessageHeaderAccessor accessor = new MessageHeaderAccessor(message);
    Map<String, Object> map2 = new HashMap<>();
    map2.put("foo", "BAR");
    map2.put("bar", "baz");
    accessor.copyHeadersIfAbsent(map2);
    MessageHeaders actual = accessor.getMessageHeaders();
    replacedertThat(actual.size()).isEqualTo(3);
    replacedertThat(actual.get("foo")).isEqualTo("bar");
    replacedertThat(actual.get("bar")).isEqualTo("baz");
}

@Test
public void convertAndSendPayloadAndMutableHeadersToDestination() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setHeader("foo", "bar");
    accessor.setLeaveMutable(true);
    MessageHeaders messageHeaders = accessor.getMessageHeaders();
    this.template.setMessageConverter(new StringMessageConverter());
    this.template.convertAndSend("somewhere", "payload", messageHeaders);
    MessageHeaders actual = this.template.message.getHeaders();
    replacedertThat(actual).isSameAs(messageHeaders);
    replacedertThat(actual.get(MessageHeaders.CONTENT_TYPE)).isEqualTo(new MimeType("text", "plain", StandardCharsets.UTF_8));
    replacedertThat(actual.get("foo")).isEqualTo("bar");
}

private String contentType(MessageHeaders message) {
    if (message.containsKey(MessageHeaders.CONTENT_TYPE)) {
        return message.get(MessageHeaders.CONTENT_TYPE).toString();
    }
    if (message.containsKey(CloudEventsHeaders.CONTENT_TYPE)) {
        return message.get(CloudEventsHeaders.CONTENT_TYPE).toString();
    }
    return null;
}

private static Message getAndWrapMessage(String destination, MessageHeaders headers, byte[] payloads) {
    if (destination == null || destination.length() < 1) {
        return null;
    }
    if (payloads == null || payloads.length < 1) {
        return null;
    }
    String[] tempArr = destination.split(":", 2);
    String topic = tempArr[0];
    String tags = "";
    if (tempArr.length > 1) {
        tags = tempArr[1];
    }
    Message rocketMsg = new Message(topic, tags, payloads);
    if (Objects.nonNull(headers) && !headers.isEmpty()) {
        Object keys = headers.get(RocketMQHeaders.KEYS);
        // if headers not have 'KEYS', try add prefix when getting keys
        if (StringUtils.isEmpty(keys)) {
            keys = headers.get(toRocketHeaderKey(RocketMQHeaders.KEYS));
        }
        if (!StringUtils.isEmpty(keys)) {
            // if headers has 'KEYS', set rocketMQ message key
            rocketMsg.setKeys(keys.toString());
        }
        Object flagObj = headers.getOrDefault("FLAG", "0");
        int flag = 0;
        try {
            flag = Integer.parseInt(flagObj.toString());
        } catch (NumberFormatException e) {
            // Ignore it
            if (log.isInfoEnabled()) {
                log.info("flag must be integer, flagObj:{}", flagObj);
            }
        }
        rocketMsg.setFlag(flag);
        Object waitStoreMsgOkObj = headers.getOrDefault("WAIT_STORE_MSG_OK", "true");
        rocketMsg.setWaitStoreMsgOK(Boolean.TRUE.equals(waitStoreMsgOkObj));
        headers.entrySet().stream().filter(entry -> !Objects.equals(entry.getKey(), "FLAG") && // exclude "FLAG", "WAIT_STORE_MSG_OK"
        !Objects.equals(entry.getKey(), "WAIT_STORE_MSG_OK")).forEach(entry -> {
            if (!MessageConst.STRING_HASH_SET.contains(entry.getKey())) {
                rocketMsg.putUserProperty(entry.getKey(), String.valueOf(entry.getValue()));
            }
        });
    }
    return rocketMsg;
}

@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();
    replacedertEquals(3, actual.size());
    replacedertNotEquals(message.getHeaders().getId(), actual.getId());
    replacedertEquals("BAR", actual.get("foo"));
    replacedertEquals("baz", actual.get("bar"));
}

@Test
public void writeInactivity() throws Exception {
    this.messageHandler.setHeartbeatValue(new long[] { 1, 0 });
    this.messageHandler.setTaskScheduler(this.taskScheduler);
    this.messageHandler.start();
    ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClreplaced(Runnable.clreplaced);
    verify(this.taskScheduler).scheduleWithFixedDelay(taskCaptor.capture(), eq(1L));
    Runnable heartbeatTask = taskCaptor.getValue();
    replacedertNotNull(heartbeatTask);
    String id = "sess1";
    TestPrincipal user = new TestPrincipal("joe");
    Message<String> connectMessage = createConnectMessage(id, user, new long[] { 0, 1 });
    this.messageHandler.handleMessage(connectMessage);
    Thread.sleep(10);
    heartbeatTask.run();
    verify(this.clientOutChannel, times(2)).send(this.messageCaptor.capture());
    List<Message<?>> messages = this.messageCaptor.getAllValues();
    replacedertEquals(2, messages.size());
    MessageHeaders headers = messages.get(0).getHeaders();
    replacedertEquals(SimpMessageType.CONNECT_ACK, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
    headers = messages.get(1).getHeaders();
    replacedertEquals(SimpMessageType.HEARTBEAT, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
    replacedertEquals(id, headers.get(SimpMessageHeaderAccessor.SESSION_ID_HEADER));
    replacedertEquals(user, headers.get(SimpMessageHeaderAccessor.USER_HEADER));
}

@SuppressWarnings("unchecked")
@Override
@Nullable
protected MimeType getMimeType(@Nullable MessageHeaders headers) {
    Object contentType = headers.get(MessageHeaders.CONTENT_TYPE);
    if (contentType instanceof byte[]) {
        contentType = new String((byte[]) contentType, StandardCharsets.UTF_8);
        contentType = ((String) contentType).replace("\"", "");
        Map<String, Object> headersMap = (Map<String, Object>) ReflectionUtils.getField(this.headersField, headers);
        headersMap.put(MessageHeaders.CONTENT_TYPE, contentType);
    }
    return super.getMimeType(headers);
}

@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();
    replacedertThat(actual.size()).isEqualTo(3);
    replacedertThat(actual.getId()).isNotEqualTo(message.getHeaders().getId());
    replacedertThat(actual.get("foo")).isEqualTo("BAR");
    replacedertThat(actual.get("bar")).isEqualTo("baz");
}

/**
 * Get user object from ws message header
 * @param headers
 * @return User object
 * @exception AuthenticationException if Token header is missing or invalid token
 */
public User validate(MessageHeaders headers) {
    MultiValueMap<String, String> map = headers.get(StompHeaderAccessor.NATIVE_HEADERS, MultiValueMap.clreplaced);
    if (Objects.isNull(map)) {
        throw new AuthenticationException("Invalid token");
    }
    String token = map.getFirst(HeaderToken);
    if (!StringHelper.hasValue(token)) {
        throw new AuthenticationException("Invalid token");
    }
    Optional<User> user = authService.get(token);
    if (!user.isPresent()) {
        throw new AuthenticationException("Invalid token");
    }
    return user.get();
}

@Test
public void readInactivity() throws Exception {
    this.messageHandler.setHeartbeatValue(new long[] { 0, 1 });
    this.messageHandler.setTaskScheduler(this.taskScheduler);
    this.messageHandler.start();
    ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClreplaced(Runnable.clreplaced);
    verify(this.taskScheduler).scheduleWithFixedDelay(taskCaptor.capture(), eq(1L));
    Runnable heartbeatTask = taskCaptor.getValue();
    replacedertNotNull(heartbeatTask);
    String id = "sess1";
    TestPrincipal user = new TestPrincipal("joe");
    Message<String> connectMessage = createConnectMessage(id, user, new long[] { 1, 0 });
    this.messageHandler.handleMessage(connectMessage);
    Thread.sleep(10);
    heartbeatTask.run();
    verify(this.clientOutChannel, atLeast(2)).send(this.messageCaptor.capture());
    List<Message<?>> messages = this.messageCaptor.getAllValues();
    replacedertEquals(2, messages.size());
    MessageHeaders headers = messages.get(0).getHeaders();
    replacedertEquals(SimpMessageType.CONNECT_ACK, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
    headers = messages.get(1).getHeaders();
    replacedertEquals(SimpMessageType.DISCONNECT_ACK, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
    replacedertEquals(id, headers.get(SimpMessageHeaderAccessor.SESSION_ID_HEADER));
    replacedertEquals(user, headers.get(SimpMessageHeaderAccessor.USER_HEADER));
}

@Override
public javax.jms.Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
    if (!(object instanceof Message)) {
        throw new IllegalArgumentException("Could not convert [" + object + "] - only [" + Message.clreplaced.getName() + "] is handled by this converter");
    }
    Message<?> input = (Message<?>) object;
    MessageHeaders headers = input.getHeaders();
    Object conversionHint = headers.get(AbstractMessagingTemplate.CONVERSION_HINT_HEADER);
    javax.jms.Message reply = createMessageForPayload(input.getPayload(), session, conversionHint);
    this.headerMapper.fromHeaders(headers, reply);
    return reply;
}

@Test
public void convertAndSendPayloadAndMutableHeadersToDestination() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setHeader("foo", "bar");
    accessor.setLeaveMutable(true);
    MessageHeaders messageHeaders = accessor.getMessageHeaders();
    this.template.setMessageConverter(new StringMessageConverter());
    this.template.convertAndSend("somewhere", "payload", messageHeaders);
    MessageHeaders actual = this.template.message.getHeaders();
    replacedertSame(messageHeaders, actual);
    replacedertEquals(new MimeType("text", "plain", StandardCharsets.UTF_8), actual.get(MessageHeaders.CONTENT_TYPE));
    replacedertEquals("bar", actual.get("foo"));
}

@Test
public void convertAndSendPayloadAndMutableHeadersToDestination() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setHeader("foo", "bar");
    accessor.setLeaveMutable(true);
    MessageHeaders messageHeaders = accessor.getMessageHeaders();
    this.template.setMessageConverter(new StringMessageConverter());
    this.template.convertAndSend("somewhere", "payload", messageHeaders);
    MessageHeaders actual = this.template.message.getHeaders();
    replacedertSame(messageHeaders, actual);
    replacedertEquals(new MimeType("text", "plain", Charset.forName("UTF-8")), actual.get(MessageHeaders.CONTENT_TYPE));
    replacedertEquals("bar", actual.get("foo"));
}

@SuppressWarnings("unchecked")
private void verifyOriginalMessage() {
    ArgumentCaptor<Message<?>> argument = ArgumentCaptor.forClreplaced(Message.clreplaced);
    verify(this.mockMessageChannel).send(argument.capture());
    MessageHeaders headers = argument.getValue().getHeaders();
    replacedertThat(headers).containsKey(GcpPubSubHeaders.ORIGINAL_MESSAGE);
    replacedertThat(headers.get(GcpPubSubHeaders.ORIGINAL_MESSAGE)).isNotNull();
    replacedertThat(headers.get(GcpPubSubHeaders.ORIGINAL_MESSAGE)).isEqualTo(mockAcknowledgeableMessage);
}

@SuppressWarnings("unchecked")
private void verifyOriginalMessage() {
    ArgumentCaptor<Message<?>> argument = ArgumentCaptor.forClreplaced(Message.clreplaced);
    verify(this.mockMessageChannel).send(argument.capture());
    MessageHeaders headers = argument.getValue().getHeaders();
    replacedertThat(headers).containsKey(GcpPubSubHeaders.ORIGINAL_MESSAGE);
    replacedertThat(headers.get(GcpPubSubHeaders.ORIGINAL_MESSAGE)).isEqualTo(mockAcknowledgeableMessage);
}

@Override
@Nullable
public Message<?> toMessage(Object payload, @Nullable MessageHeaders headers) {
    for (MessageConverter converter : getConverters()) {
        Object value = headers.get(MessageHeaders.CONTENT_TYPE).toString();
        String[] contentTypes = StringUtils.delimitedListToStringArray((String) value, ",");
        for (String contentType : contentTypes) {
            if (!MimeType.valueOf(contentType).isConcrete()) {
                List<MimeType> supportedMimeTypes = ((AbstractMessageConverter) converter).getSupportedMimeTypes();
                for (MimeType supportedMimeType : supportedMimeTypes) {
                    MessageHeaderAccessor h = new MessageHeaderAccessor();
                    h.copyHeaders(headers);
                    h.setHeader(MessageHeaders.CONTENT_TYPE, supportedMimeType);
                    Message<?> result = converter.toMessage(payload, h.getMessageHeaders());
                    if (result != null) {
                        return result;
                    }
                }
            } else {
                MessageHeaderAccessor h = new MessageHeaderAccessor();
                h.copyHeaders(headers);
                h.setHeader(MessageHeaders.CONTENT_TYPE, contentType);
                Message<?> result = converter.toMessage(payload, h.getMessageHeaders());
                if (result != null) {
                    return result;
                }
            }
        }
    }
    return null;
}

@Override
@Nullable
public Message<?> toMessage(Object payload, @Nullable MessageHeaders headers, @Nullable Object conversionHint) {
    for (MessageConverter converter : getConverters()) {
        Object value = headers.get(MessageHeaders.CONTENT_TYPE).toString();
        String[] contentTypes = StringUtils.delimitedListToStringArray((String) value, ",");
        for (String contentType : contentTypes) {
            if (!MimeType.valueOf(contentType).isConcrete()) {
                List<MimeType> supportedMimeTypes = ((AbstractMessageConverter) converter).getSupportedMimeTypes();
                for (MimeType supportedMimeType : supportedMimeTypes) {
                    MessageHeaderAccessor h = new MessageHeaderAccessor();
                    h.copyHeaders(headers);
                    h.setHeader(MessageHeaders.CONTENT_TYPE, supportedMimeType);
                    Message<?> result = ((SmartMessageConverter) converter).toMessage(payload, h.getMessageHeaders(), conversionHint);
                    if (result != null) {
                        return result;
                    }
                }
            } else {
                MessageHeaderAccessor h = new MessageHeaderAccessor();
                h.copyHeaders(headers);
                h.setHeader(MessageHeaders.CONTENT_TYPE, contentType);
                Message<?> result = ((SmartMessageConverter) converter).toMessage(payload, h.getMessageHeaders(), conversionHint);
                if (result != null) {
                    return result;
                }
            }
        }
    }
    return null;
}

private OutputSignal fromSpringMessage(Tuple2<Integer, Message<byte[]>> out) {
    int resultIndex = out.getT1();
    MessageHeaders headers = out.getT2().getHeaders();
    MimeType contentType = headers.get(MessageHeaders.CONTENT_TYPE, MimeType.clreplaced);
    OutputFrame.Builder builderForOutputFrame = OutputFrame.newBuilder().setContentType(contentType.toString()).setResultIndex(resultIndex).setPayload(ByteString.copyFrom(out.getT2().getPayload()));
    headers.entrySet().stream().filter(e -> !e.getKey().equals(MessageHeaders.CONTENT_TYPE) && e.getValue() instanceof String).forEach(e -> builderForOutputFrame.putHeaders(e.getKey(), (String) e.getValue()));
    return OutputSignal.newBuilder().setData(builderForOutputFrame).build();
}

@Override
public void fromHeaders(MessageHeaders headers, javax.jms.Message jmsMessage) {
    try {
        Object jmsCorrelationId = headers.get(JmsHeaders.CORRELATION_ID);
        if (jmsCorrelationId instanceof Number) {
            jmsCorrelationId = jmsCorrelationId.toString();
        }
        if (jmsCorrelationId instanceof String) {
            try {
                jmsMessage.setJMSCorrelationID((String) jmsCorrelationId);
            } catch (Exception ex) {
                logger.debug("Failed to set JMSCorrelationID - skipping", ex);
            }
        }
        Destination jmsReplyTo = getHeaderIfAvailable(headers, JmsHeaders.REPLY_TO, Destination.clreplaced);
        if (jmsReplyTo != null) {
            try {
                jmsMessage.setJMSReplyTo(jmsReplyTo);
            } catch (Exception ex) {
                logger.debug("Failed to set JMSReplyTo - skipping", ex);
            }
        }
        String jmsType = getHeaderIfAvailable(headers, JmsHeaders.TYPE, String.clreplaced);
        if (jmsType != null) {
            try {
                jmsMessage.setJMSType(jmsType);
            } catch (Exception ex) {
                logger.debug("Failed to set JMSType - skipping", ex);
            }
        }
        Set<String> headerNames = headers.keySet();
        for (String headerName : headerNames) {
            if (StringUtils.hasText(headerName) && !headerName.startsWith(JmsHeaders.PREFIX)) {
                Object value = headers.get(headerName);
                if (value != null && SUPPORTED_PROPERTY_TYPES.contains(value.getClreplaced())) {
                    try {
                        String propertyName = this.fromHeaderName(headerName);
                        jmsMessage.setObjectProperty(propertyName, value);
                    } catch (Exception ex) {
                        if (headerName.startsWith("JMSX")) {
                            if (logger.isTraceEnabled()) {
                                logger.trace("Skipping reserved header '" + headerName + "' since it cannot be set by client");
                            }
                        } else if (logger.isDebugEnabled()) {
                            logger.debug("Failed to map message header '" + headerName + "' to JMS property", ex);
                        }
                    }
                }
            }
        }
    } catch (Exception ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("Error occurred while mapping from MessageHeaders to JMS properties", ex);
        }
    }
}

@Override
public void fromHeaders(MessageHeaders headers, javax.jms.Message jmsMessage) {
    try {
        Object jmsCorrelationId = headers.get(JmsHeaders.CORRELATION_ID);
        if (jmsCorrelationId instanceof Number) {
            jmsCorrelationId = jmsCorrelationId.toString();
        }
        if (jmsCorrelationId instanceof String) {
            try {
                jmsMessage.setJMSCorrelationID((String) jmsCorrelationId);
            } catch (Exception e) {
                logger.info("failed to set JMSCorrelationID, skipping", e);
            }
        }
        Destination jmsReplyTo = getHeaderIfAvailable(headers, JmsHeaders.REPLY_TO, Destination.clreplaced);
        if (jmsReplyTo != null) {
            try {
                jmsMessage.setJMSReplyTo(jmsReplyTo);
            } catch (Exception e) {
                logger.info("failed to set JMSReplyTo, skipping", e);
            }
        }
        String jmsType = getHeaderIfAvailable(headers, JmsHeaders.TYPE, String.clreplaced);
        if (jmsType != null) {
            try {
                jmsMessage.setJMSType(jmsType);
            } catch (Exception e) {
                logger.info("failed to set JMSType, skipping", e);
            }
        }
        Set<String> headerNames = headers.keySet();
        for (String headerName : headerNames) {
            if (StringUtils.hasText(headerName) && !headerName.startsWith(JmsHeaders.PREFIX)) {
                Object value = headers.get(headerName);
                if (value != null && SUPPORTED_PROPERTY_TYPES.contains(value.getClreplaced())) {
                    try {
                        String propertyName = this.fromHeaderName(headerName);
                        jmsMessage.setObjectProperty(propertyName, value);
                    } catch (Exception e) {
                        if (headerName.startsWith("JMSX")) {
                            if (logger.isTraceEnabled()) {
                                logger.trace("skipping reserved header, it cannot be set by client: " + headerName);
                            }
                        } else if (logger.isWarnEnabled()) {
                            logger.warn("failed to map Message header '" + headerName + "' to JMS property", e);
                        }
                    }
                }
            }
        }
    } catch (Exception ex) {
        if (logger.isWarnEnabled()) {
            logger.warn("error occurred while mapping from MessageHeaders to JMS properties", ex);
        }
    }
}

@Override
public void fromHeaders(MessageHeaders headers, javax.jms.Message jmsMessage) {
    try {
        Object jmsCorrelationId = headers.get(JmsHeaders.CORRELATION_ID);
        if (jmsCorrelationId instanceof Number) {
            jmsCorrelationId = jmsCorrelationId.toString();
        }
        if (jmsCorrelationId instanceof String) {
            try {
                jmsMessage.setJMSCorrelationID((String) jmsCorrelationId);
            } catch (Exception ex) {
                logger.debug("Failed to set JMSCorrelationID - skipping", ex);
            }
        }
        Destination jmsReplyTo = getHeaderIfAvailable(headers, JmsHeaders.REPLY_TO, Destination.clreplaced);
        if (jmsReplyTo != null) {
            try {
                jmsMessage.setJMSReplyTo(jmsReplyTo);
            } catch (Exception ex) {
                logger.debug("Failed to set JMSReplyTo - skipping", ex);
            }
        }
        String jmsType = getHeaderIfAvailable(headers, JmsHeaders.TYPE, String.clreplaced);
        if (jmsType != null) {
            try {
                jmsMessage.setJMSType(jmsType);
            } catch (Exception ex) {
                logger.debug("Failed to set JMSType - skipping", ex);
            }
        }
        Set<Map.Entry<String, Object>> entries = headers.entrySet();
        for (Map.Entry<String, Object> entry : entries) {
            String headerName = entry.getKey();
            if (StringUtils.hasText(headerName) && !headerName.startsWith(JmsHeaders.PREFIX)) {
                Object value = entry.getValue();
                if (value != null && SUPPORTED_PROPERTY_TYPES.contains(value.getClreplaced())) {
                    try {
                        String propertyName = this.fromHeaderName(headerName);
                        jmsMessage.setObjectProperty(propertyName, value);
                    } catch (Exception ex) {
                        if (headerName.startsWith("JMSX")) {
                            if (logger.isTraceEnabled()) {
                                logger.trace("Skipping reserved header '" + headerName + "' since it cannot be set by client");
                            }
                        } else if (logger.isDebugEnabled()) {
                            logger.debug("Failed to map message header '" + headerName + "' to JMS property", ex);
                        }
                    }
                }
            }
        }
    } catch (Exception ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("Error occurred while mapping from MessageHeaders to JMS properties", ex);
        }
    }
}

@Test
public void writeInactivity() throws Exception {
    this.messageHandler.setHeartbeatValue(new long[] { 1, 0 });
    this.messageHandler.setTaskScheduler(this.taskScheduler);
    this.messageHandler.start();
    ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClreplaced(Runnable.clreplaced);
    verify(this.taskScheduler).scheduleWithFixedDelay(taskCaptor.capture(), eq(1L));
    Runnable heartbeatTask = taskCaptor.getValue();
    replacedertThat(heartbeatTask).isNotNull();
    String id = "sess1";
    TestPrincipal user = new TestPrincipal("joe");
    Message<String> connectMessage = createConnectMessage(id, user, new long[] { 0, 1 });
    this.messageHandler.handleMessage(connectMessage);
    Thread.sleep(10);
    heartbeatTask.run();
    verify(this.clientOutChannel, times(2)).send(this.messageCaptor.capture());
    List<Message<?>> messages = this.messageCaptor.getAllValues();
    replacedertThat(messages.size()).isEqualTo(2);
    MessageHeaders headers = messages.get(0).getHeaders();
    replacedertThat(headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)).isEqualTo(SimpMessageType.CONNECT_ACK);
    headers = messages.get(1).getHeaders();
    replacedertThat(headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)).isEqualTo(SimpMessageType.HEARTBEAT);
    replacedertThat(headers.get(SimpMessageHeaderAccessor.SESSION_ID_HEADER)).isEqualTo(id);
    replacedertThat(headers.get(SimpMessageHeaderAccessor.USER_HEADER)).isEqualTo(user);
}

@Test
public void writeInactivity() throws Exception {
    this.messageHandler.setHeartbeatValue(new long[] { 1, 0 });
    this.messageHandler.setTaskScheduler(this.taskScheduler);
    this.messageHandler.start();
    ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClreplaced(Runnable.clreplaced);
    verify(this.taskScheduler).scheduleWithFixedDelay(taskCaptor.capture(), eq(1L));
    Runnable heartbeatTask = taskCaptor.getValue();
    replacedertNotNull(heartbeatTask);
    String id = "sess1";
    TestPrincipal user = new TestPrincipal("joe");
    Message<String> connectMessage = createConnectMessage(id, user, new long[] { 0, 1 });
    this.messageHandler.handleMessage(connectMessage);
    Thread.sleep(10);
    heartbeatTask.run();
    verify(this.clientOutboundChannel, times(2)).send(this.messageCaptor.capture());
    List<Message<?>> messages = this.messageCaptor.getAllValues();
    replacedertEquals(2, messages.size());
    MessageHeaders headers = messages.get(0).getHeaders();
    replacedertEquals(SimpMessageType.CONNECT_ACK, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
    headers = messages.get(1).getHeaders();
    replacedertEquals(SimpMessageType.HEARTBEAT, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER));
    replacedertEquals(id, headers.get(SimpMessageHeaderAccessor.SESSION_ID_HEADER));
    replacedertEquals(user, headers.get(SimpMessageHeaderAccessor.USER_HEADER));
}

See More Examples