浅谈RabbitMQ（一）

最新推荐文章于 2024-05-01 14:29:35 发布
最新推荐文章于 2024-05-01 14:29:35 发布
阅读量208 收藏
点赞数
分类专栏： 中间件 文章标签： rabbitmq kafka 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44953152/article/details/125253091
版权

消息队列概念

消息队列（Message Queue）简称MQ，简单来说就是一种消息的容器

作用是采用FIFO（先入先出）的方式实现程序之间（服务、进程、线程）的消息通信。
在这里插入图片描述

消息队列的优点

MQ的优点有：
1）解耦

服务之间进行解耦，A服务调用B服务时，需要编写相关的代码，调用情况发生改变时，需要修改调用的代码

2）异步

传统的同步调用方式，需要等待调用完成，才能进行其它业务

异步调用方法，将消息发送到队列中，就可以返回，执行其它业务，速度大大提升

3）削峰

出现流量激增的情况时，消息队列可以设置消息的最大数量，处理一部分消息，其它消息交给队列排队处理

MQ的缺点：

  1. 增加了系统的复杂性
  2. 降低了系统的可用性（消息队列出现问题，整个系统的通信受影响）
  3. 。。。

主流的消息队列

目前市场上主流的消息队列有4种：

  • ActiveMQ

  • RabbitMQ

  • RocketMQ Alibaba

  • Kafka

    在这里插入图片描述
    RabbitMQ并发性能好，而且部署相对容易，是目前很多企业使用的消息队列。

安装RabbitMQ

Linux安装

安装erlang

wget https://packages.erlang-solutions.com/erlang-solutions-1.0-1.noarch.rpm
rpm -Uvh erlang-solutions-1.0-1.noarch.rpm
yum install epel-release
yum install erlang

安装rabbitmsq

wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.9.7/rabbitmq-server-3.9.7-1.el7.noarch.rpm
yum install rabbitmq-server-3.9.7-1.el7.noarch.rpm  # 目前的最新版本 支持erlang24

启动rabbitmsq

service rabbitmq-server start

启用管理工具

rabbitmq-plugins enable rabbitmq_management

防火墙允许端口

firewall-cmd --permanent --add-port=15672/tcp
firewall-cmd --permanent --add-port=5672/tcp

将配置文件模板复制到etc目录：

cp /usr/share/doc/rabbitmq-server-3.9.7-1/rabbitmq.config.example /etc/rabbitmq/rabbitmq.config

通过vi命令编辑：

vi /etc/rabbitmq/rabbitmq.config

修改下面内容：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ou2QLqXY-1634009581873)(assets/1527066694704.png)]
注意要去掉后面的逗号

设置开机启动

输入下面命令

chkconfig rabbitmq-server on

Windows安装

文件下载
1）安装erlang
2）安装rabbitmq
3）打开菜单输入命令，启动管理工具
在这里插入图片描述

rabbitmq-plugins enable rabbitmq_management

4）启动rabbit

net start rabbitmq
net stop rabbitmq

5）浏览器输入： http://localhost:15672 账号密码都是guest
在这里插入图片描述

基本概念

  • 生产者

    向队列中发送消息的程序

  • 消费者

    从队列中消费消息的程序

  • 队列

    消息的容器，FIFO数据结构

  • 交换机

    将消息复制分发到不同的队列中

  • 虚拟主机

    包含交换机和队列的空间

  • 连接

    客户端和MQ服务的连接

  • 通道

    通信的通道

基本使用

用户

不同的系统可以使用各自的用户登录RabbitMQ，可以在Admin的User页面添加新用户
在这里插入图片描述

虚拟主机

虚拟主机相当于一个独立的MQ服务，有自身的队列、交换机、绑定策略等。
添加虚拟主机
在这里插入图片描述

队列

不同的消息队列保存不同类型的消息，如支付消息、秒杀消息、数据同步消息等。
添加队列，需要填写虚拟主机、类型、名称、持久化、自动删除和参数等。
在这里插入图片描述

交换机

生产者将消息发送到交换机Exchange，再由交换机路由到一个或多个队列中；
交换器的类型有fanout、direct、topic、headers这四种，下篇文章将详细介绍。
添加交换机
在这里插入图片描述

