org.springframework.amqp.core.MessageProperties

/**
 * 发送mq消息
 *
 * @param exchange   exchange
 * @param routingKey routingKey
 * @param object     object
 * @return boolean
 */
public boolean messageSendMQ(String exchange, String routingKey, String object) {
    if (object == null) {
        return false;
    }
    // 本地缓存
    MessageProperties messageProperties = new MessageProperties();
    // 设置消息是否持久化。Persistent表示持久化，Non-persistent表示不持久化
    messageProperties.setDeliveryMode(MessageDeliveryMode.fromInt(this.deliveryMode));
    Message message = new Message(object.getBytes(), messageProperties);
    return this.messageSendMQ(exchange, routingKey, message);
}

@Test
public void should_call_send_to_retry_with_correct_params_without_ttl_message() {
    when(rabbitTemplateHandler.getRabbitTemplate(Mockito.any(TunedRabbitProperties.clreplaced))).thenReturn(rabbitTemplate);
    doNothing().when(rabbitTemplate).send(Mockito.any(), Mockito.any(), Mockito.any());
    int numberOfDeaths = 3;
    MessageProperties messageProperties = createMessageProperties(numberOfDeaths);
    Message message = new Message("some".getBytes(), messageProperties);
    TunedRabbitProperties queueProperties = createQueueProperties(2, 5);
    queueRetryComponent.sendToRetry(message, queueProperties, numberOfDeaths);
    verify(rabbitTemplate).send(ArgumentMatchers.eq(queueProperties.getExchange()), ArgumentMatchers.eq(queueProperties.getQueueRetry()), ArgumentMatchers.eq(message));
    replacedert.replacedertEquals("20000", messageProperties.getExpiration());
}

@Test
public void should_return_1_death() {
    MessageProperties messageProperties = createMessageProperties(1);
    Message message = new Message("some".getBytes(), messageProperties);
    int countDeath = queueRetryComponent.countDeath(message);
    replacedert.replacedertEquals(1, countDeath);
}

@Test
public void should_return_3_death() {
    MessageProperties messageProperties = createMessageProperties(3);
    Message message = new Message("some".getBytes(), messageProperties);
    int countDeath = queueRetryComponent.countDeath(message);
    replacedert.replacedertEquals(3, countDeath);
}

@Test
public void should_return_2_death() {
    MessageProperties messageProperties = createMessageProperties(2);
    Message message = new Message("some".getBytes(), messageProperties);
    int countDeath = queueRetryComponent.countDeath(message);
    replacedert.replacedertEquals(2, countDeath);
}

/**
 * construct easy message.
 * @return
 */
private Message getMessage() {
    final MessageProperties properties = new MessageProperties();
    properties.setReceivedExchange("sofaTracerTestExchange");
    properties.setReceivedRoutingKey("sofaTracerTestRoutingKey");
    return new Message("".getBytes(Charset.defaultCharset()), properties);
}

/**
 *  RabbitMqInjectCarrier.
 *
 * @author  chenchen6  2020/8/22 17:36
 * @since 3.1.0
 */
public clreplaced RabbitMqInjectCarrier implements TextMap {

    private final MessageProperties messageProperties;

    public RabbitMqInjectCarrier(MessageProperties messageProperties) {
        this.messageProperties = messageProperties;
    }

    @Override
    public void put(String key, String value) {
        messageProperties.getHeaders().put(key, value);
    }

    @Override
    public Iterator<Map.Entry<String, String>> iterator() {
        throw new UnsupportedOperationException("iterator should never be used with sofa tracer #inject()");
    }
}

@Before
public void setUp() {
    MessageProperties messageProperties = MessagePropertiesBuilder.newInstance().setHeader("x-original-queue", "original-queue").build();
    message = MessageBuilder.withBody("DummyMessage".getBytes()).andProperties(messageProperties).build();
    reQueueMessage = ReQueueMessage.builder().deadLetterQueue("dlq-name").messageCount(2).build();
}

