【学习笔记】RabbitMQ

已于 2024-05-05 11:09:03 修改
阅读量2.5k 收藏
点赞数
文章标签： rabbitmq 学习
于 2022-03-14 18:25:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47585404/article/details/123340260
版权

教学视频：B站尚硅谷RabbitMQ教学视频
代码资源：代码资源

文章目录

一、入门

1、基本概念

在这里插入图片描述
在这里插入图片描述

2、基本功能

  • 流量削峰
    在这里插入图片描述
    在这里插入图片描述
  • 应用解耦
    在这里插入图片描述
    在这里插入图片描述
  • 异步处理
    在这里插入图片描述
    在这里插入图片描述

3、MQ的分类

  • 1、ActiveMQ
    在这里插入图片描述
  • 2、kafka
    在这里插入图片描述
  • 3、RoketMQ
    在这里插入图片描述
  • RabbitMQ
    在这里插入图片描述

4、MQ的选择

在这里插入图片描述

5、四大核心概念

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二、核心部分

1、 名词解释

在这里插入图片描述
生产者、连接（含信道）、MQ（含交换机和队列）、连接（含信道）、消费者
在这里插入图片描述
在这里插入图片描述

2、安装

受不了直接临时学了点docker，秒装！！！

  • 开启、运行容器：docker run -d --hostname my-rabbit --name rabbit -p 15672:15672 -p 5672:5672 rabbitmq
  • 安装管理界面（进入rabbitmq操作界面）：rabbitmq-plugins enable rabbitmq_management
  • 设置用户，添加权限
    rabbitmqctl add_user admin 123
    rabbitmqctl set_user_tags admin administrator
    rabbitmqctl set_permissions -p “/” admin “." ".” “.*”
    rabbitmqctl list_users
    在这里插入图片描述
  • 在阿里云中开启15672端口即可访问登录rabbitmq界面

3、常用命令

  • 开机自启：chkconfig rabbitmq-server on
  • 启动服务：/sbin/service/rabbitmq-server start

4、创建Java开发环境

引入依赖

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>8</source>
                <target>8</target>
            </configuration>
        </plugin>
    </plugins>
</build>

<dependencies>

    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>5.8.0</version>
    </dependency>

    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.5</version>
    </dependency>
</dependencies>

6、六大核心/六大模式

在这里插入图片描述

1）、简单模式–“HelloWorld”
  • 生产者代码
public class Product {
    //队列名
    public static final String QUEUE_NAME = "hello";
    public static void main(String[] args) throws IOException, TimeoutException {
        //连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置ip、用户名、密码和端口号
        factory.setHost("139.224.46.237");
        factory.setUsername("admin");
        factory.setPassword("123");
        factory.setPort(5672);

        //创建连接
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        /**
         * 创建队列
         * 1、队列名
         * 2、是否持久化
         * 3、是否对消费者排他
         * 4、是否自动删除：最后一个消费者断开之后是否自动删除
         * 5、其他
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        /**
         * 使用信道发送消息
         * 1、选择交换机（本例没有）
         * 2、选择路由的key（本次是队列名称）
         * 3、其他
         * 4、消息体
         */
        channel.basicPublish("",QUEUE_NAME,null,"helloworld".getBytes());
        System.out.println("success！！");
    }
}
  • 消费者代码
public class Consumer {
    public static final String QUEUENAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("139.224.46.237");
        factory.setUsername("admin");
        factory.setPassword("123");
        factory.setPort(5672);

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //声明消息接收成功后的回调
        DeliverCallback deliverCallback = (consumerTag,message)->{
            System.out.println(new String(message.getBody()));
        };

        //声明消息接受未成功的回调
        CancelCallback cancelCallback = ConsumerTag->{
            System.out.println("消息接收被中断");
        };

        /**
         * 接受消息
         * 1、选择队列
         * 2、消费成功后是否自动应答
         * 3、接收成功的回调
         * 4、未成功的回调
         */
        channel.basicConsume(QUEUENAME,true, deliverCallback, cancelCallback);
    }
}
2）、工作模式–“WorkQueues”
  • 基本概念
    在这里插入图片描述
    一个发布，多个轮循接收
  • 代码
    略，大致与简单队列一模一样，多个接受者也是自动轮循接收的
