springboot RabbitMq json

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

import org.springframework.amqp.rabbit.annotation.RabbitListenerConfigurer;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistrar;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.converter.MappingJackson2MessageConverter;
import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;
import org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory;

/**
 * 使用json格式传送消息
 */
@Configuration
@ConditionalOnClass(RabbitTemplate.class)
public class RabbitJsonConfigurer implements RabbitListenerConfigurer {


    @Bean
    public RabbitTemplate rabbitTemplate(final ConnectionFactory connectionFactory) {
        final RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(producerJackson2MessageConverter());
        return rabbitTemplate;
    }

    @Bean
    public Jackson2JsonMessageConverter producerJackson2MessageConverter() {
        return new Jackson2JsonMessageConverter();
    }

    @Override
    public void configureRabbitListeners(RabbitListenerEndpointRegistrar registrar) {
        registrar.setMessageHandlerMethodFactory(messageHandlerMethodFactory());
    }

    @Bean
    MessageHandlerMethodFactory messageHandlerMethodFactory() {
        DefaultMessageHandlerMethodFactory messageHandlerMethodFactory = new DefaultMessageHandlerMethodFactory();
        messageHandlerMethodFactory.setMessageConverter(consumerJackson2MessageConverter());
        return messageHandlerMethodFactory;
    }

    @Bean
    public MappingJackson2MessageConverter consumerJackson2MessageConverter() {
        return new MappingJackson2MessageConverter();
    }
}

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMqConfig {

    /**
     * 家人实名认证交换机名称
     */
    public static final String FAMILY_MEMBER_REAL_NAME_AUTH = "gmHealthPatientCenter_familyMemberRealNameAuth";

    @Bean
    public TopicExchange familyMemberRealNameAuthTopicExchange() {
        return new TopicExchange(FAMILY_MEMBER_REAL_NAME_AUTH);
    }

//    @Bean
//    public Queue familyMemberRealNameAuthTestQueue() {
//        return new Queue("familyMemberRealNameAuthTest");
//    }

//    @Bean
//    Binding bindingExchangeFamilyMemberRealNameAuth(Queue familyMemberRealNameAuthTestQueue, TopicExchange familyMemberRealNameAuthTopicExchange) {
//        return BindingBuilder.bind(familyMemberRealNameAuthTestQueue).to(familyMemberRealNameAuthTopicExchange).with("*");
//    }
}

import cn.hutool.core.lang.UUID;
import com.wjj.application.healthpatient.infrastructure.config.RabbitMqConfig;
import com.wjj.common.common.Response;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;

@Configuration
@Slf4j
@RestController
public class TempTest1 implements ApplicationListener {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private RabbitTemplateCallback rabbitTemplateCallback;

    @RequestMapping("t1")
    public Response t1() {
        String uuid = UUID.fastUUID().toString();
        HashMap<String, Object> map = new HashMap<>();
        map.put("k1", RandomStringUtils.random(10, true, true));
        map.put("k2", RandomStringUtils.random(10, true, true));
        map.put("k3", "汉字测试");
        map.put("uuid",uuid);
        MessagePostProcessor messagePostProcessor = message -> {
            message.getMessageProperties().setMessageId(uuid);
            return message;
        };
        rabbitTemplate.convertAndSend(RabbitMqConfig.FAMILY_MEMBER_REAL_NAME_AUTH, "routingKey-todo", map, messagePostProcessor,new CorrelationData(uuid));
        return Response.ok(map);
    }

    @RabbitListener(queues = {"familyMemberRealNameAuthTest"}, concurrency = "1")
    public void processMessage(Message message) {
        log.info("收到消息 messageId:{} msg:{}", message.getMessageProperties().getMessageId(), new String(message.getBody()));
    }


    @Component
    public static class RabbitTemplateCallback implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnCallback {
        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            if (ack) {
                // 消息发送成功
                System.out.println("Message sent successfully: " + correlationData.getId());
            } else {
                // 消息发送失败
                System.out.println("Message sent failed: " + cause);
            }
        }

        @Override
        public void returnedMessage(org.springframework.amqp.core.Message message, int replyCode, String replyText,
                                    String exchange, String routingKey) {
            // 消息被退回 当消息发送给Exchange后，Exchange路由到Queue失败时处理
            System.out.println("Message returned: " + message.getBody());
        }
    }

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        //spring.rabbitmq.publisher-confirm-type=correlated
        //spring.rabbitmq.publisher-returns=true
        this.rabbitTemplate.setConfirmCallback(rabbitTemplateCallback);
        this.rabbitTemplate.setReturnCallback(rabbitTemplateCallback);
    }
}