@Before
public void setUp() {
    MessageProperties messageProperties = MessagePropertiesBuilder.newInstance().build();
    message = MessageBuilder.withBody("DummyMessage".getBytes()).andProperties(messageProperties).build();
}

private Message getMessage() {
    final MessageProperties messageProperties = new MessageProperties();
    messageProperties.setReceivedExchange("exchange");
    messageProperties.setReceivedRoutingKey("routingKey");
    messageProperties.setMessageId("messageId");
    return new Message("".getBytes(Charset.defaultCharset()), messageProperties);
}

/**
 * Note, new span isn't created for reply messages.
 * This extension point allows for example marking AMQP message consumer span with error for example based custom headers
 */
public void onSendReply(MessageProperties replyMessageProperties, String replyExchange, String replyRoutingKey, Span span) {
}

/**
 * @author Gilles Robert
 */
clreplaced RabbitMqInjectAdapter implements TextMap {

    private final MessageProperties messageProperties;

    RabbitMqInjectAdapter(MessageProperties messageProperties) {
        this.messageProperties = messageProperties;
    }

    @Override
    public void put(String key, String value) {
        messageProperties.getHeaders().put(key, value);
    }

    @Override
    public Iterator<Map.Entry<String, String>> iterator() {
        throw new UnsupportedOperationException("iterator should never be used with Tracer.inject()");
    }
}

public static Message createIdempotentMessage() {
    MessageProperties messageProperties = createMessageProperties();
    MessageContext context = new MessageContext(messageProperties);
    return new Message(context);
}

public static MessageContext createIdempotentContext() {
    MessageProperties messageProperties = createMessageProperties();
    return new MessageContext(messageProperties);
}

/**
 * Convert object and message properties to message.
 *
 * @param object
 *            to get converted
 * @param messageProperties
 *            to get converted
 * @return converted message
 */
public Message convertMessage(final Object object, final MessageProperties messageProperties) {
    return rabbitTemplate.getMessageConverter().toMessage(object, messageProperties);
}

/**
 * Method to validate if content type is set in the message properties.
 *
 * @param message
 *            the message to get validated
 */
private void checkContentTypeJson(final Message message) {
    if (message.getBody().length == 0) {
        return;
    }
    final MessageProperties messageProperties = message.getMessageProperties();
    final String headerContentType = (String) messageProperties.getHeaders().get("content-type");
    if (null != headerContentType) {
        messageProperties.setContentType(headerContentType);
    }
    final String contentType = messageProperties.getContentType();
    if (contentType != null && contentType.contains("json")) {
        return;
    }
    throw new AmqpRejectAndDontRequeueException("Content-Type is not JSON compatible");
}

@Override
public Message toMessage(Object object, MessageProperties messageProperties) throws MessageConversionException {
    return new Message(object.toString().getBytes(), messageProperties);
}

private MessageProperties createMessageProperties(Integer numberOfDeaths) {
    MessageProperties messageProperties = new MessageProperties();
    HashMap<String, Integer> map = new HashMap<>();
    IntStream.range(0, numberOfDeaths).forEach(value -> map.put("count", value));
    messageProperties.getHeaders().put("x-death", Collections.singletonList(map));
    return messageProperties;
}

private static Message createMessageWithDeath(int numberOfDeaths) {
    MessageProperties messageProperties = new MessageProperties();
    HashMap<String, Integer> map = new HashMap<>();
    map.put(COUNT, numberOfDeaths);
    messageProperties.getHeaders().put(X_DEATH, Collections.singletonList(map));
    return new Message("some".getBytes(), messageProperties);
}

/**
 * construct message and add some amqp headers by sofa trace id and spanId.
 * @return
 */
private Message getConstructMessageWithContext() {
    Message message = getMessage();
    MessageProperties messageProperties = message.getMessageProperties();
    messageProperties.setHeader(AbstractTextB3Formatter.TRACE_ID_KEY_HEAD, sendTraceId);
    messageProperties.setHeader(AbstractTextB3Formatter.SPAN_ID_KEY_HEAD, sendSpanId);
    return new Message("".getBytes(Charset.defaultCharset()), messageProperties);
}

