Rabbit配置，监听与推送方法

会写BUG的鱼

已于 2023-07-04 15:30:16 修改

阅读量205

点赞数

文章标签：后端 java

于 2023-07-04 15:18:29 首次发布

本文链接：https://blog.csdn.net/IGIli/article/details/131535731

版权



import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**

 *类说明： Rabbit配置，申明队列交换器
 */
@Configuration
@Slf4j
public class RabbitConfig {

    @Value("${spring.rabbitmq.host}")
    private String addresses;

    @Value("${spring.rabbitmq.port}")
    private String port;

    @Value("${spring.rabbitmq.username}")
    private String username;

    @Value("${spring.rabbitmq.password}")
    private String password;

    @Value("${spring.rabbitmq.virtual-host}")
    private String virtualHost;

    @Value("${spring.rabbitmq.publisher-confirms}")
    private boolean publisherConfirms;



    /**
     *  连接工厂
     */
    @Bean
    public ConnectionFactory connectionFactory() {

        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(addresses+":"+port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        //TODO 消息发送确认
        /** 如果要进行消息回调，则这里必须要设置为true */
        connectionFactory.setPublisherConfirms(publisherConfirms);
        return connectionFactory;
    }
    //TODO rabbitAdmin类封装对RabbitMQ的管理操作
    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory){
        return new RabbitAdmin(connectionFactory);
    }

    //TODO 使用Template
    @Bean
    public RabbitTemplate newRabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        //TODO 失败通知
        template.setMandatory(true);
        //TODO 发送方确认
        template.setConfirmCallback(confirmCallback());
        //TODO 失败回调
        template.setReturnCallback(returnCallback());
        return template;
    }

    //===============生产者发送确认==========
    @Bean
    public RabbitTemplate.ConfirmCallback confirmCallback(){
        return new RabbitTemplate.ConfirmCallback(){

            @Override
            public void confirm(CorrelationData correlationData,
                                boolean ack, String cause) {
                if (ack) {
                    log.info("发送者确认发送给mq成功");
                } else {
                    //处理失败的消息
                    log.error("发送者确认发送给mq失败，尝试重发");
                    log.info("发送者发送给mq失败,考虑重发:"+cause);
                }
            }
        };
    }
    //===============失败通知==========
    @Bean
    public RabbitTemplate.ReturnCallback returnCallback(){
        return new RabbitTemplate.ReturnCallback(){

            @Override
            public void returnedMessage(Message message,
                                        int replyCode,
                                        String replyText,
                                        String exchange,
                                        String routingKey) {
                log.warn("无法路由的消息，需要考虑另外处理!");
                log.warn("Returned replyText："+replyText);
                log.warn("Returned exchange："+exchange);
                log.warn("Returned routingKey："+routingKey);
                String msgJson  = new String(message.getBody());
                log.warn("Returned Message："+msgJson);
            }
        };
    }

}


/**

 *类说明： Rabbit配置，申明队列交换器
 */
@Configuration
@Slf4j
public class MqInfoConfig {



    //===============以下是验证Topic Exchange==========
    @Bean
    public Queue startGasEvent(){
        return new Queue("QUEUE_GAS_EVENT_START");
    }

   
    /** 声明交换器 */
    @Bean
    TopicExchange gasEventExchange() {
        return new TopicExchange("EXCHANGE_GAS_EVENT");
    }

    
    @Bean
    Binding bindingExchangeStartResultEvent(Queue startResultEvent,TopicExchange gasEventExchange){
        return BindingBuilder.bind(startResultEvent).to(gasEventExchange).with("ROUTING_KEY_GAS_EVENT_START_RESULT");
    }





}



/**

 * @description mq信息接收
 * @date 2023/6/6 16:53
 */
@Component
@Slf4j
public class GasEventInfoHandler {


    @RabbitHandler
    @RabbitListener(queues = MqInfoConstant.QUEUE_GAS_EVENT_START)
    public void processMqReg(String msg) {
        log.info("事件上报信息：{}", msg);
       

}


    public int sendEndEvent(String process) {
        try {
            log.info("发送消息内容：{}",JSONObject.toJSONString(pushMag));
            rabbitTemplate.convertAndSend(MqInfoConstant.EXCHANGE_GAS_EVENT, MqInfoConstant.ROUTING_KEY_GAS_EVENT_END, process);
            return 1;
        }catch (Exception e){
            log.error("发送事件消息异常：{}", e.toString());
            return 0;
        }
    }

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>${mq.version}</version>
        </dependency>