3）、消息应答模式（自创的，教学视频一团乱麻）
  • 基本概念
    • 消息应答
      在这里插入图片描述
    • 自动应答
      在这里插入图片描述
    • 应答的方式
      在这里插入图片描述
      在这里插入图片描述
    • 消息自动重新入队
      在这里插入图片描述
  • 代码
    在这里插入图片描述
  • 队列持久化
    概念—略
    即使RabbitMQ关机重启也不会消失
    在这里插入图片描述
  • 消息持久化
    在这里插入图片描述
  • 不公平分发
    在这里插入图片描述
    在这里插入图片描述
    得到接受者的回应就会发送下一个消息，而没有回应的接受者则让其一直等待
  • 预期值
    在这里插入图片描述
    prefetchCount：可以理解为消息堆积上限，接受者提前处理完的可以继续接收，0就代表不管接受者的回应，完全按照轮循分发
4）、发布确认模式–“PublisherConfirms”
  • 原理
    在这里插入图片描述
    在这里插入图片描述
  • 使用
    在这里插入图片描述
  • 发布确认的三种方式

    • 单个
      在这里插入图片描述
      在这里插入图片描述

    • 批量
      在这里插入图片描述

    • 异步
      在这里插入图片描述

//成功确认回调，消息标记，是否为批量确认
        ConfirmCallback ackCallback = (deliveryTag,mutiple)->{
            System.out.println(deliveryTag+"success");
        };
        //确认失败回调
        ConfirmCallback nackCallback = (deliveryTag,mutiple)->{
            System.out.println(deliveryTag+"fail");
        };
        //添加异步发布确认监听器
        channel.addConfirmListener(ackCallback,nackCallback);

        //发消息
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            channel.basicPublish("",queueName,null,String.valueOf(i).getBytes());
        }
  • 处理异步未确认的消息在这里插入图片描述
//支持高并发的hashMap,用于记录未确认的消息：消息标记为long，消息为string
        ConcurrentSkipListMap<Long, String > skipListMap = new ConcurrentSkipListMap<>();

        //成功确认回调，消息标记，是否为批量确认
        ConfirmCallback ackCallback = (deliveryTag,mutiple)->{
            //成功确认的消息就从hashmap中移除
            if (mutiple){
                //批量移除:获取从第一个到deliveryTag的所有k，v，clear清除所有kv
                ConcurrentNavigableMap<Long, String> headMap = skipListMap.headMap(deliveryTag);
                headMap.clear();
            }else{
                //单个移除
                skipListMap.remove(deliveryTag);
            }
            System.out.println(deliveryTag+"success");
        };
        //确认失败回调
        ConfirmCallback nackCallback = (deliveryTag,mutiple)->{
            System.out.println(deliveryTag+"fail");
        };
        //添加异步发布确认监听器
        channel.addConfirmListener(ackCallback,nackCallback);

        //发消息
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = i+"";
            channel.basicPublish("",queueName,null,message.getBytes());
            //先记录消息：序号，消息内容
            skipListMap.put(channel.getNextPublishSeqNo(),message);
        }
5）、发布订阅模式–“Publish/Subscribe”
  • 基本概念
    • 交换机概念
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    • 交换机类型
      在这里插入图片描述
      直接类型—路由模式；主题—主题模式；标题类型不常用了；扇出类型----发布模式；
      无名类型—默认交换机
      在这里插入图片描述
    • 临时队列
      在这里插入图片描述
      在这里插入图片描述
    • 绑定
      在这里插入图片描述
      可以通过不同的routingkey区分不同“队列组”（同一个队列可以绑定多个交换机）
      在这里插入图片描述

在不同模式中的bindingkey和routingkey使用场景不同
在这里插入图片描述

- 扇出/发布订阅概念（忽略所有routingkey）

在这里插入图片描述

  • 使用/例子
    在这里插入图片描述