// inject headers.
private void injectCarrier(SofaTracerSpan tracerSpan, MessageProperties properties) {
    SofaTracer sofaTracer = this.rabbitMQSendTracer.getSofaTracer();
    sofaTracer.inject(tracerSpan.getSofaTracerSpanContext(), ExtendFormat.Builtin.B3_TEXT_MAP, new RabbitMqInjectCarrier(properties));
}

private Message getMessageWithContext() {
    Message message = getMessage();
    MessageProperties messageProperties = message.getMessageProperties();
    messageProperties.setHeader("traceid", 1L);
    messageProperties.setHeader("spanid", 1L);
    return new Message("".getBytes(Charset.defaultCharset()), messageProperties);
}

@Test(expected = UnsupportedOperationException.clreplaced)
public void tesreplacederator() {
    // given
    MessageProperties messageProperties = new MessageProperties();
    RabbitMqInjectAdapter carrier = new RabbitMqInjectAdapter(messageProperties);
    // when
    carrier.iterator();
// then exception
}

/**
 * 发送消息到队列
 *
 * @param Expiration
 * @Description:
 * @param: * @param msg
 * @return: void
 * @Author: 落叶随风
 * @Date: 2020/4/16
 */
public void send(Object msg, int Expiration) {
    CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
    rabbitTemplate.convertAndSend("delay", "routing_delay", msg, message -> {
        MessageProperties messageProperties = message.getMessageProperties();
        // 设置这条消息的过期时间
        // messageProperties.setExpiration(Expiration);
        messageProperties.setHeader("x-delay", Expiration);
        return message;
    }, correlationData);
}

@Override
public Message toMessage(Object object, MessageProperties messageProperties) throws MessageConversionException {
    throw new MessageConversionException(" convert error ! ");
}

private Message updateAttributes(final String tenant, final String targetId, final DmfUpdateMode mode, final Map<String, String> attributes) {
    final MessageProperties messagePropertiesForSP = createAttributeUpdateMessage(tenant, targetId);
    final DmfAttributeUpdate attributeUpdate = new DmfAttributeUpdate();
    attributeUpdate.setMode(mode);
    attributeUpdate.getAttributes().putAll(attributes);
    return convertMessage(attributeUpdate, messagePropertiesForSP);
}

private static String getTenant(final Message message) {
    final MessageProperties messageProperties = message.getMessageProperties();
    final Map<String, Object> headers = messageProperties.getHeaders();
    return (String) headers.get(MessageHeaderKey.TENANT);
}

@Test
public void should_call_send_to_dlq_with_correct_params() {
    when(rabbitTemplateHandler.getRabbitTemplate(Mockito.any(TunedRabbitProperties.clreplaced))).thenReturn(rabbitTemplate);
    doNothing().when(rabbitTemplate).send(Mockito.any(), Mockito.any(), Mockito.any());
    MessageProperties messageProperties = createMessageProperties(3);
    Message message = new Message("some".getBytes(), messageProperties);
    TunedRabbitProperties queueProperties = createQueueProperties();
    queueRetryComponent.sendToDlq(message, queueProperties);
    verify(rabbitTemplate).send(ArgumentMatchers.eq(queueProperties.getExchange()), ArgumentMatchers.eq(queueProperties.getQueueDlq()), ArgumentMatchers.eq(message));
    replacedert.replacedertFalse(messageProperties.getHeaders().containsKey("x-death"));
}

private String createRetryQueueAndGetRetryRourtingKey(Message message) {
    MessageProperties messageProperties = message.getMessageProperties();
    String exchange = messageProperties.getReceivedExchange();
    String routeKey = messageProperties.getReceivedRoutingKey();
    String queueName = messageProperties.getConsumerQueue();
    String retryQueueName = queueName + DeadLetterConstant.DEFAULT_RETRY_QUEUENAME_PREFIX;
    String retryRouteKey = routeKey + DeadLetterConstant.DEFAULT_RETRY_QUEUENAME_PREFIX;
    deadLetterQueueCreator.createDeadLetterQueue(exchange, routeKey, retryRouteKey, queueName, retryQueueName, interval);
    return retryRouteKey;
}

