RabbitMQ讲解与整合

| Single active consumer | x-single-active-consumer | 配置队列是否只允许单个消费者消费消息。当设置了x-single-active-consumer参数时，表示队列只允许有一个消费者活跃地消费消息，其他消费者将被阻塞，直到当前的消费者停止消费或断开连接 |
| Dead letter exchange | x-dead-letter-exchange | 设置队列中的死信消息转发到的交换机名称。当消息成为死信时，将会被转发到指定的交换机 |
| Dead letter routing key | x-dead-letter-routing-key | 设置死信消息转发时的路由键。死信消息将通过指定的路由键转发到目标交换机 |
| Max length | x-max-length | 设置队列的最大长度，即队列中消息的最大数量。当队列中消息数量达到设定的最大长度后，新消息将无法入队 |
| Max length bytes | x-max-length-bytes | 设置队列消息的最大总字节数。当队列中消息的总字节数达到设定的最大值后，新消息将无法入队 |
| Leader locator | x-queue-leader-locator | 配置队列的领导者（Leader）定位器，集群中使用 |

SpringBoot整合

引入依赖

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

配置数据源

spring: 
  rabbitmq:
    addresses: xxx.xxx.xx.xx:5672
    username: admin
    password: xxxxxx
    virtual-host: /

配置交换机和队列

@Component
public class RabbitMqConfig {
	// 定义交换机名称
    public static final String FANOUT\_EXCHANGE = "fanout.test";
    @Bean(name = FANOUT\_EXCHANGE)
    public FanoutExchange fanoutExchange() {
    	// 交换机类型按需创建，这里用的是Fanout，发布订阅，绑定在该交换机下的队列都会收到消息
    	// 参数2：是否持久化
    	// 参数3：是否自动删除
        return new FanoutExchange(FANOUT\_EXCHANGE, true, false);
    }
	
	// 定义队列
    public static final String FANOUT\_QUEUE1 = "queue1";
    @Bean(name = FANOUT\_QUEUE1)
    public Queue fanoutQueue1() {
    	// 后三个不写也行，这是默认值
    	// 参数2：是否持久化数据到磁盘（防止意外关闭数据丢失）
    	// 参数3：是否具有排他性
    	// 参数4：队列不再使用时是否自动删除
        return new Queue(FANOUT\_QUEUE1, true, false, false);
    }
	public static final String FANOUT\_QUEUE2 = "queue2";
    @Bean(name = FANOUT\_QUEUE2)
    public Queue fanoutQueue2() {
        return new Queue(FANOUT\_QUEUE2, true, false, false);
    }
		
    @Bean
    public Binding bindingSimpleQueue1(@Qualifier(FANOUT\_QUEUE1) Queue fanoutQueue1,
                                       @Qualifier(FANOUT\_EXCHANGE) FanoutExchange fanoutExchange) {
        // 将交换机和队列绑定
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }
    @Bean
    public Binding bindingSimpleQueue2(@Qualifier(FANOUT\_QUEUE2) Queue fanoutQueue2,
                                       @Qualifier(FANOUT\_EXCHANGE) FanoutExchange fanoutExchange) {
        // 将交换机和队列绑定
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}

测试发一条消息到队列

@SpringBootTest(classes = TemplateApplication.class)
public class RabbitMQTest {

    @Autowired
    RabbitMessagingTemplate rabbitMessagingTemplate;

    @Test
    public void testSent(){
		//指定交换机->指定队列（因为创建的交换机是FanoutExchange，所以绑定该交换机的队列都会收到一条消息）
        rabbitMessagingTemplate.convertAndSend("fanout.test","发送数据到FanoutExchange");
    	// 如果创建队列不绑定交换机和路由键，那么实际上会有默认的交换机和路由键，均为空，直接将消息发送给队列，队列名则和路由键保持一致，仍然可以成功发送消息。
    }
}

测试接收队列消息

写个监听类接收消息：

@Component
public class RabbitMqListenter {
    @RabbitListener(queues = {RabbitMqConfig.FANOUT\_QUEUE1,RabbitMqConfig.FANOUT\_QUEUE2})
    public void reciveLogAll(String msg) throws Exception {
        System.out.println("消费到数据：" + msg);
    }
}

-------------基础的使用到这里就结束了-------------

拓展事项

rabbitMqPusher

自己封装一个更加方便使用的发送工具，可有可无，其中可以使用RabbitMessagingTemplate和RabbitTemplate，RabbitMessagingTemplate和RabbitTemplate都是Spring AMQP提供的用于与RabbitMQ进行交互的工具类如果只是简单使用，那么RabbitMessagingTemplate就够用了，如果需要更精细的控制，可以选择使用RabbitTemplate。

，但它们在使用方式和功能上有一些不同点：

RabbitMessagingTemplate：

RabbitMessagingTemplate是MessagingTemplate的子类，用于在Spring应用程序中发送和接收消息。
它提供了一种更高级别的抽象，使得在Spring框架中更容易使用消息发送和接收的功能。
可以直接与Spring的消息通道（MessageChannel）集成，方便进行消息的发送和接收。

RabbitTemplate：

RabbitTemplate是Spring AMQP提供的用于与RabbitMQ进行交互的核心类，提供了丰富的方法来发送和接收消息。
它是一个强大而灵活的工具，可以直接与RabbitMQ的交互进行细粒度的控制。
可以设置消息的属性、监听发送确认、接收确认等功能，更加灵活地处理消息发送和接收的细节。

public interface RabbitMqPublish {