五种消息模型

在这里插入图片描述
RabbitMQ提供了多种消息模型，官网上第6种是RPC不属于常规的消息队列。
属于消息模型的是前5种：

  1. 简单的一对一模型
  2. 工作队列模型 ，一个生产者将消息分发给多个消费者
  3. 发布/订阅模型 ，生产者发布消息，多个消费者同时收取
  4. 路由模型 ，生产者通过关键字发送消息给特定消费者
  5. 主题模型 ，路由模式基础上，在关键字里加入了通配符

一对一模型

在这里插入图片描述
最基本的队列模型：
一个生产者发送消息到一个队列，一个消费者从队列中取消息。

启动Rabbitmq，在管理页面中创建用户admin
使用admin登录，然后创建虚拟主机myhost
在这里插入图片描述
创建队列，配置如下
在这里插入图片描述
导入依赖

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

MQ工具类

public class MQUtils {

    public static final String QUEUE_NAME = "myqueue01";
    public static final String QUEUE_NAME2 = "myqueue02";

    public static final String EXCHANGE_NAME = "myexchange01";
    public static final String EXCHANGE_NAME2 = "myexchange02";
    public static final String EXCHANGE_NAME3 = "myexchange03";

    /**
     * 获得MQ的连接
     * @return
     * @throws IOException
     */
    public static Connection getConnection() throws IOException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //配置服务器名、端口、虚拟主机名、登录账号和密码
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("myhost");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("123456");
        return connectionFactory.newConnection();
    }
}

生产者

/**
 * 生产者，发送简单的消息到队列中
 */
public class SimpleProducer {

    public static void main(String[] args) throws IOException {
        Connection connection = MQUtils.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //定义队列
        channel.queueDeclare(MQUtils.QUEUE_NAME,false,false,false,null);
        String msg = "Hello World!";
        //发布消息到队列
        channel.basicPublish("",MQUtils.QUEUE_NAME,null,msg.getBytes());
        channel.close();
        connection.close();
    }
}

运行生产者代码，管理页面点进myqueue01，在GetMessages中可以看到消息
在这里插入图片描述

消费者

/**
 * 消费者，从队列中读取简单的消息
 */
public class SimpleConsumer {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        //定义队列
        channel.queueDeclare(MQUtils.QUEUE_NAME,false,false,false,null);
        //创建消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //消费者消费通道中的消息
        channel.basicConsume(MQUtils.QUEUE_NAME,true,queueingConsumer);
        //读取消息
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println(new String(delivery.getBody()));
        }
    }
}

工作队列

在这里插入图片描述

工作队列，生产者将消息分发给多个消费者，如果生产者生产了100条消息，消费者1消费50条，消费者2消费50条。
生产者

/**
  多对多模式的生产者，会发送多条消息到队列中
 */
public class WorkProductor {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(MQUtils.QUEUE_NAME,false,false,false,null);
        for(int i = 0;i < 100;i++){
            String msg = "Hello-->" + i;
            channel.basicPublish("",MQUtils.QUEUE_NAME,null, msg.getBytes());
            System.out.println("send:" + msg);
            Thread.sleep(10);
        }
        channel.close();
        connection.close();
    }
}

消费者1

/**
 * 多对多模式的消费者1
 */
public class WorkConsumer01 {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(MQUtils.QUEUE_NAME,false,false,false,null);
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //消费者消费通道中的消息
        channel.basicConsume(MQUtils.QUEUE_NAME,true,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("WorkConsumer1 receive :" + new String(delivery.getBody()));
            Thread.sleep(10);
        }
    }
}

消费者2

/**
 * 多对多模式的消费者2
 */
public class WorkConsumer02 {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(MQUtils.QUEUE_NAME,false,false,false,null);
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //消费者消费通道中的消息
        channel.basicConsume(MQUtils.QUEUE_NAME,true,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("WorkConsumer2 receive :" + new String(delivery.getBody()));
            Thread.sleep(1000);
        }
    }
}

生产者发送100个消息，两个消费者分别读取了50条。
看消息内容，发现队列发送消息采用的是轮询方式，也就是先发给消费者1，再发给消费者2，依次往复。

能者多劳