@Test
public void testTraceRabbitSend_whenNoConversionIsNeeded() throws Throwable {
    MessageProperties properties = new MessageProperties();
    Message message = new Message("".getBytes(), properties);
    Object[] args = new Object[] { exchange, ROUTING_KEY, message };
    given(proceedingJoinPoint.getArgs()).willReturn(args);
    given(messageConverter.toMessage(any(Object.clreplaced), any(MessageProperties.clreplaced))).willReturn(message);
    // com.sofa.alipay.tracer.plugins.rabbitmq.aspect.SofaTracerSendMessageAspect.traceRabbitSend(org.aspectj.lang.ProceedingJoinPoint, java.lang.String, java.lang.String, java.lang.Object)
    aspect.traceRabbitSend(proceedingJoinPoint, exchange, ROUTING_KEY, message);
    verify(proceedingJoinPoint).getArgs();
    verify(proceedingJoinPoint).proceed(args);
}

@Test(expected = Throwable.clreplaced)
public void testTraceRabbitSend_whenException() throws Throwable {
    MessageProperties properties = new MessageProperties();
    Message message = new Message("".getBytes(), properties);
    Object[] args = new Object[] { exchange, ROUTING_KEY, message };
    given(proceedingJoinPoint.getArgs()).willReturn(args);
    given(messageConverter.toMessage(any(Object.clreplaced), any(MessageProperties.clreplaced))).willReturn(message);
    given(proceedingJoinPoint.proceed(args)).willThrow(new RuntimeException());
    try {
        aspect.traceRabbitSend(proceedingJoinPoint, exchange, ROUTING_KEY, message);
    } catch (Throwable t) {
        verify(proceedingJoinPoint).getArgs();
        verify(proceedingJoinPoint).proceed(args);
        throw t;
    }
}

private void appendRequestSpanTags(SofaTracerSpan tracerSpan, MessageProperties messageProperties) {
    // append some tags/
    tracerSpan.setTag(CommonSpanTags.CURRENT_THREAD_NAME, Thread.currentThread().getName());
    tracerSpan.setTag(CommonSpanTags.LOCAL_APP, SofaTracerConfiguration.getProperty(SofaTracerConfiguration.TRACER_APPNAME_KEY));
    tracerSpan.setTag(CommonSpanTags.RABBIT_EXCHANGE, messageProperties.getReceivedExchange());
    tracerSpan.setTag(CommonSpanTags.RABBIT_ROUNTING_KEY, messageProperties.getReceivedRoutingKey());
    tracerSpan.setTag(CommonSpanTags.RABBIT_QUEUE_NAME, messageProperties.getConsumerQueue());
}

private void appendRequestSpanTagsAndInject(SofaTracerSpan tracerSpan, String exchange, String routingKey, Message convertedMessage) {
    MessageProperties properties = convertedMessage.getMessageProperties();
    // append tags
    tracerSpan.setTag(CommonSpanTags.CURRENT_THREAD_NAME, Thread.currentThread().getName());
    tracerSpan.setTag(CommonSpanTags.LOCAL_APP, SofaTracerConfiguration.getProperty(SofaTracerConfiguration.TRACER_APPNAME_KEY));
    tracerSpan.setTag(CommonSpanTags.RABBIT_EXCHANGE, exchange);
    tracerSpan.setTag(CommonSpanTags.RABBIT_ROUNTING_KEY, routingKey);
    // inject
    injectCarrier(tracerSpan, properties);
}

@Test
public void onMessageWithoutReplyTo() {
    final MessageProperties props = new MessageProperties();
    final byte[] payload = UUID.randomUUID().toString().getBytes();
    final Message message = new Message(payload, props);
    expect(messageHandler.handleMessage(aryEq(payload))).andReturn("{\"id\":1}");
    replayAll();
    rpcQueueMessageHandlerAdapter.onMessage(message);
    verifyAll();
}

