org.springframework.messaging.Message.getHeaders()

/**
 * RocketMQ回查本地事务状态
 * @param message 消息
 * @return RocketMQ事务状态
 */
@Override
public RocketMQLocalTransactionState checkLocalTransaction(Message message) {
    MessageHeaders headers = message.getHeaders();
    String transicationId = (String) headers.get(RocketMQHeaders.TRANSACTION_ID);
    log.info("RocketMQ事务状态回查=>{}", transicationId);
    // 从数据库中根据事务Id查询对应的事务日志，对应图中第6步
    FwTransactionLog transactionLog = fwTransactionLogService.getOne(new LambdaQueryWrapper<FwTransactionLog>().eq(FwTransactionLog::getTransactionId, transicationId));
    // 对应图中的第7步骤
    return transactionLog != null ? RocketMQLocalTransactionState.COMMIT : RocketMQLocalTransactionState.ROLLBACK;
}

/**
 * 执行本地事务
 * @param message 消息
 * @param o 额外参数
 * @return RocketMQ事务状态
 */
@Override
public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
    MessageHeaders headers = message.getHeaders();
    String transicationId = (String) headers.get(RocketMQHeaders.TRANSACTION_ID);
    try {
        FwTradeLog tradeLog = (FwTradeLog) o;
        // 对应图中第3步，执行本地事务
        orderService.payOrder(tradeLog, transicationId);
        log.info("本地事务=>{} 执行成功，往RocketMQ发送COMMIT", transicationId);
        // 对应图中第4步，COMMIT，半消息经过COMMIT后，消息消费端就可以消费这条消息了
        return RocketMQLocalTransactionState.COMMIT;
    } catch (Exception e) {
        log.info("本地事务=>{} 回滚，往RocketMQ发送ROLLBACK", transicationId, e);
        // 对应途中第4步，ROLLBACK
        return RocketMQLocalTransactionState.ROLLBACK;
    }
}

// SPR-14690
@Test
public void handleMessageFromClientWithTokenAuthentication() {
    ExecutorSubscribableChannel channel = new ExecutorSubscribableChannel();
    channel.addInterceptor(new AuthenticationInterceptor("[email protected]"));
    channel.addInterceptor(new ImmutableMessageChannelInterceptor());
    TestMessageHandler messageHandler = new TestMessageHandler();
    channel.subscribe(messageHandler);
    StompSubProtocolHandler handler = new StompSubProtocolHandler();
    handler.afterSessionStarted(this.session, channel);
    TextMessage wsMessage = StompTextMessageBuilder.create(StompCommand.CONNECT).build();
    handler.handleMessageFromClient(this.session, wsMessage, channel);
    replacedertEquals(1, messageHandler.getMessages().size());
    Message<?> message = messageHandler.getMessages().get(0);
    Principal user = SimpMessageHeaderAccessor.getUser(message.getHeaders());
    replacedertNotNull(user);
    replacedertEquals("[email protected]", user.getName());
}

@Test
public void resolveWithConversion() throws Exception {
    Message<String> message = MessageBuilder.withPayload("test").build();
    MethodParameter parameter = new MethodParameter(this.method, 1);
    given(this.converter.fromMessage(message, Integer.clreplaced)).willReturn(4);
    @SuppressWarnings("unchecked")
    Message<Integer> actual = (Message<Integer>) this.resolver.resolveArgument(parameter, message);
    replacedertNotNull(actual);
    replacedertSame(message.getHeaders(), actual.getHeaders());
    replacedertEquals(new Integer(4), actual.getPayload());
}

@Test
public void convertAndSendWithSimpMessageHeaders() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setHeader("key", "value");
    accessor.setLeaveMutable(true);
    MessageHeaders headers = accessor.getMessageHeaders();
    this.template.convertAndSend("channel", "data", headers);
    List<Message<byte[]>> messages = this.messageChannel.getMessages();
    Message<byte[]> message = messages.get(0);
    replacedertSame(headers, message.getHeaders());
    replacedertFalse(accessor.isMutable());
}

@Test
public void toMessageWithPayloadAndMutableHeaders() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setHeader("foo", "bar");
    accessor.setLeaveMutable(true);
    MessageHeaders headers = accessor.getMessageHeaders();
    Message<?> message = this.converter.toMessage("payload", headers);
    replacedertEquals("payload", message.getPayload());
    replacedertSame(headers, message.getHeaders());
    replacedertEquals("bar", message.getHeaders().get("foo"));
}

@Test
public void toMessageWithPayloadAndHeaders() {
    MessageHeaders headers = new MessageHeaders(Collections.<String, Object>singletonMap("foo", "bar"));
    Message<?> message = this.converter.toMessage("payload", headers);
    replacedertEquals("payload", message.getPayload());
    replacedertEquals("bar", message.getHeaders().get("foo"));
}