上面案例中有一个问题：消费者处理消息的速度是不一样的，消费者1处理后睡眠10毫秒（Thread.sleep(10)），消费者2是1000毫秒，速度相差100倍，但是最后处理的消息数还是一样的。这样就存在效率问题：处理能力强的消费者得不到更多的消息。

因为队列默认采用是自动确认机制，消息发过去后就自动确认，队列不清楚每个消息具体什么时间处理完，所以平均分配消息数量。

实现能者多劳：

  1. channel.basicQos(1);限制队列一次发一个消息给消费者，等消费者有了反馈，再发下一条
  2. channel.basicAck 消费完消息后手动反馈，处理快的消费者就能处理更多消息
  3. basicConsume 中的参数改为false
/**
多对多模式的消费者1
*/
public class WorkConsumer1 {

   public static void main(String[] args) throws IOException, InterruptedException {
       Connection connection = MQUtils.getConnection();
       Channel channel = connection.createChannel();
       channel.queueDeclare(MQUtils.QUEUE_NAME,false,false,false,null);
       //同一时刻服务器只发送一条消息给消费者
       channel.basicQos(1);
       QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
       //true是自动返回完成状态，false表示手动
       channel.basicConsume(MQUtils.QUEUE_NAME,false,queueingConsumer);
       while(true){
           QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
           System.out.println("WorkConsumer1 receive :" + new String(delivery.getBody()));
           Thread.sleep(10);
           //手动确定返回状态，不写就是自动确认
           channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
       }
   }
}
   
/**
 * 多对多模式的消费者2
*/
public class WorkConsumer2 {

   public static void main(String[] args) throws IOException, InterruptedException {
       Connection connection = MQUtils.getConnection();
       Channel channel = connection.createChannel();
       channel.queueDeclare(MQUtils.QUEUE_NAME,false,false,false,null);
       //同一时刻服务器只发送一条消息给消费者
       channel.basicQos(1);
       QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
       //true是自动返回完成状态，false表示手动
       channel.basicConsume(MQUtils.QUEUE_NAME,false,queueingConsumer);
       while(true){
           QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
           System.out.println("WorkConsumer2 receive :" + new String(delivery.getBody()));
           Thread.sleep(1000);
           //手动确定返回状态，不写就是自动确认
           channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
       }
   }
}

发布/订阅

在这里插入图片描述
发布/订阅模式和Work模式的区别是：Work模式只存在一个队列，多个消费者共同消费一个队列中的消息；而发布订阅模式存在多个队列，不同的消费者可以从各自的队列中处理完全相同的消息。
实现步骤：

  1. 创建交换机（Exchange）类型是fanout（扇出）
  2. 交换机需要绑定不同的队列
  3. 不同的消费者从不同的队列中获得消息
  4. 生产者发送消息到交换机
  5. 再由交换机将消息分发到多个队列

新建队列
在这里插入图片描述
新建交换机
在这里插入图片描述
点击交换机，在bindings里面绑定两个队列
在这里插入图片描述
生产者

/**
 * 发布和订阅模式的生产者，消息会通过交换机发到队列
 */
public class PublishProductor {

    public static void main(String[] args) throws IOException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        //声明fanout exchange
        channel.exchangeDeclare(MQUtils.EXCHANGE_NAME,"fanout");
        String msg = "Hello Fanout";
        //发布消息到交换机
        channel.basicPublish(MQUtils.EXCHANGE_NAME,"",null,msg.getBytes());
        System.out.println("send:" + msg);
        channel.close();
        connection.close();
    }
}

消费者1

/**
 * 发布订阅模式的消费者1
 * 两个消费者绑定的消息队列不同
 * 通过交换机一个消息能被不同队列的两个消费者同时获取
 * 一个队列可以有多个消费者，队列中的消息只能被一个消费者获取
 */
public class SubscribeConsumer1 {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(MQUtils.QUEUE_NAME,false,false,false,null);
        //绑定队列1到交换机
        channel.queueBind(MQUtils.QUEUE_NAME,MQUtils.EXCHANGE_NAME,"");
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume(MQUtils.QUEUE_NAME,true,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("Consumer1 receive :" + new String(delivery.getBody()));
        }
    }
}

消费者2