@Test
public void testTraceRabbitSend_whenNoPropertiesHeaders() throws Throwable {
    // given
    String exchange = "opentracing.event.exchange";
    String routingKey = ROUTING_KEY;
    Span span = mockTracer.buildSpan("test").start();
    mockTracer.scopeManager().activate(span);
    TestMessage<String> myMessage = new TestMessage<>("");
    Object[] args = new Object[] { exchange, routingKey, myMessage };
    given(proceedingJoinPoint.getArgs()).willReturn(args);
    MessageProperties properties = new MessageProperties();
    properties.setReceivedExchange("exchange");
    properties.setReceivedRoutingKey("routingKey");
    properties.setMessageId("messageId");
    Message message = new Message("".getBytes(), properties);
    given(messageConverter.toMessage(any(Object.clreplaced), any(MessageProperties.clreplaced))).willReturn(message);
    // when
    aspect.traceRabbitSend(proceedingJoinPoint, exchange, routingKey, myMessage);
    // then
    verify(proceedingJoinPoint).getArgs();
    verify(messageConverter).toMessage(any(Object.clreplaced), any(MessageProperties.clreplaced));
    verify(proceedingJoinPoint).proceed(args);
}

@Test
public void testTraceRabbitSend_whenNoConversionIsNeeded() throws Throwable {
    // given
    String exchange = "opentracing.event.exchange";
    MessageProperties properties = new MessageProperties();
    Message message = new Message("".getBytes(), properties);
    Object[] args = new Object[] { exchange, ROUTING_KEY, message };
    given(proceedingJoinPoint.getArgs()).willReturn(args);
    given(messageConverter.toMessage(any(Object.clreplaced), any(MessageProperties.clreplaced))).willReturn(message);
    // when
    aspect.traceRabbitSend(proceedingJoinPoint, exchange, ROUTING_KEY, message);
    // then
    verify(proceedingJoinPoint).getArgs();
    verify(proceedingJoinPoint).proceed(args);
}

@Test(expected = RuntimeException.clreplaced)
public void testTraceRabbitSend_whenException() throws Throwable {
    // given
    String exchange = "opentracing.event.exchange";
    MessageProperties properties = new MessageProperties();
    Message message = new Message("".getBytes(), properties);
    Object[] args = new Object[] { exchange, ROUTING_KEY, message };
    given(proceedingJoinPoint.getArgs()).willReturn(args);
    given(messageConverter.toMessage(any(Object.clreplaced), any(MessageProperties.clreplaced))).willReturn(message);
    given(proceedingJoinPoint.proceed(args)).willThrow(new RuntimeException());
    try {
        // when
        aspect.traceRabbitSend(proceedingJoinPoint, exchange, ROUTING_KEY, message);
    } catch (RuntimeException e) {
        // then
        verify(proceedingJoinPoint).getArgs();
        verify(proceedingJoinPoint).proceed(args);
        throw e;
    }
}

@Test
public void testPut() {
    // given
    MessageProperties messageProperties = new MessageProperties();
    RabbitMqInjectAdapter carrier = new RabbitMqInjectAdapter(messageProperties);
    String key = "myKey";
    String value = "myValue";
    // when
    carrier.put(key, value);
    // then
    replacedertThat(messageProperties.getHeaders().get(key)).isEqualTo(value);
}

public void onSend(MessageProperties messageProperties, String exchange, String routingKey, Span span) {
    Tags.COMPONENT.set(span, RabbitMqTracingTags.RABBITMQ.getKey());
    RabbitMqTracingTags.EXCHANGE.set(span, exchange);
    RabbitMqTracingTags.MESSAGE_ID.set(span, messageProperties.getMessageId());
    RabbitMqTracingTags.ROUTING_KEY.set(span, routingKey);
}

private Message doBefore(String exchange, String routingKey, Object message) {
    Message convertedMessage = convertMessageIfNecessary(message);
    final MessageProperties messageProperties = convertedMessage.getMessageProperties();
    // Add tracing header to outgoing AMQP message
    // so that new spans created on the AMQP message consumer side could be replacedociated with span of current trace
    scope = RabbitMqTracingUtils.buildSendSpan(tracer, messageProperties);
    tracer.inject(tracer.scopeManager().activeSpan().context(), Format.Builtin.TEXT_MAP, new RabbitMqInjectAdapter(messageProperties));
    // Add AMQP related tags to tracing span
    spanDecorator.onSend(messageProperties, exchange, routingKey, tracer.scopeManager().activeSpan());
    return convertedMessage;
}