@Test
public void streaminess() throws Exception {
    Message<String> message = MessageBuilder.withPayload("Hello").build();
    this.source.output().send(message);
    Message<?> received = this.collector.forChannel(this.source.output()).take();
    replacedertThat(received.getPayload()).isEqualTo(message.getPayload());
    replacedertThat(received.getHeaders()).containsKeys("contentType", "id", "timestamp");
}

@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void testWrappedWithAroundAdviseConfiguration() {
    FunctionCatalog catalog = this.configureCatalog(WrappedWithAroundAdviseConfiguration.clreplaced);
    Function f = catalog.lookup("uppercase");
    Message result = (Message) f.apply(new GenericMessage<String>("hello"));
    replacedertThat(result.getHeaders().get("before")).isEqualTo("foo");
    replacedertThat(result.getHeaders().get("after")).isEqualTo("bar");
}

@Override
public String destination(Supplier<?> supplier, String name, Object value) {
    if (logger.isDebugEnabled()) {
        logger.debug("Lambda invoming value: " + value);
    }
    String destination = "unknown";
    if (value instanceof Message) {
        Message<?> message = (Message<?>) value;
        MessageHeaders headers = message.getHeaders();
        if (headers.containsKey("lambda-runtime-aws-request-id")) {
            destination = (String) headers.get("lambda-runtime-aws-request-id");
        }
    }
    if (logger.isDebugEnabled()) {
        logger.debug("Lambda destination resolved to: " + destination);
    }
    return destination;
}

@Override
public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
    Object num = msg.getHeaders().get("test");
    if ("1".equals(num)) {
        System.out.println("executer: " + new String((byte[]) msg.getPayload()) + " unknown");
        return RocketMQLocalTransactionState.UNKNOWN;
    } else if ("2".equals(num)) {
        System.out.println("executer: " + new String((byte[]) msg.getPayload()) + " rollback");
        return RocketMQLocalTransactionState.ROLLBACK;
    }
    System.out.println("executer: " + new String((byte[]) msg.getPayload()) + " commit");
    return RocketMQLocalTransactionState.COMMIT;
}

@Test
public void headerConversionLazilyInvoked() throws JMSException {
    javax.jms.Message jmsMessage = mock(javax.jms.Message.clreplaced);
    when(jmsMessage.getPropertyNames()).thenThrow(new IllegalArgumentException("Header failure"));
    MessagingMessageListenerAdapter listener = getSimpleInstance("simple", Message.clreplaced);
    Message<?> message = listener.toMessagingMessage(jmsMessage);
    this.thrown.expect(IllegalArgumentException.clreplaced);
    this.thrown.expectMessage("Header failure");
    // Triggers headers resolution
    message.getHeaders();
}

