【消息中间件/笔记】3个分布式消息中间件之一Rabbitmq（一）

最新推荐文章于 2025-10-21 16:59:56 发布
原创 最新推荐文章于 2025-10-21 16:59:56 发布 · 938 阅读 · 30 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#分布式 #笔记 #rabbitmq

主流MQ产品

  • RabbitMQ
    • 优点
      • 消息可靠性高
      • 功能全面
    • 缺点
      • 吞吐量较低
      • 消息积压会影响性能
      • erlang语言比较小众
    • 适用环境
      • 企业内部系统调用
  • kafka
    • 优点
      • 吞吐量大
      • 性能好
      • 技术生态完整
    • 缺点
      • 功能单一
    • 适用环境
      • 分布式日志收集
      • 大数据采集
  • RocketMQ
    • 优点
      • 高吞吐量
      • 高性能
      • 高可用
      • 高级功能非常全
    • 缺点
      • 技术生态相对没那么完整
    • 适用环境
      • 几乎全场景
      • 尤其适合金融场景

RabbitMQ

基本概念

在这里插入图片描述

交换机

队列

  • 类型
    • Classic：经典队列是默认类型，灵活性强，大部分功能可以通过参数进行设置，在特定情况下消息会丢失。
    • Quorum：适合用于集群使用，一条消息会同步到集群节点上，有消息备份，且主节点故障需要重新选举。增加了毒消息的处理，可通过x-delivery-limit来判断是否为毒消息后进行删除。队列也有一定策略，没有消息是会自动删除。
    • Stream：将消息数据存储到了日志文件中，解决了传统消息挤压导致性能下降的问题，但他的刷盘持久化机制需要靠操作系统来进行刷盘，安全性很差。
  • 一系列参数
    • duration：是否持久化，即rabbitmq重启系统可以到磁盘获取之前未消费的数据
    • auto Delete：当前队列没有消费者连接会自动删除
    • dead letter exchange：设置死信交换机，即数据没有应答时会将消息转到死信队列中，可用于做延迟队列。
    • auto expire：在一定时间内，队列未被使用，就会自动删除

交换机

  • 类型
    • direct：绑定队列，可通过routingKey完全匹配来给指定的队列传递数据。
    • fanout：当交换机接收到消息，他会给绑定的所有队列都传递一条消息。
    • topic：支持routingKey通配符匹配，即模糊匹配，*一个单词，#0-n个单词。
    • headers：与routingkey不同，他可以通过object对象来进行路由匹配，any是匹配一个键值对即可发送消息，all需要所以键值对都匹配才可以发送消息。
  • 一系列参数
    • alternate exchange：备用交换机，当消息不能被路由时，那么该不可用消息会转发到备用交换机上。

基础开发模型

依赖

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

原生API代码写法

消费者
// 推模式
public class Customer {
    private static final String HOST="127.0.0.1";
    private static final Integer PORT=5672;
    private static final String USERNAME="guest";
    private static final String PASSWORD="guest";
    private static final String VIRTUAL_HOST="/mirror";
    private static final String QUEUE_NAME = "test2";
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建一个连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(HOST);
        factory.setPort(PORT);
        factory.setUsername(USERNAME);
        factory.setPassword(PASSWORD);
        factory.setVirtualHost(VIRTUAL_HOST);

        // 获取连接
        Connection connection = factory.newConnection();
        // 创建通道 创建单个通道不需要传参
        Channel channel = connection.createChannel();
        // 创建多个通道需要传一个channelNumber 如果channelNumber重复了，
        // 服务端就会返回一个null
        Channel channelB = connection.createChannel(2);


        //声明队列
        Map<String,Object> params = new HashMap<>();

        channel.queueDeclare(QUEUE_NAME,true,false,false,params);

        // 每个worker同时最多只处理一个消息 这是只获取一条消息
        channel.basicQos(1);

        // 回调函数，处理接收到的消息
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("============");
                String routingKey = envelope.getRoutingKey();
                System.out.println("routingKey->"+routingKey);
                String contentType = properties.getContentType();
                System.out.println("contentType->"+contentType);
                long deliveryTag = envelope.getDeliveryTag();
                System.out.println("deliveryTag->"+deliveryTag);
                System.out.println("消息："+ new String(body,"UTF-8"));