    void send(String quene, String message);

    void send(String exchange, String routingKey, String message);

    void send(String quene, String message, Integer expiration);

    void send(String exchange, String routingKey, String message, Integer expiration);

}

package com.template.rabbitmq.producer.impl;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component
@Slf4j
public class RabbitMqPublishImpl implements RabbitMqPublish {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /\*\*
 \* 发送消息
 \* @param quene 队列名称 或 交换机名称
 \* @param message 消息内容
 \*/
    public void send(String quene, String message) {
        rabbitTemplate.send(quene, MessageBuilder.withBody(message.getBytes()).build());
        log.info("发送消息---> quene:{} ---> message:{}", message, quene);
    }

    /\*\*
 \* 直接发送消息到队列
 \* 超过有效期丢弃
 \*
 \* @param quene 队列名称
 \* @param message 消息内容
 \* @param expiration 有效期(毫秒)
 \*/
    public void send(String quene, String message, Integer expiration) {
        rabbitTemplate.send(quene, MessageBuilder.withBody(message.getBytes()).setExpiration(String.valueOf(expiration)).build());
        log.info("发送消息---> quene:{} ---> message:{} ---> expiration:{}", quene, message, expiration);
    }


    /\*\*
 \* 发送消息
 \* 超过有效期丢弃
 \*
 \* @param exchange 交换机名称
 \* @param routingKey 路由键
 \* @param message 消息内容
 \* @param expiration 有效期(毫秒)
 \*/
    public void send(String exchange, String routingKey, String message, Integer expiration) {
        rabbitTemplate.send(exchange, routingKey, MessageBuilder.withBody(message.getBytes()).setExpiration(String.valueOf(expiration)).build());
        log.info("发送消息---> exchange:{} ---> routingKey:{} ---> message:{} ---> expiration:{}", exchange, routingKey, message, expiration);
    }

    /\*\*
 \* 发送消息
 \*
 \* @param exchange 交换机名称
 \* @param routingKey 路由键
 \* @param message 消息内容
 \*/
    public void send(String exchange, String routingKey, String message) {
        rabbitTemplate.send(exchange, routingKey, MessageBuilder.withBody(message.getBytes()).build());
        log.info("发送消息---> exchange:{} ---> routingKey:{} ---> message:{}", exchange, routingKey, message);
    }


}

在RabbitMQ中，如果队列没有设置过期时间（即没有声明x-message-ttl属性），那么即使在发送消息时设置了消息的过期时间也会失效。消息的过期时间只有在队列设置了过期时间的情况下才会生效。
实测以上列代码的方式直接对消息设置有效期是生效的。

死信队列

和普通队列一样，只不过是对其他队列进行配置，将过期的消息路由到死信队列中。
创建死信交换机和死信路由

	// 配置交换机的文件中继续增加配置
	public static final String DIRECT\_GP\_DEAD\_LETTER\_EXCHANGE = "DIRECT\_GP\_DEAD\_LETTER\_EXCHANGE";
    public static final String DIRECT\_GP\_DEAD\_LETTER\_QUEUE = "DIRECT\_GP\_DEAD\_LETTER\_QUEUE";
    @Bean(DIRECT\_GP\_DEAD\_LETTER\_EXCHANGE)
    public DirectExchangedirectDeadLetterExchange() {
        return new DirectExchange(DIRECT\_GP\_DEAD\_LETTER\_EXCHANGE, true, false, new HashMap<>());
    }
    @Bean(DIRECT\_GP\_DEAD\_LETTER\_QUEUE)
    public Queue directDeadLetterQueue() {
        return new Queue(DIRECT\_GP\_DEAD\_LETTER\_QUEUE, true, false, false, new HashMap<>());
    }

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数大数据工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上大数据开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注大数据获取）

143281)]
[外链图片转存中…(img-ti2OdTez-1712859143281)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上大数据开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注大数据获取）
[外链图片转存中…(img-UaydFIQd-1712859143282)]