public class SubscribeConsumer2 {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(MQUtils.QUEUE_NAME2,false,false,false,null);
        //绑定队列2到交换机
        channel.queueBind(MQUtils.QUEUE_NAME2,MQUtils.EXCHANGE_NAME,"");
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume(MQUtils.QUEUE_NAME2,true,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("Consumer2 receive :" + new String(delivery.getBody()));
        }
    }
}

路由

在这里插入图片描述
路由模式的消息队列可以给队列绑定不同的key，生产者发送消息时，给消息设置不同的key，这样交换机在分发消息时，可以让消息路由到key匹配的队列中。
可以想象上图是一个日志处理系统，C1可以处理error日志消息，C2可以处理info\error\warining类型的日志消息，使用路由模式就很容易实现了。

新建direct类型的交换机
在这里插入图片描述
生产者，给myqueue01绑定了key:error，myqueue02绑定了key:debug，然后发送了key:error的消息

/**
  路由模式的生产者，发布消息会有特定的Key，消息会被绑定特定Key的消费者获取
 */
public class RouteProductor {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机类型为direct
        channel.exchangeDeclare(MQUtils.EXCHANGE_NAME2,"direct");
        String msg = "Hello-->Route";
        //绑定队列1到交换机，指定了Key为error
        channel.queueBind(MQUtils.QUEUE_NAME,MQUtils.EXCHANGE_NAME2,"error");
        //绑定队列2到交换机，指定了Key为debug
        channel.queueBind(MQUtils.QUEUE_NAME2,MQUtils.EXCHANGE_NAME2,"debug");
        //error是一个指定的Key
        channel.basicPublish(MQUtils.EXCHANGE_NAME2,"error",null,msg.getBytes());
        System.out.println("send:" + msg);
        channel.close();
        connection.close();
    }
}

消费者1

/**
 * 路由模式的消费者1
 * 可以指定Key，消费特定的消息
 */
public class RouteConsumer1 {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(MQUtils.QUEUE_NAME,false,false,false,null);
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume(MQUtils.QUEUE_NAME,true,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("RouteConsumer1 receive :" + new String(delivery.getBody()));
        }
    }
}

消费者2

/**
 * 路由模式的消费者2
 * 可以指定Key，消费特定的消息
 */
public class RouteConsumer2 {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(MQUtils.QUEUE_NAME2,false,false,false,null);
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume(MQUtils.QUEUE_NAME2,true,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("RouteConsumer2 receive :" + new String(delivery.getBody()));

        }
    }
}

主题

在这里插入图片描述
主题模式和路由模式差不多，在key中可以加入通配符：

  • * 匹配任意一个单词
  • # 匹配逗号隔开的多个单词
/**
  主题模式的生产者
 */
public class TopicProductor {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机类型为topic
        channel.exchangeDeclare(MQUtils.EXCHANGE_NAME3,"topic");
        //绑定队列到交换机，最后指定了Key
        channel.queueBind(MQUtils.QUEUE_NAME,MQUtils.EXCHANGE_NAME3,"xray.#");
        //绑定队列到交换机，最后指定了Key
        channel.queueBind(MQUtils.QUEUE_NAME2,MQUtils.EXCHANGE_NAME3,"*.*.cn");
        String msg = "Hello-->Topic";
        channel.basicPublish(MQUtils.EXCHANGE_NAME3,"rabbit.com.cn",null,msg.getBytes());
        System.out.println("send:" + msg);
        channel.close();
        connection.close();
    }
}

消费者1

/**
 * 主题模式的消费者1 ，类似路由模式，可以使用通配符对Key进行筛选
 *   #匹配1个或多个单词，*匹配一个单词
 */
public class TopicConsumer1 {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(MQUtils.QUEUE_NAME,false,false,false,null);
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume(MQUtils.QUEUE_NAME,true,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("TopicConsumer1 receive :" + new String(delivery.getBody()));
        }
    }
}

消费者2

/**
 * 主题模式的消费者2
 */
public class TopicConsumer2 {