public class Product {
    public static final String EXCHANGE_NAME="logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();
        //发消息
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.nextLine();
            //交换机和routingkey，其他和消息体
            channel.basicPublish(EXCHANGE_NAME,"2",null,message.getBytes());
        }
    }
}

		//接收消息，创建交换机，在发送端创建也可以
	public class Comsum {
    	public static final String EXCHANGE_NAME="logs";
    	public static void main(String[] args) throws IOException, TimeoutException {
        //信道
        Channel channel = RabbitMQUtils.getChannel();
        //声明一个交换机:交换机名，交换机类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        //临时队列
        String tempQueueName = channel.queueDeclare().getQueue();

        //绑定交换机与队列：队列名，交换机名，routingkey
        channel.queueBind(tempQueueName,EXCHANGE_NAME,"1");



        //接收消息
        //声明消息接收成功后的回调
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println(new String(message.getBody()));
        };

        //声明消息接受未成功的回调
        CancelCallback cancelCallback = ConsumerTag->{
            System.out.println("消息接收被中断");
        };

        channel.basicConsume(tempQueueName,true, deliverCallback, cancelCallback);
    }
}

public class Comsum2 {
    public static final String EXCHANGE_NAME="logs";
    public static void main(String[] args) throws IOException, TimeoutException {
        //信道
        Channel channel = RabbitMQUtils.getChannel();
        //声明一个交换机:交换机名，交换机类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        //临时队列
        String tempQueueName = channel.queueDeclare().getQueue();
        //绑定交换机与队列：队列名，交换机名，routingkey
        channel.queueBind(tempQueueName,EXCHANGE_NAME,"2");



        //接收消息
        //声明消息接收成功后的回调
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println(new String(message.getBody()));
        };

        //声明消息接受未成功的回调
        CancelCallback cancelCallback = ConsumerTag->{
            System.out.println("消息接收被中断");
        };

        channel.basicConsume(tempQueueName,true, deliverCallback, cancelCallback);

    }
}
6）、路由模式–“Routing”
  • 基本概念
    需要确认routingkey与bindingkey才会将消息发布到对应的队列
    在这里插入图片描述
  • 例子
    与发布订阅模式一致，只不过会按照routingkey,以及不同的队列分发了而已，不会对所有队列广播
7）、主题模式–“Topics”
  • 基本概念
    • 之前的模式无法解决的问题
      在这里插入图片描述
    • routingkey的命名规范
      在这里插入图片描述
      在这里插入图片描述
  • 例子
    略，就是根据routingkey命名后缀的不同进行分发，减少不必要，过多的交换机而已

7、死信队列

  • 概念
    在这里插入图片描述
  • 产生
    在这里插入图片描述
  • 例子
    在这里插入图片描述
  • 代码（ttl过期、队列达到最大长度、消息被拒）
//生产者
public static final String NORMAL_EXCHANGE = "normal_exchange";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();
        //设置消息过期时间10s
//        AMQP.BasicProperties properties = new AMQP.BasicProperties()
//                .builder().expiration("10000").build();

        //发消息
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.nextLine();
            //交换机和routingkey，其他和消息体
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",null,message.getBytes());
        }
    }

//正常队列消费者
//交换机名
    public static final String NORMAL_EXCHANGE = "normal_exchange";
    public static final String DEAD_EXCHANGE = "dead_exchange";
    //队列名
    public static final String NORMAL_QUEUE = "normal_queue";
    public static final String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();
        //交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE,BuiltinExchangeType.DIRECT);

        //队列:在普通队列绑定死信交换机
        Map<String, Object> arguments = new HashMap<>();
        //设置过期时间:也可以由发送方设置时间
        //arguments.put("x-message-ttl",10000);
        //绑定死信交换机
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信routingkey
        arguments.put("x-dead-letter-routing-key","lisi");
        //设置队列最大长度:超过最大长度会把最先到达队列的放入死信队列（先到先去死信）
//        arguments.put("x-max-length",6);

        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //绑定交换机与队列
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");


        //接收消息
        //声明消息接收成功后的回调
        DeliverCallback deliverCallback = (consumerTag, message)->{
            //检验消息
            String msg = new String(message.getBody(), StandardCharsets.UTF_8);
            if (msg.equals("1")){
                System.out.println("reject!!!");
                //拒绝消息消息标签，是否放回队列
                channel.basicReject(message.getEnvelope().getDeliveryTag(),false);
            }else{
                //接受消息:消息标记，是否批量接受
                channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
                System.out.println(new String(message.getBody()));
            }
        };

        //声明消息接受未成功的回调
        CancelCallback cancelCallback = ConsumerTag->{
            System.out.println("消息接收被中断");
        };
        //开启手动应答：false
        channel.basicConsume(NORMAL_QUEUE,false,deliverCallback,cancelCallback);

    }