public void ping(final String tenant, final String correlationId) {
    final MessageProperties messageProperties = new MessageProperties();
    messageProperties.getHeaders().put(MessageHeaderKey.TENANT, tenant);
    messageProperties.getHeaders().put(MessageHeaderKey.TYPE, MessageType.PING.toString());
    messageProperties.setCorrelationId(correlationId);
    messageProperties.setReplyTo(amqpProperties.getSenderForSpExchange());
    messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
    sendMessage(spExchange, new Message(null, messageProperties));
}

private Message createUpdateResultMessage(final SimulatedUpdate cacheValue, final DmfActionStatus actionStatus, final List<String> updateResultMessages) {
    final MessageProperties messageProperties = new MessageProperties();
    final Map<String, Object> headers = messageProperties.getHeaders();
    final DmfActionUpdateStatus actionUpdateStatus = new DmfActionUpdateStatus(cacheValue.getActionId(), actionStatus);
    headers.put(MessageHeaderKey.TYPE, MessageType.EVENT.name());
    headers.put(MessageHeaderKey.TENANT, cacheValue.getTenant());
    headers.put(MessageHeaderKey.TOPIC, EventTopic.UPDATE_ACTION_STATUS.name());
    headers.put(MessageHeaderKey.CONTENT_TYPE, MessageProperties.CONTENT_TYPE_JSON);
    actionUpdateStatus.addMessage(updateResultMessages);
    return convertMessage(actionUpdateStatus, messageProperties);
}

private Message thingCreatedMessage(final String tenant, final String targetId) {
    final MessageProperties messagePropertiesForSP = new MessageProperties();
    messagePropertiesForSP.setHeader(MessageHeaderKey.TYPE, MessageType.THING_CREATED.name());
    messagePropertiesForSP.setHeader(MessageHeaderKey.TENANT, tenant);
    messagePropertiesForSP.setHeader(MessageHeaderKey.THING_ID, targetId);
    messagePropertiesForSP.setHeader(MessageHeaderKey.SENDER, "simulator");
    messagePropertiesForSP.setContentType(MessageProperties.CONTENT_TYPE_JSON);
    messagePropertiesForSP.setReplyTo(amqpProperties.getSenderForSpExchange());
    return new Message(null, messagePropertiesForSP);
}

private MessageProperties createAttributeUpdateMessage(final String tenant, final String targetId) {
    final MessageProperties messagePropertiesForSP = new MessageProperties();
    messagePropertiesForSP.setHeader(MessageHeaderKey.TYPE, MessageType.EVENT.name());
    messagePropertiesForSP.setHeader(MessageHeaderKey.TOPIC, EventTopic.UPDATE_ATTRIBUTES);
    messagePropertiesForSP.setHeader(MessageHeaderKey.TENANT, tenant);
    messagePropertiesForSP.setHeader(MessageHeaderKey.THING_ID, targetId);
    messagePropertiesForSP.setContentType(MessageProperties.CONTENT_TYPE_JSON);
    messagePropertiesForSP.setReplyTo(amqpProperties.getSenderForSpExchange());
    return messagePropertiesForSP;
}

/**
 * Create a action status message.
 *
 * @param actionStatus
 *            the ActionStatus
 * @param actionMessage
 *            the message description
 * @param actionId
 *            the action id
 * @param cacheValue
 *            the cacheValue value
 */
