2024年MQ笔记-MQ相关知识

      multiplier: 2 #间隔因子 2 4 8 16

除了使用yml配置文件自动装配外还可以手动注入Bean来配置，一般需要特殊配置时使用手动注入

/**
 * 手动创建工厂连接 覆盖配置文件自动配置
 *
 * @return
 */
@Bean
public ConnectionFactory connectionFactory() {
    CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
    connectionFactory.setHost(rabbitMQProperties.getHost());
    connectionFactory.setVirtualHost(rabbitMQProperties.getVirtualHost());
    connectionFactory.setPort(rabbitMQProperties.getPort());
    connectionFactory.setUsername(rabbitMQProperties.getUsername());
    connectionFactory.setPassword(rabbitMQProperties.getPassword());
    connectionFactory.setPublisherReturns(rabbitMQProperties.getPublisherReturns());
    if (StrUtil.isBlank(rabbitMQProperties.getPublisherConfirmType())
            || CachingConnectionFactory.ConfirmType.CORRELATED.name().equals(rabbitMQProperties.getPublisherConfirmType().toUpperCase())) {
        connectionFactory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);
    }
    if (CachingConnectionFactory.ConfirmType.SIMPLE.name().equals(rabbitMQProperties.getPublisherConfirmType().toUpperCase())) {
        connectionFactory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.SIMPLE);
    }
    if (CachingConnectionFactory.ConfirmType.NONE.name().equals(rabbitMQProperties.getPublisherConfirmType().toUpperCase())) {
        connectionFactory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.NONE);
    }
    return connectionFactory;
}

@Bean
public SimpleRabbitListenerContainerFactory myRabbitListenerContainerFactory() {
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    factory.setConnectionFactory(connectionFactory());
    factory.setMaxConcurrentConsumers(5);
    factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
    return factory;
}
/**
 * rabbitmq的模板配置
 *
 * @return
 */
@Bean
public RabbitTemplate rabbitTemplate() {
    rabbitTemplate = new RabbitTemplate(connectionFactory());
    // 发送到交换机：消息确认
    rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
        log.info("RabbitMQ-发送到交换机:::Confirm callback id:{},ack:{},cause:{}", correlationData, ack, cause);
        if (ack) {
            log.info("RabbitMQ-发送到交换机:::成功");
        } else {
            log.info("RabbitMQ-发送到交换机:::失败-{}", cause);
        }
    });
    // 交换机到队列：这个参数为true表示如果发送消息到了RabbitMq，没有对应该消息的队列。那么会将消息返回给生产者，此时仍然会发送ack确认消息，否则丢弃消息
    rabbitTemplate.setMandatory(true);
    // 交换机到队列：Mandatory为true时设置broker消息返回
    rabbitTemplate.setReturnsCallback((returnedMessage) -> {
        log.info("RabbitMQ-交换机到队列退回:::return callback message：{},code:{},text:{},exchange:{},routingKey:{}",
                returnedMessage.getMessage(), returnedMessage.getReplyCode(), returnedMessage.getReplyText(),
                returnedMessage.getExchange(), returnedMessage.getRoutingKey());
    });

// rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey)
// -> log.info(“return callback message：{},code:{},text:{}”, message, replyCode, replyText));
}
#使用yml自动配置时 配置rabbitmq的模板
@Autowired
private RabbitTemplate rabbitTemplate;
@PostConstruct
public void init() {
// 发送到交换机：消息确认
rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
log.info(“RabbitMQ-发送到交换机:::Confirm callback id:{},ack:{},cause:{}”, correlationData, ack, cause);
if (ack) {
log.info(“RabbitMQ-发送到交换机:::成功”);
} else {
log.info(“RabbitMQ-发送到交换机:::失败-{}”, cause);
}
});
// 交换机到队列：这个参数为true表示如果发送消息到了RabbitMq，没有对应该消息的队列。那么会将消息返回给生产者，此时仍然会发送ack确认消息，否则丢弃消息
rabbitTemplate.setMandatory(true);
// 交换机到队列：Mandatory为true时设置broker消息返回
rabbitTemplate.setReturnsCallback((returnedMessage) -> {
log.info(“RabbitMQ-交换机到队列退回:::return callback message：{},code:{},text:{},exchange:{},routingKey:{}”,
returnedMessage.getMessage(), returnedMessage.getReplyCode(), returnedMessage.getReplyText(),
returnedMessage.getExchange(), returnedMessage.getRoutingKey());
});
// rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey)
// -> log.info(“return callback message：{},code:{},text:{}”, message, replyCode, replyText));
}

     创建队列绑定交换机