//死信队列消费者
public static final String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMQUtils.getChannel();

        //接收消息
        //声明消息接收成功后的回调
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println(new String(message.getBody()));
        };

        //声明消息接受未成功的回调
        CancelCallback cancelCallback = ConsumerTag->{
            System.out.println("消息接收被中断");
        };

        channel.basicConsume(DEAD_QUEUE,true,deliverCallback,cancelCallback);

    }

8、延迟队列

  • 概念
    近似于ttl过期的死信队列
    在这里插入图片描述
  • 使用场景
    在这里插入图片描述
    -例子(顺便整合springboot)
    • 代码结构图
      在这里插入图片描述
    • 代码
      略
    • 优化
      在这里插入图片描述
      在这里插入图片描述
    • 存在问题
      在这里插入图片描述
      用插件解决p66
      在这里插入图片描述
      原本的死信队列模式：消息在正常队列中延迟，过期再发给延迟队列
      在这里插入图片描述

基于插件的不再使用死信队列：消息在交换机中延迟，过期就发给队列
在这里插入图片描述
- 解决的代码（装不了插件，这里的代码先不敲了）
在这里插入图片描述
配置文件
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
product、controller
在这里插入图片描述

三、高级部分

1、高级发布确认

  • 问题
    在这里插入图片描述
  • 解决方案一：回调反馈
    在这里插入图片描述
    • 重点：回调接口
      在这里插入图片描述
      simple是同步确认方式，发一个就等待确认，效率很慢
@Component
public class ConfirmCallBack implements RabbitTemplate.ConfirmCallback {
    //由于ConfirmCallback是内部类，需要注入，才能让内部调用我们重写的类
    @Autowired
    RabbitTemplate rabbitTemplate;

    //这个是JSR250定义的注解，被注解的方法将在bean创建并且赋值完成，在执行初始化方法之前调用，
    // 原理：后置处理器起的作用
    @PostConstruct
    public void init(){
        //将父类的接口换成我们重写的这个
        rabbitTemplate.setConfirmCallback(this);
    }

    /**
     *
     * @param correlationData,相关信息
     * @param b，是否发送成功
     * @param s，失败原因，成功为null
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean b, String s) {
        //获取交换机id
        String exchangeId = correlationData!=null?correlationData.getId():"";
        if (b) {
            System.out.println(exchangeId + "已经收到");
        } else {
            System.out.println(exchangeId+"未收到:"+s);
        }


    }
}

但是这只是交换机的反馈，队列消息的丢失并不能正常反馈

  • 回退消息
    在这里插入图片描述
    路由即是从交换机发往队列的过程
    • 配置文件中开启：spring.rabbitmq.publisher-returns=true
    • 重写ReturnCallback，注入（可以与之前的写在一起）
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
  • 解决方法二：备份交换机
    • 代码架构图
      在这里插入图片描述
      在confirmExchange的交换机声明中绑定备份交换机
      在这里插入图片描述
      在这里插入图片描述

2、幂等性问题

  • 概念
    在这里插入图片描述
    在这里插入图片描述
  • 解决方法
    在这里插入图片描述
    在这里插入图片描述

3、优先级队列

  • 使用场景
    在这里插入图片描述
  • 使用
//优先级队列
        Map<String, Object> arguments = new HashMap<>();
        //优先级范围0-255，这里为0-10，不要设置过大cpu会有影响
        arguments.put("x-max-priority",10);
        /**
         * 创建队列
         * 1、队列名
         * 2、是否持久化
         * 3、是否对消费者排他
         * 4、是否自动删除：最后一个消费者断开之后是否自动删除
         * 5、其他
         */
        channel.queueDeclare(QUEUE_NAME,true,false,false,arguments);