                // autoAck 没有开启自动应答，那么这里需要手动应答
                // 那么这条消息就会重新入队
                channel.basicAck(deliveryTag,true);
            }
        };
        // 消费者接收消息  queue 队列名称 autoAck 自动给服务端应答
        channel.basicConsume(QUEUE_NAME,false,consumer);

    }
    // 拉模式
    void pull() throws IOException, TimeoutException {
        // 创建一个连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(HOST);
        factory.setPort(PORT);
        factory.setUsername(USERNAME);
        factory.setPassword(PASSWORD);
        factory.setVirtualHost(VIRTUAL_HOST);

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        // 他是直接获取一次就结束了 一次拉一条
        // 如果队列为空，那么就会返回null，需要处理
        GetResponse response = channel.basicGet(QUEUE_NAME,false);
        byte[] body = response.getBody();
        Envelope envelope = response.getEnvelope();
        int messageCount = response.getMessageCount();
        AMQP.BasicProperties props = response.getProps();

        System.out.println("==========");
        String routingKey = envelope.getRoutingKey();
        System.out.println("routingKey->"+routingKey);
        String contentType = props.getContentType();
        System.out.println("contentType->"+contentType);
        long deliveryTag = envelope.getDeliveryTag();
        System.out.println("messageCount"+messageCount);
        System.out.println("消息内容->"+new String(body,"UTF-8"));

        channel.close();
        connection.close();
    }
生产者
public class Producer {
    private static final String HOST="127.0.0.1";
    private static final Integer PORT=5672;
    private static final String USERNAME="guest";
    private static final String PASSWORD="guest";
    private static final String VIRTUAL_HOST="/mirror";
    private static final String QUEUE_NAME = "test2";

    private static final String EXCHANGE_NAME = "producerExchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建一个连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(HOST);
        factory.setPort(PORT);
        factory.setUsername(USERNAME);
        factory.setPassword(PASSWORD);
        factory.setVirtualHost(VIRTUAL_HOST);

        // 获取连接
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 设置队列类型
        Map<String,Object> params = new HashMap<>();
        params.put("x-queue-type","classic");

        // 声明交换机 如果服务端已经存在交换机，那么声明交换机的参数需要相同，参数不一致会报错
        // exchangeDeclare(exchange交换机名字,type交换机类型,durable 是否持久化保存,
        // autoDelete 交换机没有使用自动删除,arguments 构建交换机的参数)
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT,true,false,params);

        // 声明队列
        // queue 队列名 durable 是否持久化 否 重启服务数据丢失
        // exclusive 队列是否仅允许创建者能使用 autoDelete 没有队列连接，自动删除
        channel.queueDeclare(QUEUE_NAME,true,false,false,new HashMap<>());

        // 声明绑定关系
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"key1");

        // 发送消息
        String message = "直接发送到队列";
        // 发送到队列
        channel.basicPublish("",QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());
        String message2 = "直接发送到交换机";
        // 发送到交换机
        channel.basicPublish(EXCHANGE_NAME,"key1", MessageProperties.PERSISTENT_TEXT_PLAIN,message2.getBytes());

        channel.close();
        connection.close();
    }
}

整合Springboot实现mq的使用

连接配置

spring:
  application:
    name: mqProject
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /mirror
#   用于开启回调的配置ConfirmCallback
    publisher-confirm-type: correlated
    # 开启 ReturnsCallback
    publisher-returns: true
    listener:
      simple:
        #    单次推送消息数量
        prefetch: 1
        #        消费者消费线程数量
        concurrency: 5
#        消费者最大线程数量
        max-concurrency: 10
        acknowledge-mode: manual

队列和交换机的配置