    public static void main(String[] args) throws IOException, InterruptedException {
        Connection connection = MQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(MQUtils.QUEUE_NAME2,false,false,false,null);
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume(MQUtils.QUEUE_NAME2,true,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("TopicConsumer2 receive :" + new String(delivery.getBody()));
        }
    }
}
阳光宅男dh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【RabbitMQ】什么是RabbitMQ？RabbitMQ有什么用？应用场景有那些？
四季轮换叶，一路招摇胜
09-27 3万+
RabbitMQ简称MQ是一套实现了高级消息队列协议的开源消息代理软件，简单来说就是一个消息中间件。是一种程序对程序的通信方法。
深入浅出RabbitMQ
01-07
目录 一、RabbitMQ的基本概念 二、RabbitMQ集群 一、RabbitMQ的基本概念     RabbitMQ是一款功能丰富的传统消息队列，代表性的功能包括：消息持久化、消息确认、死信队列、消息消费端限流，丰富的功能特性是选择RabbitMQ的首要理由。RabbitMQ遵循AMQP协议，AMQP的模型如下：     相关概念如下：1、Producer：消息生产者；2、Broker：即RabbitMQ serveice提供者；3、Virtual Host：RabbitMQ是多租户系统，一个Broker支持多个Virtual Host，这些Virtual Host之间是彼此隔离的，Vi
第八节 使用RabbitMQ异步解耦（提高性能）
大宇的博客，欢迎访问
02-22 4757
一、基本思路 假设我们有一个"更新用户"的业务，此业务需要花费1秒钟时间。 然后需要为当前系统"记录日志"，日志需要记录用户操作的方法名以及模块名称，此操作需要花费3秒。 上述两个步骤在同步情况下(主线程顺序执行)需要 1+3 = 4秒。如果将"记录日志"的操作从"更新用户"的业务中异步解耦出来，即"记录日志"交给消息中间件使用另外一个线...
一文把RabbitMQ讲透了，佩服！
Admans的专栏
07-26 284
常见的消息队列很多，主要包括RabbitMQ、Kafka、RocketMQ和ActiveMQ，相关的选型可以看我之前的系列，这篇文章只讲RabbitMQ，先讲原理，后搞实战。不BB，直接上思维导图消息队列目前主要2种模式，分别为“点对点模式”和“发布/订阅模式”。一个具体的消息只能由一个消费者消费，多个生产者可以向同一个消息队列发送消息，但是一个消息在被一个消息者处理的时候，这个消息在队列上会被锁住或者被移除并且其他消费者无法处理该消息。单个消息可以被多个订阅者并发的获取和处理。...
RabbitMQ单机安装
嘻哈记的运维学习之路
11-17 555
RabbitMQ介绍1.RabbitMQ简介2.Centos7上安装RabbitMQ（单机）2.1 安装erlang2.2 安装rabbitmq2.3 启动rabbitmq2.4 开启RabbitMQ网页访问3.rabbitmq常用命令3.1 虚拟机管理3.2 用户管理3.2.1 用户的增删改密3.2.2用户的tags3.2.3 插件管理3.2.4 限制3.2.4 其他 1.RabbitMQ简介 官网：https://www.rabbitmq.com RabbitMQ是一款在全球范围内使用非常广泛的开源
MQ（Message Queue消息队列）
2301_77664771的博客
07-15 656
2007 年发布，是一个在 AMQP(高级消息队列协议)基础上完成的，可复用的企业消息系统，是当前最主流的消息中间件之一。RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue 高级消息队列协议 ）的开源实现，由于erlang 语言的高并发特性，性能较好，本质是个队列，FIFO 先入先出，里面存放的内容是messageRabbitMQ是一个消息中间件:它接受并转发消息。
rabbitMQ的详细介绍
热门推荐
wang20010104的博客
04-07 7万+
rabbitMQ的详细介绍
6、RabbitMQ---消息应答
weixin_45608577的博客
07-27 209
1、 概念 消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成了部分突然它挂掉了，会发生什么情况。RabbitMQ 一旦向消费者传递了一条消息，便立即将该消息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息。以及后续发送给该消费这的消息，因为它无法接收到。为了保证消息在发送过程中不丢失，rabbitmq 引入消息应答机制，消息应答就是:消费者在接收到消息并且处理该消息之后，告诉 rabbitmq 它已经处理了，rabbitmq 可以把该消息删除了。 2、
RabbitMQ学习——常见概念详解
日积月累，天道酬勤
12-08 507
文章目录Exchange描述结构图交换机属性Direct ExchangeTopic ExchangeFanout ExchangeBindingQueue属性Message属性Virtual host - 虚拟主机 Exchange 描述 用于接收消息，并根据路由键转发消息到所绑定的队列 结构图 蓝色框表示发送消息，然后消息通过路由关系路由到Queue1或Queue2 绿色框表示接收消息，消费...
RabbitMQ基础概念详细介绍
woailuohui的专栏
08-14 9005
RabbitMQ简介 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。RabbitMQ是一个开源的AMQP实现，服务器端用Erl...
RabbitMQ的一个demo
05-22
RabbitMQ的一个demo，实现简单的消息队列，先执行sender，后执行recv。环境需要：Springboot+gradle
浅谈spring-boot-rabbitmq动态管理的方法
08-28
主要介绍了浅谈spring-boot-rabbitmq动态管理的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
RabbitMQ的一个调试工具
04-07
在微服务架构下，少不了使用MQ和Redis,为了方便调试，制作了一个简单的RabbitMQ的调试工具，不用总是进入15672去看，主要是觉得麻烦。 工具具备创建Exchange,Queue,发布和订阅，自动应答处理等常用的消息处理操作。 ...
RabbitMQ基本概念和使用
01-30
例如一个日志系统，很容易使用RabbitMQ简化工作量，一个Consumer进行消息的正常处理，另一个Consumer复制对消息进行日志记录，只要在程序中指定两个Consumer所监听的queue以相同的方式绑定到同一个exchange即可，...
消息队列 RabbitMQ python实战
jacke121的专栏
04-29 1064
消息队列 RabbitMQ python实战
【消息队列】RabbitMQ五种消息模式
weixin_62513677的博客
04-30 2110
Spring AMQP是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息，包含两部分，其中Spring-amqp是基础抽象，spring-rabbit是底层的默认实现。这是为了防止消息队列中的队列不存在，在进行消息队列初始化的时候不知道是先建立消费者，还是先建立生产者，所以都执行创建函数，但是创建的队列只有一个不会重复。发布者发送消息时，指定消息的RoutingKey，Exchange将消息路由到BindingKey与消息RoutingKey一致的队列。Work queue，工作队列。
RabbitMQ之基础入门
CSDN_LiMingfly的博客
04-30 1399
在 AMQP 中，Producer 将消息发送到 Exchange ，再由 Exchange 将消息路由到一个或多个 Queue 中（或者丢弃）。Exchange 根据 Routing Key 和 Binding Key 将消息路由到 Queue ，目前提供了四种类型。A. QueueQueue: Queue（队列）是RabbitMQ的内部对象，用于存储消息,RabbitMQ 中的消息都只能存储在 Queue 中,生产消息并最终投递到Queue中, 消费者可以从Queue中获取消息并消费。
RabbitMQ之消费者并发消费
CSDN_LiMingfly的博客
05-01 428
当生产者的推送速度是远远超过消费者的能力的，可以提高消费者的消费速度。比如在java中我们可以启动多个 JVM 进程，实现多进程的并发消费，从而加速消费的速度，在mq中也可以通过设置配置。Consumer 线程，负责从 RabbitMQ Broker 获取 Queue 中的消息，存储到内存中的 BlockingQueue 阻塞队列中。@RabbitListener 注解中，有 concurrency 属性，它可以指定并发消费的线程数。若需完整代码 可识别二维码后 给您发代码。
RabbitMQ之消费者批量消费
最新发布
CSDN_LiMingfly的博客
05-01 552
在一些业务场景下，我们希望使用 Consumer 批量消费消息，提高消费速度。可以通过对 SimpleRabbitListenerContainerFactory 进行配置实现批量消费能力。若需完整代码 可识别二维码后 给您发代码。
写一个rabbitmq的dockerfile
06-08
好的，下面是一个基本的 RabbitMQ Dockerfile，你可以根据自己的需要进行修改： ``` FROM rabbitmq:3.8.3-management-alpine # 安装一些必要的工具 RUN apk update && \ apk add --no-cache bash && \ apk add -...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值