/**
 * 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;
}

@Test
public void toMessageHeadersCopied() {
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("foo", "bar");
    MessageHeaders headers = new MessageHeaders(map);
    Message<?> message = this.converter.toMessage("ABC", headers);
    replacedertEquals("bar", message.getHeaders().get("foo"));
}

@Test
public void payloadIsAMessage() throws JMSException {
    final Message<String> message = MessageBuilder.withPayload("Test").setHeader("inside", true).build();
    converter.setPayloadConverter(new SimpleMessageConverter() {

        @Override
        public Object fromMessage(javax.jms.Message jmsMessage) throws JMSException, MessageConversionException {
            return message;
        }
    });
    Message<?> msg = (Message<?>) converter.fromMessage(new StubTextMessage());
    replacedertEquals(message.getPayload(), msg.getPayload());
    replacedertEquals(true, msg.getHeaders().get("inside"));
}

@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;
    javax.jms.Message reply = createMessageForPayload(input.getPayload(), session);
    this.headerMapper.fromHeaders(input.getHeaders(), reply);
    return reply;
}

@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "${spring.rabbitmq.listener.queue.name}", durable = "${spring.rabbitmq.listener.queue.durable}", exclusive = "${spring.rabbitmq.listener.queue.exclusive}", autoDelete = "${spring.rabbitmq.listener.queue.autoDelete}", ignoreDeclarationExceptions = "${spring.rabbitmq.listener.queue.ignoreDeclarationExceptions}"), exchange = @Exchange(name = "${spring.rabbitmq.listener.exchange.name}", type = "${spring.rabbitmq.listener.exchange.type}", durable = "${spring.rabbitmq.listener.exchange.durable}", autoDelete = "${spring.rabbitmq.listener.exchange.autoDelete}", ignoreDeclarationExceptions = "${spring.rabbitmq.listener.exchange.ignoreDeclarationExceptions}"), key = "${spring.rabbitmq.listener.exchange.routing-key}"))
@RabbitHandler
public void onMessage1(Message message, Channel channel) throws Exception {
    System.out.println("-----------------1 ");
    System.out.println("message : " + message.getPayload());
    channel.basicAck(message.getHeaders().get(AmqpHeaders.DELIVERY_TAG, Long.clreplaced), false);
}

@Override
public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
    fooService.checkInfo(msg);
    if ("1".equals(msg.getHeaders().get("error"))) {
        System.out.println(new String((byte[]) msg.getPayload()) + " rollback");
        return RocketMQLocalTransactionState.ROLLBACK;
    }
    return RocketMQLocalTransactionState.COMMIT;
}

@Test
public void testMessageBuilder() {
    Message msg = MessageBuilder.withPayload("test").setHeader("A", "test1").setHeader("B", "test2").build();
    System.out.printf("header size=%d  %s %n", msg.getHeaders().size(), msg.getHeaders().toString());
    replacedertTrue(msg.getHeaders().get("A") != null);
    replacedertTrue(msg.getHeaders().get("B") != null);
}

@Test
public void testHeaderConvertToSpringMsg() {
    org.apache.rocketmq.common.message.Message rmqMsg = new org.apache.rocketmq.common.message.Message();
    rmqMsg.setBody("test body".getBytes());
    rmqMsg.setTopic("test-topic");
    rmqMsg.putUserProperty("test", "1");
    rmqMsg.setTags("tags");
    Message springMsg = RocketMQUtil.convertToSpringMessage(rmqMsg);
    replacedertEquals(String.valueOf("1"), springMsg.getHeaders().get("test"));
    replacedertEquals("tags", springMsg.getHeaders().get(RocketMQHeaders.PREFIX + RocketMQHeaders.TAGS));
    org.apache.rocketmq.common.message.Message rocketMsg = RocketMQUtil.convertToRocketMessage(objectMapper, "UTF-8", "test-topic", springMsg);
    replacedertEquals(String.valueOf("1"), rocketMsg.getProperty("test"));
    replacedertEquals(String.valueOf("tags"), rocketMsg.getProperty(RocketMQHeaders.PREFIX + RocketMQHeaders.TAGS));
    replacedertNull(rocketMsg.getTags());
    rmqMsg.putUserProperty(toRocketHeaderKey(RocketMQHeaders.TAGS), "tags2");
    springMsg = RocketMQUtil.convertToSpringMessage(rmqMsg);
    replacedertEquals("tags", springMsg.getHeaders().get(RocketMQHeaders.PREFIX + RocketMQHeaders.TAGS));
}

@Test
public void testConvertToSpringMessage() {
    org.apache.rocketmq.common.message.MessageExt rocketMsg = new org.apache.rocketmq.common.message.MessageExt();
    rocketMsg.setTopic("test");
    rocketMsg.setBody("test".getBytes());
    rocketMsg.setTags("tagA");
    rocketMsg.setKeys("key1");
    Message message = RocketMQUtil.convertToSpringMessage(rocketMsg);
    replacedertEquals("test", message.getHeaders().get(toRocketHeaderKey(RocketMQHeaders.TOPIC)));
    replacedertEquals("tagA", message.getHeaders().get(toRocketHeaderKey(RocketMQHeaders.TAGS)));
    replacedertEquals("key1", message.getHeaders().get(toRocketHeaderKey(RocketMQHeaders.KEYS)));
}

@Test
public void shouldSendIntegrationRequestMessage() {
    // when
    integrationRequestSender.sendIntegrationRequest(integrationRequest);
    // then
    verify(integrationProducer).send(integrationRequestMessageCaptor.capture());
    Message<IntegrationRequest> integrationRequestMessage = integrationRequestMessageCaptor.getValue();
    IntegrationRequest sentIntegrationRequestEvent = integrationRequestMessage.getPayload();
    replacedertThat(sentIntegrationRequestEvent).isEqualTo(integrationRequest);
    replacedertThat(integrationRequestMessage.getHeaders().get(IntegrationRequestSender.CONNECTOR_TYPE)).isEqualTo(CONNECTOR_TYPE);
}

@Test
public void handleMessageFromClient() {
    TextMessage textMessage = StompTextMessageBuilder.create(StompCommand.STOMP).headers("login:guest", "preplacedcode:guest", "accept-version:1.1,1.0", "heart-beat:10000,10000").build();
    this.protocolHandler.afterSessionStarted(this.session, this.channel);
    this.protocolHandler.handleMessageFromClient(this.session, textMessage, this.channel);
    verify(this.channel).send(this.messageCaptor.capture());
    Message<?> actual = this.messageCaptor.getValue();
    replacedertNotNull(actual);
    replacedertEquals("s1", SimpMessageHeaderAccessor.getSessionId(actual.getHeaders()));
    replacedertNotNull(SimpMessageHeaderAccessor.getSessionAttributes(actual.getHeaders()));
    replacedertNotNull(SimpMessageHeaderAccessor.getUser(actual.getHeaders()));
    replacedertEquals("joe", SimpMessageHeaderAccessor.getUser(actual.getHeaders()).getName());
    replacedertNotNull(SimpMessageHeaderAccessor.getHeartbeat(actual.getHeaders()));
    replacedertArrayEquals(new long[] { 10000, 10000 }, SimpMessageHeaderAccessor.getHeartbeat(actual.getHeaders()));
    StompHeaderAccessor stompAccessor = StompHeaderAccessor.wrap(actual);
    replacedertEquals(StompCommand.STOMP, stompAccessor.getCommand());
    replacedertEquals("guest", stompAccessor.getLogin());
    replacedertEquals("guest", stompAccessor.getPreplacedcode());
    replacedertArrayEquals(new long[] { 10000, 10000 }, stompAccessor.getHeartbeat());
    replacedertEquals(new HashSet<>(Arrays.asList("1.1", "1.0")), stompAccessor.getAcceptVersion());
    replacedertEquals(0, this.session.getSentMessages().size());
}

@Test
public void testBuildMessageWithoutIdAndTimestamp() {
    MessageHeaderAccessor headerAccessor = new MessageHeaderAccessor();
    headerAccessor.setIdGenerator(new IdGenerator() {

        @Override
        public UUID generateId() {
            return MessageHeaders.ID_VALUE_NONE;
        }
    });
    Message<?> message = MessageBuilder.createMessage("foo", headerAccessor.getMessageHeaders());
    replacedertNull(message.getHeaders().getId());
    replacedertNull(message.getHeaders().getTimestamp());
}

@Test
public void testHeaderValues() {
    Message<String> message = MessageBuilder.withPayload("test").setHeader("foo", "bar").setHeader("count", 123).build();
    replacedertEquals("bar", message.getHeaders().get("foo", String.clreplaced));
    replacedertEquals(new Integer(123), message.getHeaders().get("count", Integer.clreplaced));
}

@Test
public void testSettingToNullRemoves() {
    Message<Integer> message1 = MessageBuilder.withPayload(1).setHeader("foo", "bar").build();
    Message<Integer> message2 = MessageBuilder.fromMessage(message1).setHeader("foo", null).build();
    replacedertFalse(message2.getHeaders().containsKey("foo"));
}

@Test
public void createIdRegenerated() {
    Message<String> message1 = MessageBuilder.withPayload("test").setHeader("foo", "bar").build();
    Message<String> message2 = MessageBuilder.fromMessage(message1).setHeader("another", 1).build();
    replacedertEquals("bar", message2.getHeaders().get("foo"));
    replacedertNotSame(message1.getHeaders().getId(), message2.getHeaders().getId());
}

@Test
public void testRemove() {
    Message<Integer> message1 = MessageBuilder.withPayload(1).setHeader("foo", "bar").build();
    Message<Integer> message2 = MessageBuilder.fromMessage(message1).removeHeader("foo").build();
    replacedertFalse(message2.getHeaders().containsKey("foo"));
}

@Test
public void testBuildMultipleMessages() {
    MessageHeaderAccessor headerAccessor = new MessageHeaderAccessor();
    MessageBuilder<?> messageBuilder = MessageBuilder.withPayload("payload").setHeaders(headerAccessor);
    headerAccessor.setHeader("foo", "bar1");
    Message<?> message1 = messageBuilder.build();
    headerAccessor.setHeader("foo", "bar2");
    Message<?> message2 = messageBuilder.build();
    headerAccessor.setHeader("foo", "bar3");
    Message<?> message3 = messageBuilder.build();
    replacedertEquals("bar1", message1.getHeaders().get("foo"));
    replacedertEquals("bar2", message2.getHeaders().get("foo"));
    replacedertEquals("bar3", message3.getHeaders().get("foo"));
}

@Test
public void handleUnsubscribe() {
    given(this.brokerChannel.send(Mockito.any(Message.clreplaced))).willReturn(true);
    this.handler.handleMessage(createWith(SimpMessageType.UNSUBSCRIBE, "joe", "123", "/user/queue/foo"));
    ArgumentCaptor<Message> captor = ArgumentCaptor.forClreplaced(Message.clreplaced);
    Mockito.verify(this.brokerChannel).send(captor.capture());
    Message message = captor.getValue();
    replacedertEquals("/queue/foo-user123", SimpMessageHeaderAccessor.getDestination(message.getHeaders()));
}

@Test
public void jmsTypeIgnoredIfIncorrectType() throws JMSException {
    Message<String> message = initBuilder().setHeader(JmsHeaders.TYPE, 123).build();
    javax.jms.Message jmsMessage = new StubTextMessage();
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    replacedertNull(jmsMessage.getJMSType());
}

@Test
public void attemptToWriteDisallowedReplyToPropertyIsNotFatal() throws JMSException {
    Message<String> message = initBuilder().setHeader(JmsHeaders.REPLY_TO, new Destination() {
    }).setHeader("foo", "bar").build();
    javax.jms.Message jmsMessage = new StubTextMessage() {

        @Override
        public void setJMSReplyTo(Destination replyTo) throws JMSException {
            throw new JMSException("illegal property");
        }
    };
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    replacedertNull(jmsMessage.getJMSReplyTo());
    replacedertNotNull(jmsMessage.getStringProperty("foo"));
    replacedertEquals("bar", jmsMessage.getStringProperty("foo"));
}

@Test
public void jmsTypeMappedFromHeader() throws JMSException {
    String jmsType = "testing";
    Message<String> message = initBuilder().setHeader(JmsHeaders.TYPE, jmsType).build();
    javax.jms.Message jmsMessage = new StubTextMessage();
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    replacedertNotNull(jmsMessage.getJMSType());
    replacedertEquals(jmsType, jmsMessage.getJMSType());
}

@Test
public void JmsReplyToIgnoredIfIncorrectType() throws JMSException {
    Message<String> message = initBuilder().setHeader(JmsHeaders.REPLY_TO, "not-a-destination").build();
    javax.jms.Message jmsMessage = new StubTextMessage();
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    replacedertNull(jmsMessage.getJMSReplyTo());
}

@Test
public void propertyMappingExceptionIsNotFatal() throws JMSException {
    Message<String> message = initBuilder().setHeader("foo", 123).setHeader("bad", 456).setHeader("bar", 789).build();
    javax.jms.Message jmsMessage = new StubTextMessage() {

        @Override
        public void setObjectProperty(String name, Object value) throws JMSException {
            if (name.equals("bad")) {
                throw new JMSException("illegal property");
            }
            super.setObjectProperty(name, value);
        }
    };
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    Object foo = jmsMessage.getObjectProperty("foo");
    replacedertNotNull(foo);
    Object bar = jmsMessage.getObjectProperty("bar");
    replacedertNotNull(bar);
    Object bad = jmsMessage.getObjectProperty("bad");
    replacedertNull(bad);
}

@Test
public void userDefinedPropertyWithUnsupportedType() throws JMSException {
    Destination destination = new Destination() {
    };
    Message<String> message = initBuilder().setHeader("destination", destination).build();
    javax.jms.Message jmsMessage = new StubTextMessage();
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    Object value = jmsMessage.getObjectProperty("destination");
    replacedertNull(value);
}

// Outbound mapping
@Test
public void jmsReplyToMappedFromHeader() throws JMSException {
    Destination replyTo = new Destination() {
    };
    Message<String> message = initBuilder().setHeader(JmsHeaders.REPLY_TO, replyTo).build();
    javax.jms.Message jmsMessage = new StubTextMessage();
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    replacedertNotNull(jmsMessage.getJMSReplyTo());
    replacedertSame(replyTo, jmsMessage.getJMSReplyTo());
}

@Test
public void attemptToWriteDisallowedTypePropertyIsNotFatal() throws JMSException {
    Message<String> message = initBuilder().setHeader(JmsHeaders.TYPE, "someType").setHeader("foo", "bar").build();
    javax.jms.Message jmsMessage = new StubTextMessage() {

        @Override
        public void setJMSType(String type) throws JMSException {
            throw new JMSException("illegal property");
        }
    };
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    replacedertNull(jmsMessage.getJMSType());
    replacedertNotNull(jmsMessage.getStringProperty("foo"));
    replacedertEquals("bar", jmsMessage.getStringProperty("foo"));
}

@Test
public void illegalArgumentExceptionIsNotFatal() throws JMSException {
    Message<String> message = initBuilder().setHeader("foo", 123).setHeader("bad", 456).setHeader("bar", 789).build();
    javax.jms.Message jmsMessage = new StubTextMessage() {

        @Override
        public void setObjectProperty(String name, Object value) throws JMSException {
            if (name.equals("bad")) {
                throw new IllegalArgumentException("illegal property");
            }
            super.setObjectProperty(name, value);
        }
    };
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    Object foo = jmsMessage.getObjectProperty("foo");
    replacedertNotNull(foo);
    Object bar = jmsMessage.getObjectProperty("bar");
    replacedertNotNull(bar);
    Object bad = jmsMessage.getObjectProperty("bad");
    replacedertNull(bad);
}

@Test
public void userDefinedPropertyMappedFromHeaderWithCustomPrefix() throws JMSException {
    Message<String> message = initBuilder().setHeader("foo", 123).build();
    mapper.setOutboundPrefix("custom_");
    javax.jms.Message jmsMessage = new StubTextMessage();
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    Object value = jmsMessage.getObjectProperty("custom_foo");
    replacedertNotNull(value);
    replacedertEquals(Integer.clreplaced, value.getClreplaced());
    replacedertEquals(123, ((Integer) value).intValue());
}

@Test
public void userDefinedPropertyMappedFromHeader() throws JMSException {
    Message<String> message = initBuilder().setHeader("foo", 123).build();
    javax.jms.Message jmsMessage = new StubTextMessage();
    mapper.fromHeaders(message.getHeaders(), jmsMessage);
    Object value = jmsMessage.getObjectProperty("foo");
    replacedertNotNull(value);
    replacedertEquals(Integer.clreplaced, value.getClreplaced());
    replacedertEquals(123, ((Integer) value).intValue());
}

private boolean releaseStrategy(MessageGroup group) {
    replacedert group.size() > 0;
    if (group.size() == 1) {
        // i.e. if group consists of just one element and thus is insufficient for making decision
        return false;
    }
    if (group.size() >= groupSizeThreshold) {
        return true;
    }
    MessageTwain prevAndLastMessages = findPrevAndLastMessages(group);
    Message<?> lastMessage = prevAndLastMessages.getM1();
    Message<?> second2LastMessage = prevAndLastMessages.getM2();
    // relying on check for singleton group
    replacedert (lastMessage != null) && (second2LastMessage != null);
    Long lastMessageCorrId = lastMessage.getHeaders().get(CORRELATION_ID, Long.clreplaced);
    Long prevMessageCorrId = second2LastMessage.getHeaders().get(CORRELATION_ID, Long.clreplaced);
    boolean isGroupComplete = !Objects.equals(lastMessageCorrId, prevMessageCorrId);
    if (isGroupComplete) {
        log.trace("Group {} is about to be released as last corrId {} differs from previous ones {}.", group.getGroupId(), lastMessageCorrId, prevMessageCorrId);
    }
    return isGroupComplete;
}

public static void main(String[] args) throws InterruptedException, IOException {
    // System.setProperty("spring.sleuth.enabled", "false");
    // System.setProperty("spring.sleuth.reactor.instrumentation-type",
    // "DECORATE_ON_EACH");
    // System.setProperty("spring.sleuth.reactor.instrumentation-type",
    // "DECORATE_ON_LAST");
    // System.setProperty("spring.sleuth.reactor.instrumentation-type", "MANUAL");
    System.setProperty("spring.sleuth.reactor.instrumentation-type", "MANUAL");
    System.setProperty("spring.sleuth.function.type", "simple");
    ConfigurableApplicationContext context = SpringApplication.run(SleuthBenchmarkingStreamApplication.clreplaced, args);
    for (int i = 0; i < 1; i++) {
        InputDestination input = context.getBean(InputDestination.clreplaced);
        input.send(MessageBuilder.withPayload("hello".getBytes()).setHeader("b3", "4883117762eb9420-4883117762eb9420-1").build());
        log.info("Retrieving the message for tests");
        OutputDestination output = context.getBean(OutputDestination.clreplaced);
        Message<byte[]> message = output.receive(200L);
        log.info("Got the message from output");
        replacedertThat(message).isNotNull();
        log.info("Message is not null");
        replacedertThat(message.getPayload()).isEqualTo("HELLO".getBytes());
        log.info("Payload is HELLO");
        String b3 = message.getHeaders().get("b3", String.clreplaced);
        log.info("Checking the b3 header [" + b3 + "]");
        replacedertThat(b3).startsWith("4883117762eb9420");
    }
}

@Test
public void testSortedInboundChannelAdapter() {
    // This uses the channel adapter with a custom comparator.
    // Files will be processed in ascending order by name: alpha/alpha, beta, gamma
    Message<?> message = this.sortedChannel.receive(5000);
    replacedertThat(message).isNotNull();
    replacedertThat(message.getPayload()).isInstanceOf(InputStream.clreplaced);
    replacedertThat(message.getHeaders().get(FileHeaders.REMOTE_FILE)).isEqualTo("alpha/alpha");
    message = this.sortedChannel.receive(5000);
    replacedertThat(message.getHeaders().get(FileHeaders.REMOTE_FILE)).isEqualTo("beta");
    replacedertThat(message.getPayload()).isInstanceOf(InputStream.clreplaced);
    message = this.sortedChannel.receive(5000);
    replacedertThat(message.getHeaders().get(FileHeaders.REMOTE_FILE)).isEqualTo("gamma");
    replacedertThat(message.getPayload()).isInstanceOf(InputStream.clreplaced);
    message = this.sortedChannel.receive(10);
    replacedertThat(message).isNull();
}

@Test
public void testInboundStreamingChannelAdapter() {
    Message<?> message = this.unsortedChannel.receive(5000);
    replacedertThat(message).isNotNull();
    replacedertThat(message.getPayload()).isInstanceOf(InputStream.clreplaced);
    replacedertThat(message.getHeaders().get(FileHeaders.REMOTE_FILE)).isEqualTo("gamma");
    message = this.unsortedChannel.receive(5000);
    replacedertThat(message.getHeaders().get(FileHeaders.REMOTE_FILE)).isEqualTo("beta");
    replacedertThat(message.getPayload()).isInstanceOf(InputStream.clreplaced);
    message = this.unsortedChannel.receive(5000);
    replacedertThat(message.getHeaders().get(FileHeaders.REMOTE_FILE)).isEqualTo("alpha/alpha");
    replacedertThat(message.getPayload()).isInstanceOf(InputStream.clreplaced);
    message = this.unsortedChannel.receive(10);
    replacedertThat(message).isNull();
}

@Test
public void sendAndReceiveMessagereplacedtring() {
    this.contextRunner.withUserConfiguration(PollableConfiguration.clreplaced, CommonConfiguration.clreplaced).run((context) -> {
        Map<String, Object> headers = new HashMap<>();
        // Only String values for now..
        headers.put("storm", "lift your skinny fists");
        headers.put("static", "lift your skinny fists");
        headers.put("sleep", "lift your skinny fists");
        Message originalMessage = MessageBuilder.createMessage("I am a message (sendAndReceiveMessagereplacedtring).".getBytes(), new MessageHeaders(headers));
        context.getBean("inputChannel", MessageChannel.clreplaced).send(originalMessage);
        Message<?> message = context.getBean("outputChannel", PollableChannel.clreplaced).receive(RECEIVE_TIMEOUT_MS);
        replacedertThat(message).isNotNull();
        replacedertThat(message.getPayload()).isInstanceOf(byte[].clreplaced);
        String payload = new String((byte[]) message.getPayload());
        replacedertThat(payload).isEqualTo("I am a message (sendAndReceiveMessagereplacedtring).");
        replacedertThat(message.getHeaders().size()).isEqualTo(6);
        replacedertThat(message.getHeaders().get("storm")).isEqualTo("lift your skinny fists");
        replacedertThat(message.getHeaders().get("static")).isEqualTo("lift your skinny fists");
        replacedertThat(message.getHeaders().get("sleep")).isEqualTo("lift your skinny fists");
        replacedertThat(message.getHeaders().get(GcpPubSubHeaders.ORIGINAL_MESSAGE)).isNotNull();
    });
}

@Test
public void testPojoToStringViaMessageExpectMessage() {
    int port = SocketUtils.findAvailableTcpPort();
    try (ConfigurableApplicationContext applicationContext = new SpringApplicationBuilder(MessagingConfiguration.clreplaced).web(WebApplicationType.NONE).run("--logging.level.org.springframework.cloud.function=DEBUG", "--spring.rsocket.server.port=" + port)) {
        RSocketRequester.Builder rsocketRequesterBuilder = applicationContext.getBean(RSocketRequester.Builder.clreplaced);
        Person p = new Person();
        p.setName("Ricky");
        Message<Person> message = MessageBuilder.withPayload(p).setHeader("someHeader", "foo").build();
        Message<String> result = rsocketRequesterBuilder.tcp("localhost", port).route("pojoToString").data(message).retrieveMono(new ParameterizedTypeReference<Message<String>>() {
        }).block();
        replacedertThat(result.getPayload()).isEqualTo("RICKY");
        replacedertThat(result.getHeaders().get("someHeader")).isEqualTo("foo");
    }
}

@Test
public void testPojoMessageToPojoViaMessageExpectMessage() {
    int port = SocketUtils.findAvailableTcpPort();
    try (ConfigurableApplicationContext applicationContext = new SpringApplicationBuilder(MessagingConfiguration.clreplaced).web(WebApplicationType.NONE).run("--logging.level.org.springframework.cloud.function=DEBUG", "--spring.rsocket.server.port=" + port)) {
        RSocketRequester.Builder rsocketRequesterBuilder = applicationContext.getBean(RSocketRequester.Builder.clreplaced);
        Person p = new Person();
        p.setName("Ricky");
        Message<Person> message = MessageBuilder.withPayload(p).setHeader("someHeader", "foo").build();
        Message<Person> result = rsocketRequesterBuilder.tcp("localhost", port).route("pojoMessageToPojo").data(message).retrieveMono(new ParameterizedTypeReference<Message<Person>>() {
        }).block();
        replacedertThat(result.getPayload().getName()).isEqualTo("RICKY");
        replacedertThat(result.getHeaders().get("someHeader")).isEqualTo("foo");
    }
}

@SuppressWarnings("unchecked")
@Test
public void testSerializationWithCompatibleWildcardSubtypeAcceptHeader() {
    FunctionCatalog catalog = this.configureCatalog(NegotiatingMessageConverterConfiguration.clreplaced);
    FunctionInvocationWrapper function = catalog.lookup("echo", "text/*");
    Message<Tuple2<String, String>> tupleResult = (Message<Tuple2<String, String>>) function.apply(MessageBuilder.withPayload(Tuples.of("bonjour", "monde")).setHeader(MessageHeaders.CONTENT_TYPE, MimeType.valueOf("text/csv")).build());
    replacedertThat(tupleResult.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MimeType.valueOf("text/csv"));
    replacedertThat(tupleResult.getHeaders().get("accept")).isNull();
    Message<Date> dateResult = (Message<Date>) function.apply(MessageBuilder.withPayload(123).setHeader(MessageHeaders.CONTENT_TYPE, MimeType.valueOf("text/integer")).build());
    replacedertThat(dateResult.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MimeType.valueOf("text/integer"));
    replacedertThat(dateResult.getHeaders().get("accept")).isNull();
}

@Test
public void testAttributeRecognitionAndCanonicalization() {
    Message<String> httpMessage = MessageBuilder.withPayload("hello").setHeader(CloudEventMessageUtils.SOURCE, "https://foo.bar").setHeader(CloudEventMessageUtils.SPECVERSION, "1.0").setHeader(CloudEventMessageUtils.TYPE, "blah").setHeader("x", "x").setHeader("zzz", "zzz").build();
    Map<String, Object> attributes = CloudEventMessageUtils.getAttributes(httpMessage);
    replacedertThat(attributes.size()).isEqualTo(3);
    replacedertThat((String) CloudEventMessageUtils.getData(httpMessage)).isEqualTo("hello");
    Message<String> kafkaMessage = CloudEventMessageBuilder.fromMessage(httpMessage).build(CloudEventMessageUtils.KAFKA_ATTR_PREFIX);
    attributes = CloudEventMessageUtils.getAttributes(kafkaMessage);
    // id will be auto injected, so always at least 4 (as tehre are 4 required attributes in CE)
    replacedertThat(attributes.size()).isEqualTo(4);
    replacedertThat(kafkaMessage.getHeaders().get("ce_source")).isNotNull();
    replacedertThat(CloudEventMessageUtils.getSource(kafkaMessage)).isEqualTo(URI.create("https://foo.bar"));
    replacedertThat(kafkaMessage.getHeaders().get("ce_type")).isNotNull();
    replacedertThat(CloudEventMessageUtils.getType(kafkaMessage)).isEqualTo("blah");
    replacedertThat(kafkaMessage.getHeaders().get("ce_specversion")).isNotNull();
    replacedertThat(CloudEventMessageUtils.getSpecVersion(kafkaMessage)).isEqualTo("1.0");
    httpMessage = CloudEventMessageBuilder.fromMessage(kafkaMessage).build(CloudEventMessageUtils.DEFAULT_ATTR_PREFIX);
    attributes = CloudEventMessageUtils.getAttributes(httpMessage);
    // 
    replacedertThat(attributes.size()).isEqualTo(4);
    replacedertThat(httpMessage.getHeaders().get("ce-source")).isNotNull();
    replacedertThat(CloudEventMessageUtils.getSource(httpMessage)).isEqualTo(URI.create("https://foo.bar"));
    replacedertThat(httpMessage.getHeaders().get("ce-type")).isNotNull();
    replacedertThat(CloudEventMessageUtils.getType(httpMessage)).isEqualTo("blah");
    replacedertThat(httpMessage.getHeaders().get("ce-specversion")).isNotNull();
    replacedertThat(CloudEventMessageUtils.getSpecVersion(httpMessage)).isEqualTo("1.0");
}

See More Examples