@Configuration
public class FanoutConfig {
    // 声明队列
    @Bean
    public Queue fanoutA(){
        return new Queue("testA",true);
    }
    @Bean
    public Queue topicB(){
        return new Queue("testB",true);
    }
    // 声明交换机
    @Bean
    public FanoutExchange fanoutExchangeA(){
        Map<String,Object> params = new HashMap();

        return new FanoutExchange("springExchangeA",true,false);
    }
    @Bean
    public TopicExchange topicExchangeA(){
        return new TopicExchange("topicExchange",true,false);
    }

    // 绑定关系
    @Bean
    public Binding bindA(){
        return BindingBuilder.bind(fanoutA()).to(fanoutExchangeA());
    }
    @Bean
    public Binding bindB(){
        return BindingBuilder.bind(topicB()).to(topicExchangeA()).with("*.host");
    }
}

消费者配置

@Component
public class Consumer {
    @RabbitListener(queues = "testA",containerFactory = "qos_2")
    public void testA(Message message, Channel channel,String messageStr) throws UnsupportedEncodingException {
        System.out.println("接收到的消息"+new String(message.getBody(),"UTF-8"));

    }
}

消息发送

@RestController
public class producer {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/testTopic")
    public Object testTopic(){
        // 设置部分请求参数
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
        messageProperties.setPriority(2);

        String message = "测试";
        // 设置请求转换器 json格式
        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
        rabbitTemplate.send("directqueue",new Message(message.getBytes()));
        return message;
    }
}

监听与回溯

原生api写法

  • 监听类
    • DeliverCallback：消费者消息传递到的时候触发
    • CancelCallback：队列删除的时候触发
    • ConsumerShutdownSignalCallback：connection连接中断的时候触发
  • deliveryType : 消息传递的编号
  • consumerTag: 消费者的标签
public class CallbackConsumer {
    private static final String HOST="127.0.0.1";
    private static final Integer PORT=5672;
    private static final String USERNAME="guest";
    private static final String PASSWORD="guest";
    private static final String VIRTUAL_HOST="/mirror";
    private static final String QUEUE_NAME = "test2";
    private static final String EXCHANGE_NAME = "producerExchange";
    private static final String EXCHANGE_NAME_B = "producerExchangeB";
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建一个连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(HOST);
        factory.setPort(PORT);
        factory.setUsername(USERNAME);
        factory.setPassword(PASSWORD);
        factory.setVirtualHost(VIRTUAL_HOST);

        // 获取连接
        Connection connection = factory.newConnection();
        // 创建通道 创建单个通道不需要传参
        Channel channel = connection.createChannel();

        // 设置备用交换机
        Map<String,Object> params = new HashMap<>();
        params.put("alternate-exchange",EXCHANGE_NAME_B);
        channel.exchangeDeclare(EXCHANGE_NAME_B,BuiltinExchangeType.DIRECT,true,false,params);

        // 服务端 消息穿过来了后触发
        channel.basicConsume(QUEUE_NAME, new DeliverCallback() {
            @Override
            public void handle(String consumerTag, Delivery delivery) throws IOException {
                long deliveryTag = delivery.getEnvelope().getDeliveryTag();
                String correlationId = delivery.getProperties().getCorrelationId();
                System.out.println("接收到消息" + new String(delivery.getBody(), "UTF-8"));
                channel.basicAck(deliveryTag, false);
            }
            // CancelCallback 消费者队列删除了会触发
        }, new CancelCallback() {
            @Override
            public void handle(String s) throws IOException {
                System.out.println("删除队列触发");
            }
            // 连接关闭会触发
        }, new ConsumerShutdownSignalCallback() {
            @Override
            public void handleShutdownSignal(String s, ShutdownSignalException e) {
                System.out.println("连接关闭了");
            }
        });
    }
}

springboot写法

@Component
public class RabbitmqConfirmCallback implements RabbitTemplate.ConfirmCallback {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        System.out.println("实例化了");
        rabbitTemplate.setConfirmCallback(this);
    }
    @Override
    public void confirm(CorrelationData correlationData, boolean b, String s) {
        System.out.println("监听到ack");
    }
}

@Component
public class RabbitReturnCallback implements RabbitTemplate.ReturnsCallback {
    @Override
    public void returnedMessage(ReturnedMessage returnedMessage) {
        System.out.println("监听到服务端返回的消息");
    }
}