        //优先级队列：发消息
        for (int i = 0; i < 10; i++) {
            if(i==5){
                //增加第五条的优先级，其他消息不变
                AMQP.BasicProperties properties =
                        new AMQP.BasicProperties().builder().priority(10).build();
                channel.basicPublish("",QUEUE_NAME,properties,
                        String.valueOf(i).getBytes());
            }else{
                channel.basicPublish("",QUEUE_NAME,null,
                        String.valueOf(i).getBytes());
            }
        }

4、惰性队列

  • 使用队列
    在这里插入图片描述
  • 两种模式
    在这里插入图片描述
  • 代码
    略

四、集群部分

  • 概念
    略
    在这里插入图片描述

  • 搭建步骤
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  • 镜像队列

    • 概念
      在这里插入图片描述
    • 搭建
      • docker的搭建方式
        docker的rabbitmq搭建集群
        勘误：
        1、加入节点到集群中进入后台的命令中的名字应该与运行容器的名字一样，去掉my加上mq
        2、加入节点的名字也是错的去掉mq
      • 本节内容
        在这里插入图片描述
        pattern:队列命名符合此处的正则表达式才会进行备份
        ha-mode:备份模式–指令模式
        ha-parass：指令----主从在内备份两份
        ha-sync-mode：同步模式—自动
      • 效果：如果节点一宕机了，则会使用备份节点中的队列，另外再找一个备份节点，已达到备份数量为2的策略，以此类推。因此只要集群中仍有一个节点，就不会丢失信息

  • 利用nginx或haproxy、keepalive进行负载均衡高可用
    略

  • 联邦交换机（Federation exchange）
    • 概念
      个地区有多个服务器，需要让用户按照地区进行访问，因此如要用联邦交换机来同步各个服务器之间的信息
      信息只能从上游（即被联邦的一方）同步到下游（联邦别人的一方），如果要实现双向的信息同步就要进行双向的联邦，操作同理
    • 使用
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述

在这里插入图片描述