private Message createActionStatusMessage(final String tenant, final DmfActionStatus actionStatus, final List<String> updateResultMessages, final Long actionId) {
    final MessageProperties messageProperties = new MessageProperties();
    final Map<String, Object> headers = messageProperties.getHeaders();
    final DmfActionUpdateStatus actionUpdateStatus = new DmfActionUpdateStatus(actionId, actionStatus);
    headers.put(MessageHeaderKey.TYPE, MessageType.EVENT.name());
    headers.put(MessageHeaderKey.TENANT, tenant);
    headers.put(MessageHeaderKey.TOPIC, EventTopic.UPDATE_ACTION_STATUS.name());
    headers.put(MessageHeaderKey.CONTENT_TYPE, MessageProperties.CONTENT_TYPE_JSON);
    actionUpdateStatus.addMessage(updateResultMessages);
    return convertMessage(actionUpdateStatus, messageProperties);
}

@Override
public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) {
    RabbitTemplate rabbitTemplate = this.templateFuture.get();
    MetricReport report = new MetricReport();
    Map<String, Object> data = new HashMap<>();
    report.setMetrics(data);
    // we note that in MetricRegistry all data persisted into single map, and therefore it's keys unique per registry
    data.putAll(gauges);
    data.putAll(counters);
    data.putAll(histograms);
    data.putAll(meters);
    data.putAll(timers);
    try {
        MessageProperties messageProperties = new MessageProperties();
        processMessageProperties(messageProperties);
        // it's not good, but it simply
        report.setApplication(messageProperties.getAppId());
        report.setApplicationVersion(AppInfo.getApplicationVersion());
        report.setHost((String) messageProperties.getHeaders().get(MessageHeaders.HOST));
        byte[] body = objectMapper.writeValueAsBytes(report);
        Message message = new Message(body, messageProperties);
        rabbitTemplate.send(exchangeName, routingKey, message);
    } catch (JsonProcessingException e) {
        log.error("on serialize metrics report", e);
    }
}

private void processMessageProperties(MessageProperties messageProperties) {
    messageProperties.setContentType(MessageProperties.CONTENT_TYPE_JSON);
    messageProperties.setContentEncoding("UTF-8");
    messageProperties.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT);
    messageProperties.setHeader(MessageHeaders.HOST, OSUtils.getHostName());
    messageProperties.setAppId(AppInfo.getApplicationName());
    if (this.messagePropertiesCallback != null) {
        this.messagePropertiesCallback.call(messageProperties);
    }
}

@Override
public AMQP.BasicProperties fromMessageProperties(MessageProperties source, String charset) {
    final TraceFilterConfig filterConfiguration = backend.getConfiguration(profile);
    if (!backend.isEmpty() && filterConfiguration.shouldProcessContext(TraceFilterConfig.Channel.AsyncDispatch)) {
        final Map<String, String> filteredParams = filterConfiguration.filterDeniedParams(backend.copyToMap(), TraceFilterConfig.Channel.AsyncDispatch);
        source.getHeaders().put(Builder.TPIC_HEADER, filteredParams);
    }
    return super.fromMessageProperties(source, charset);
}

@Override
public MessageProperties toMessageProperties(AMQP.BasicProperties source, Envelope envelope, String charset) {
    final MessageProperties messageProperties = super.toMessageProperties(source, envelope, charset);
    final TraceFilterConfig filterConfiguration = backend.getConfiguration(profile);
    if (filterConfiguration.shouldProcessContext(TraceFilterConfig.Channel.AsyncProcess)) {
        final Map<String, String> TraceContextMap = transformToTraceContextMap((Map<String, ?>) messageProperties.getHeaders().get(Builder.TPIC_HEADER));
        if (TraceContextMap != null && !TraceContextMap.isEmpty()) {
            backend.putAll(filterConfiguration.filterDeniedParams(TraceContextMap, TraceFilterConfig.Channel.AsyncProcess));
        }
    }
    org.aoju.bus.tracer.Builder.generateInvocationIdIfNecessary(backend);
    return messageProperties;
}

public void send(String message) {
    MessageProperties properties = new MessageProperties();
    properties.setHeader("token", "abc123");
    Message amqpMessage = new Message(message.getBytes(), properties);
    amqpTemplate.convertAndSend(RabbitMQHeaderConfig.HEAD_EXCHAGE, "", amqpMessage);
}

See More Examples