死信队列

  • 参数
    • Dead letter exchange：配置死信交换机（普通交换机）
    • Dead letter routing key：配置死信的routing key 他会覆盖原本的routingkey
  • 机制
  • 主要就是创建一个死信交换机并绑定一个队列，在其他队列配置上死信队列，当他的接收到消息，但没有接到ack确认信息，那么他就会把该数据发送到死信队列中。
  • 其他作用
    • 延迟队列：只要做法就是，在一个队列中设置一个ttl时间，等这个时间超时就进入到死信队列中，即达到延迟效果。

Kafka

RabbitMQ3/4---持久化机制、内存磁盘控制
Stephanie翟倩
07-25 1887
持久化到磁盘的那些操作。
RabbitMq 最全的性能调优笔记
weixin_34062469的博客
09-11 8958
RabbitMq 性能调优笔记 [TOC] 避免雷区 要避免流控机制触发 服务端默认配置是当内存使用达到40%，磁盘空闲空间小于50M，即启动内存报警，磁盘报警；报警后服务端触发流控（flowcontrol）机制。 一般地，当发布端发送消息速度快于订阅端消费消息的速度时，队列中堆积了大量的消息，导致报警，就会触发流控机制。 触发流控机制...
RabbitMQ个人小结
山鬼谣的专栏
12-13 242
前言 小组分享 未完待续。。。 什么是MQ？ 全称：Message Queue Middleware 消息队列中间件； 指利用高效可靠的消息传递机制进行与平台无关的数据交流； 通过提供消息传递和消息排队模型，它可以再分布式环境下扩展进程间的通信。 削峰填谷 消息的传递模式 ① 点对点模式 ② 发布/订阅模式（pub/sub) RabbitMQ原理 本质上呢，就是一个生产者与消费者模型，主要负责接收、存储和转发消息。 形象点的理解： 寄快递，快递员上门取件，快递公司会暂存快递到集散点，运送到目的地后，由
使用RabbitMQ的延时交换机实现定时发送
TZfool的博客
03-09 1061
使用RabbitMQ的延时交换机实现定时发送，用户选择一个时间段定时发送信息到相应平台或者设备
RabbitMQ延时队列
Hello World
01-23 2344
延时队列 1.1 什么是延时队列 在开发中，往往会遇到一些关于延时任务的需求。例如 生成订单30分钟未支付，则自动取消 生成订单60秒后,给用户发短信 滴滴打车订单完成后，如果用户一直不评价，48小时后会将自动评价为5星。 和定时任务区别 对上述的任务，我们给一个专业的名字来形容，那就是延时任务。那么这里就会产生一个问题，这个延时任务和定时任务的区别究竟在哪里呢？一共有如下几点区别 定时任务有明确的触发时间，延时任务没有 定时任务有执行周期，而延时任务在某事件触发后一段时间内执行，没有执行周期。（可
分布式消息中间件之RabbitMQ学习笔记[一]
山河已无恙
07-04 696
户外依然大雨滂沱，只是这回彷彿不仅命运一人独自哭泣，不晓得由来，窗外的雨水似乎渗上我心头，有些寒冻，有些缩麻，还有些苦涩。城市万家灯火，橘黄街灯与家户里的温暖流洩，我总觉得这时候的我，最脆弱。 -----《Unser Leben Unser Traum》是一个由语言开发的基于的消息中间件。最初起源于,用于在中存储转发消息,在、、等方面表现不俗。其具体包括:我们先来看一下，了解消息中间件的小伙伴，这个协议应该不陌生，这里我们简单了解下在2004年,和开始着手开放标准的开发。年,发布了。目前协议的版本为。一般来
学习笔记：分布式消息队列RabbitMQ
qq_45867699的博客
08-02 569
简单模式 HelloWorld：一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）。工作队列模式 Work Queue：一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）。发布订阅模式 Publish/Subscribe：需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列。
分布式消息中间件RabbitMQ学习笔记（一）——使用场景（限流削峰、异步解耦、数据收集）
weixin_51542566的博客
10-23 1733
1、用户完成支付服务，需要调用订单服务、仓储服务、短信服务等等，并且需要等待调用的服务全部完成，才完成支付服务。2、当用户执行订单服务时，订单服务调用其他服务时，只需要通过MQ发送订单消息通知其他所调用的服务完成任务即可，无需等待其他服务执行完。当用户执行订单服务时，调用短信服务的同时，调用邮件服务、SMS短信等服务，等待调用的所有服务完成后，完成支付服务。加入消息中间件RabbitMQ后，MQ会将超量的请求拦截下来，暂存到队列里，既避免过量请求导致系统A崩溃，也不会丢失用户的请求数据。
RabbitMQ消息中间件技术精讲.txt
12-04
该资源包括RabbitMQ消息中间件详细视频教程，包括详细笔记及源码，可以很好的帮助学习消息中间件。RabbitMQ用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。
尚硅谷_消息中间件RabbitMQ_课件.rar
08-15
【描述】"消息中间件rabbitMq笔记，很详细，适用于Java开发人员。" 暗示这组资料深入浅出地阐述了RabbitMQ的基本概念、工作原理以及如何在Java项目中集成和使用。对于希望提升自己在分布式系统中处理异步通信能力的...
消息中间件学习笔记.zip
09-02
集群管理是消息中间件另一个重要的知识点，它涉及如何将消息代理分布在不同的节点上，以实现负载均衡和高可用性。集群管理通常需要处理节点的加入和离开、数据同步和负载均衡策略等问题。 学习笔记中还会包含对不同...
RabbitMQ系列学习笔记（一）--认识消息队列
Scr1Pt的博客
10-14 2055
本文主要介绍消息队列、RabbitMQ消息队列的基本概念以及安装过程，为作者在学习RabbitMQ时的笔记，特此记录，以便后续学习中能够查漏补缺。
rabbitmq部署使用笔记
督门提酒的博客
02-02 5061
本人在ubantu16.04上部署rabbitmq集群，有以下总结。写的稍乱，要选择性参考 安装     echo 'deb http://www.rabbitmq.com/debian/ testing main' |             sudo tee /etc/apt/sources.list.d/rabbitmq.list     wget -O- https://w
JAVA 架构师面试题含答案：JVM+spring+ 分布式 + 并发编程
sjkflw121150的博客
10-19 426
面试不光是这些准备不光包括技术，还有你对公司的了解，这是在 hr 这关更看重的，他们想找的不光是技术大拿，更重要的事可以跟公司共同进步的伙伴，所以当你真正开始面试，那么就要拿出自己的真诚，让 hr 感受到你对公司的兴趣、热情和自信，从谈吐上表现出果断和坚定往往会是很多招聘人事更加青睐的。synchronized 的原理，什么是自旋锁，偏向锁，轻量级锁，什么叫可重入锁，什么叫公平锁和非公平锁。类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字段，他们的执行顺序。
解锁分布式唯一 ID：技术、实践与最佳方案
xintaitehao的博客
10-17 1016
分布式唯一 ID 的核心就是 “唯一、稳、快”，选方案不用追求 “最牛”，适合自己业务的才最好 —— 比如中小公司先用雪花算法，大公司再上 Leaf，一步步来就行。
自建webrtc低延时分布式街机游戏直播方案
最新发布
fangji999的专栏
10-21 714
自建webrtc低延时分布式街机游戏直播方案
Piper：一种基于 PackML 语义的分布式工业协同框架
weixin_41939376的博客
10-19 846
Piper是美国CESMII推出的开放式工业协同框架，旨在解决传统自动化系统设备协作僵化问题。它以PackML状态语义为基础，通过分布式节点模型和事件驱动机制，实现边缘层的柔性编排。Piper采用声明式流程定义（JSON/YAML），使设备协同像微服务编排一样灵活，支持动态重构产线流程而无需修改PLC程序。作为连接控制层与管理层的分布式中间层，Piper将单机PackML状态扩展为系统级语义协同，代表着OT架构从硬联锁到软编排的范式转变，为智能制造提供可组合、可演化的机边协同能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AloneLie

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值