#配置文件方式
// 创建死信队列
@Bean
public Queue createDeadQueue() {
return new Queue(MqConstants.DEADQUEUE, true);
}
// 创建死信交换机
@Bean
public DirectExchange createDeadExchange() {
return new DirectExchange(MqConstants.DEADEXCHAGENAME, true, false);
}
// 死信交换机 死信队列 绑定
@Bean
public Binding createDeadBinding() {
return BindingBuilder.bind(createDeadQueue()).to(createDeadExchange()).with(MqConstants.DEADQUEUE);
}
// 声明direct类型的Exchange
@Bean
public Exchange directExchange() {
return new DirectExchange(MqConstants.EXCHAGENAME, true, false);
}
// 声明和direct类型的Exchange绑定的queue
@Bean
public List queues() {
List queueList = new ArrayList<>();
List queueNames = Collections.singletonList(MqConstants.DEFAULTQUEUE);
// 设置死信队列
HashMap<String, Object> map = new HashMap<String, Object>();
map.put(“x-dead-letter-exchange”, MqConstants.DEADEXCHAGENAME);
map.put(“x-dead-letter-routing-key”, MqConstants.DEADQUEUE);
for (String queueName : queueNames) {
queueList.add(new Queue(queueName, true, false, false, map));
}
return queueList;
}
// direct类型的Exchange绑定queue
@Bean
public List bindings() {
List bindingList = new ArrayList<>();
for (Queue queue : queues()) {
bindingList.add(BindingBuilder.bind(queue).
to(directExchange()).with(queue.getName()).noargs());
}
return bindingList;
}
// 声明延迟交换机使用自定义的交换机CustomExchange，需要Mq安装rabbitmq-delayed-message-exchange插件参考开头安装环境
@Bean
public CustomExchange delayExchange() {
Map<String, Object> args = new HashMap<>(1);
// 这里使用直连方式的路由，如果想使用不同的路由行为，可以修改，如 topic
args.put(“x-delayed-type”, “direct”);
return new CustomExchange(MqConstants.DELAYEXCHAGENAME, “x-delayed-message”, true, false, args);
}
// 声明和延时类型的Exchange绑定的queue
@Bean
public List delayQueues() {
List queueList = new ArrayList<>();
List queueNames = Collections.singletonList(MqConstants.ORDERTIMEOUTQUEUE);
// 设置死信队列
HashMap<String, Object> map = new HashMap<String, Object>();
map.put(“x-dead-letter-exchange”, MqConstants.DEADEXCHAGENAME);
map.put(“x-dead-letter-routing-key”, MqConstants.DEADQUEUE);
for (String queueName : queueNames) {
queueList.add(new Queue(queueName, true, false, false, map));
}
return queueList;
}
// 延时类型的Exchange绑定queue
@Bean
public List delayBindings() {
List bindingList = new ArrayList<>();
for (Queue queue : delayQueues()) {
bindingList.add(BindingBuilder.bind(queue).
to(delayExchange()).with(queue.getName()).noargs());
}
return bindingList;
}
/**
* 声明Topic交换机 用于广播消息如果本项目不消费可以不创建队列和绑定
*
* @return
*/
@Bean
public TopicExchange runtimeTopicexchange() {
return new TopicExchange(MqConstants.RUNTIMETOPICEXCHAGENAME, true, false);
}
# 配置文件方式声明的Exchange和queue一般会在有监听时(注解)才被创建到Mq，如果消费者和生产者不在一个项目那么消费者启动时无法订阅消息，如果想项目启动就创建可以使用rabbitAdmin，或者不使用配置文件方式使用声明式注解方式来创建消费者
@Autowired
RabbitAdmin rabbitAdmin;
// 创建初始化RabbitAdmin对象
@Bean
public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
// 只有设置为 true，spring 才会加载 RabbitAdmin 这个类
rabbitAdmin.setAutoStartup(true);
return rabbitAdmin;
}
// 创建交换机和对列 解决懒加载 启动时不自动创建队列和交换机问题
@Bean
public void createExchangeQueue() {
rabbitAdmin.declareExchange(createDeadExchange());
rabbitAdmin.declareQueue(createDeadQueue());
rabbitAdmin.declareBinding(createDeadBinding());

    rabbitAdmin.declareExchange(directExchange());
    for (Queue item : queues()) {
        rabbitAdmin.declareQueue(item);
    }
    for (Queue item : delayQueues()) {
        rabbitAdmin.declareQueue(item);
    }

    for (Binding item : bindings()) {
        rabbitAdmin.declareBinding(item);
    }
    for (Binding item : delayBindings()) {
        rabbitAdmin.declareBinding(item);
    }
    rabbitAdmin.declareExchange(runtimeTopicexchange());
}

声明式注解方式

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "test",durable = "true", declare = "true", arguments = {}),

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！