  • 联邦队列
    在这里插入图片描述
    • 使用
      在这里插入图片描述
  • Shovel
    • 概念
      在这里插入图片描述
      在这里插入图片描述
    • 使用
      在这里插入图片描述
      在这里插入图片描述
舟生tt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
rabbitMQ的详细介绍
wang20010104的博客
04-07 7万+
rabbitMQ的详细介绍
【RabbitMQ】MQ的基本概念、RabbitMQ简介及安装
十八岁讨厌编程的博客
01-11 2万+
本文涉及MQ的基本概念、RabbitMQ简介、RabbitMQ的安装等内容
RabbitMQ详解，用心看完这一篇就够了【重点】
热门推荐
sunnyday0426的博客
03-15 8万+
1.1 消息中间件 消息中间件是基于队列与消息传递技术，在网络环境中为应用系统提供同步或异步、可靠的消息传输的支撑性软件系统——百度百科 1.1.1 应用场景 1.1.1.1 异步处理 场景说明： 用户注册后，需要发注册邮件和注册短信，传统的做法有两种 1.串行的方式； 2.并行的方式 ； (1)串行方式：将注册信息写入数据库后，发送注册邮件，再发送注册短信，以上三个任务全部完成后才返回给客户端。这有一个问题是，邮件，短信并不是必须的，它只是一个通知，而这种做法让客户端等待没有必要等待的东西。 (
RabbitMQ详解
08-11 1万+
1.1 什么是MQ MQ(Message Quene) : 翻译为 消息队列,通过典型的 生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。别名为 消息中间件 通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。 1.2 MQ有哪些 当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、RabbitMQ，炙手可热的Kafka
RabbitMQ 入门介绍
qq_24991197的博客
06-17 2465
MQ 的相关概念 什么是 MQ MQ(message queue)，从字面意思上看，本质是个队列，FIFO 先入先出，只不过队列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ 是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了 MQ 之后，消息发送上游只需要依赖 MQ，不用依赖其他服务。 为什么要用 MQ 1.流量消峰 举个例子，如果订单系统最多能处理一万次订单，这个处理能力应付正常时段的下单时绰绰有余，正常时段我们下单一秒后就能返回结
rabbitMQ学习笔记
最新发布
11-06
rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ...
RabbitMQ学习笔记
06-22
RabbitMQ学习笔记
rabbitmq学习笔记和软件和插件
05-05
rabbitmq学习笔记和软件和插件，尚硅谷的学习笔记和软件
RabbitMq学习笔记1
08-03
RabbitMq学习笔记1
RabbitMq学习笔记
01-15
RabbitMq是实现AMQP（高级消息队列协议）的消息中间件的一种，与Springboot整合后使用方便简单，功能强大。本文还列举了Springboot整合RabbitMq使用和原版对比、及一些坑，简单易懂。
RabbitMQ 详解
m0_53067943的博客
05-09 1万+
文章主要对关于RabbitMQ的知识总结
深入理解RabbitMQ消息队列的使用
06-20
本课程将涵盖RabbitMQ的下述知识:RabbitMQ单节点服务搭建以及集群的搭建、RabbitMQ的整体架构及各个组件的功能、RabbitMQ当中生产者以及消费者的具体实现、消费者如何做到消息的确认、RabbitMQ如何做到消息的公平分发、RabbitMQ当中fanout、direct、topic交换机的特点以及转化关系、RabbitMQ基于RPC机制的具体实现等内容.
RabbitMQ的详解和使用
创作不易，请多支持，将为本站提供更多「有价值的文章」。
04-10 8666
一、AMQP协议 1、AMQP协议介绍 AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有RabbitMQ等。 2、功能范围 存储转发（多个消息发送者，单个消息接收者） 分布式事务（多个消息发送者，多个消息接收者） 发布订阅（多个消息发送者，多个消息
rabbitmq详解
m0_67393342的博客
07-28 2584
RabbitMQ是一个实现了AMQP（AdvancedMessageQueuingProtocol）高级消息队列协议的消息队列服务，用Erlang语言。是面向消息的中间件。你可以把它想像成一个邮局你把信件放入邮箱，邮递员就会把信件投递到你的收件人处。在这个比喻中，RabbitMQ是一个邮箱、邮局、邮递员。RabbitMQ和邮局的主要区别是，它处理的不是纸，而是接收、存储和发送二进制的数据——消息。主要流程。...
乐优商城（二十四）——RabbitMQ及数据同步
lyj2018gyq的博客
10-19 3259
目录 一、RabbitMQ 1.1 搜索与商品服务的问题 1.2 消息队列（MQ） 1.2.1 什么是消息队列 1.2.2 AMQP和JMS 1.2.3 常见MQ产品 1.2.4 RabbitMQ 1.3 下载和安装 1.3.1 下载 1.3.2 安装 二、五种消息模型 2.1 基本消息模型 2.1.1 生产者发送消息 2.1.2 管理工具中查看消息 2.1.3 消费...
【RabbitMQ】什么是RabbitMQ？RabbitMQ有什么用？应用场景有那些？
四季轮换叶，一路招摇胜
09-27 3万+
RabbitMQ简称MQ是一套实现了高级消息队列协议的开源消息代理软件，简单来说就是一个消息中间件。是一种程序对程序的通信方法。
RabbitMQ实战教程
09-02
本课程适用于RabbitMQ实战者以及SpringBoot整合RabbitMQ实战需求者。课程将首先带领大家拜读RabbitMQ官网的技术开发手册，之后会将学到的知识深入的实战到实际的各种应用场景中，从而加深知识点的理解，其中包括如何实现单一队列多个消费者监听消费、业务服务模块解耦通信、抢单高并发方案的解决、登录成功异步写日志、异步发送邮件、死信队列实战以及实现用户下单超时未支付自动失效等等。
RabbitMQ消息队列常见面试题总结
张维鹏的博客
03-23 6万+
RabbitMQ消息队列常见面试题总结； 1、什么是消息队列？消息队列的优缺点？ 2、Kafka、ActiveMQ、RabbitMQ、RocketMQ的区别？ 3、如何保证消息不被重复消费？ 4、如何保证消息不丢失，进行可靠性传输？ 5、如何保证消息的有序性？ 6、如何处理消息堆积情况? 7、如何保证消息队列的高可用？

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值