RabbitMQ（一）----simple、work queues

最新推荐文章于 2023-11-21 14:03:46 发布
最新推荐文章于 2023-11-21 14:03:46 发布
阅读量143 收藏
点赞数
分类专栏： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42727102/article/details/103583715
版权

一.simple简单队列
在这里插入图片描述
1.导入依赖jar包

<dependency>
      <groupId>com.rabbitmq</groupId>
      <artifactId>amqp-client</artifactId>
      <version>4.0.2</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.10</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.5</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

2.获取rabbitmq的连接
ConnectionUtils.java

public class ConnectionUtils {
    /**
     * 获取rabbitmq的连接
     * @return
     */
    public static Connection getConnection() throws IOException, TimeoutException {
        //定义一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //设置服务地址
        factory.setHost("127.0.0.1");

        //AMQP 5672
        factory.setPort(5672);

        //virtualHost 相当于就是数据库
        factory.setVirtualHost("/db1");

        //用户名
        factory.setUsername("xuanxuanxuan");
        //密码
        factory.setPassword("12345678");

        return factory.newConnection();
    }
}

Send.java 生产者生产消息

public class Send {
    private static final String QUEUE_NAME = "test_simple_queue";
    public static void main(String[] args) throws Exception{
        //创建一个连接
        Connection connection = ConnectionUtils.getConnection();

        //从连接中获取一个通道
        Channel channel = connection.createChannel();

        //创建队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        String msg = "hello simple !";
        channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
        System.out.println("----send msg:"+msg);


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

Receive.java 消费者消费消息

/**
 * 消费者获取消息
 */
public class Receive {
    private static final String QUEUE_NAME = "test_simple_queue";
    public static void main(String[] args) throws Exception{
        //获取连接
        Connection connection = ConnectionUtils.getConnection();

        //根据连接得到通道
        Channel channel = connection.createChannel();

        //定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);//旧的api

        //监听队列
        channel.basicConsume(QUEUE_NAME,true,consumer);
        while (true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();

            String msgString = new String(delivery.getBody());
            System.out.println("[receive] msg:"+msgString);
        }
    }
}

新版api

 public static void main(String[] args) throws Exception{
        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //队列声明
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
		
     	//定义消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //获取到到达的消息
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msgString = new String(body, "utf-8");
                System.out.println("new api receive:" + msgString);
            }
        };

        //监听队列
        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);
    }

二.work queues 工作队列 公平分发 轮询分发

简单队列的不足：耦合性高，生产者一一对应消费者（如果我想有多个消费者消费队列中的消息，这时候就不行了），队列名变更，这时候得同时变更。
在这里插入图片描述
为什么会出现工作队列？

​ Simple队列是一一对应的，而且我们实际开发，生产者发送消息是毫不费力的，而消费者一般是要跟业务相结合的。消费者接收到消息之后就需要处理，可能需要花费时间，这时候队列就会积压很多消息，一个消费者不够消费这些消息，这时候就需要多个消费者来消费。

1轮询分发

Send.java 生产者

public class Send {
    private static final String QUEUE_NAME = "test_work_queues";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();

        //获取channel
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        for (int i = 0; i < 50; i++) {
            String msg = UUID.randomUUID().toString();

            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            TimeUnit.MILLISECONDS.sleep(20);
        }

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

Receive1.java 消费者1

public class Receive1 {
    private static final String QUEUE_NAME = "test_work_queues";
    private static int i = 1;

    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //创建消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //一旦有消息就会触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String str = new String(body,"utf-8");
                System.out.println("[1] receive :"+str+"   "+(i++));
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        //监听队列
        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);
    }
}

Receive2.java

public class Receive2 {
    private static final String QUEUE_NAME = "test_work_queues";
    private static int i = 1;

    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //创建消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //一旦有消息就会触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String str = new String(body,"utf-8");
                System.out.println("[2] receive :"+str+"   "+(i++));
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        //监听队列
        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);
    }
}

现象：消费者1和消费者2处理的消息是一样的，是均分的。这就是轮询分发（round-robin），结果就是无论忙与不忙，都不会多给一个任务，任务消息总是你一个我一个，轮换着来。

2公平分发 fair dipath

即能者多得

Send.java

public class Send {
    private static final String QUEUE_NAME = "test_work_queues";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();

        //获取channel
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        /**
         * 每个消费者发送确认消息之前，消息队列不发送下一个消息到消费者，一次只处理一个消息
         * 限制发送给同一个消费者，不得超过一条消息
         */
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);
        for (int i = 0; i < 50; i++) {
            String msg = UUID.randomUUID().toString();

            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            TimeUnit.MILLISECONDS.sleep(20);
        }

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

Receive1.java

public class Receive1 {
    private static final String QUEUE_NAME = "test_work_queues";
    private static int i = 1;

    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //获取通道
        final Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        channel.basicQos(1);//保证一次只分发一个
        //创建消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //一旦有消息就会触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String str = new String(body,"utf-8");
                System.out.println("[1] receive :"+str+"   "+(i++));
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1] done");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };

        //监听队列   autoAck=false   即第二个参数改为false  不让其自动应答
        channel.basicConsume(QUEUE_NAME,false,defaultConsumer);
    }
}

Receive2.java

public class Receive2 {
    private static final String QUEUE_NAME = "test_work_queues";
    private static int i = 1;

    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //获取通道
        final Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        channel.basicQos(1);
        //创建消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //一旦有消息就会触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String str = new String(body,"utf-8");
                System.out.println("[2] receive :"+str+"   "+(i++));
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[2] done ");
                    //手动回执
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };

        //监听队列  不让其自动应答
        channel.basicConsume(QUEUE_NAME,false,defaultConsumer);
    }
}

3消息应答与消息持久化
消息应答：

boolean autoAck = false；

channel.basicConsume(QUEUE_NAME,autoAck,consumer);

boolean autoAck = true；//自动确认模式 一旦rabbitmq将消息分发给消费者，就会从内存中删除

这种情况下，如果杀死正在执行的消费者，就会丢失正在处理的消息

boolean autoAck = false；手动模式 如果一个消费者挂掉，就会交付给其他消费者。rabbitmq支持消息应答，消费者发送一个消息应答，告诉rabbitmq这个消息我已经处理完成，你可以删了，然后rabbitmq就删除内存中的消息

消息应答默认是打开的，false。

如果rabbitmq挂掉了，那么消息也会丢失。

消息持久化：

boolean durable = false;

channel.queueDeclare(QUEUE_NAME,durable,false,false,null);

我们将程序中的boolean durable = false;改成true；是不可以的，即使代码是正确的，他也不会运行成功的！因为我们已经定义了一个叫test_work_queue，这个queue是未持久化的。rabbitmq不允许重新定义（不同参数）一个已存在的队列。

解决方案：①在控制台将这个队列删除掉

​ ②修改队列名

哦吼~
关注
专栏目录
RabbitMQ-全面详解（学习总结---从入门到深化）
12-05 641
如果在系统中引入MQ，即订单系统将消息先发送到MQ中，MQ再 转发到其他系统，则会解决以下问题：如果订单系统同步访问每个系统，则用户下单等待时长如下： 如果引入MQ，则用户下单等待时长如下：假设我们的系统每秒只能承载1000请求，如果请求瞬间增多到每秒 5000，则会造成系统崩溃。此时引入mq即可解决该问题 RabbitMQ是由Erlang语言编写的基于AMQP的MQ产品。即Advanced Message Queuing Protocol(高级消息队列协议)，是 一个网络协议，专门为消息中间件设计。基于
rabbitMQ(1)rabbitMQ入门,simple work
weixin_42276962的博客
06-10 150
环境配置 安装erlang；https://www.erlang.org/downloads Windows环境的话可以直接下载exe文件到本地,直接右键以管理员身份运行,安装完成后需要配置环境变量 安装rabbitMQ；http://www.rabbitmq.com/ Windows环境的话可以直接下载exe文件到本地,直接右键以管理员身份运行 安装RabbitMQ的图形管理界面插件；在rabbitmq的安装目录下找到sbin目录，进入并在此目录打开cmd窗口执行rabbitmq-plugins
RabbitMQ学习笔记4-五种模式之二（simple、work）
代码还是得自己扣
06-29 913
simple queue模式 模型 描述 是一个一对一的简单模式，即一个生产者和一个消费者。 代码 生产者 package com.lin.rabbit.simple; import java.io.IOException; import java.util.concurrent.TimeoutException; import com.lin.rabbit.utils.ConnectionUt......
rabbitmq 所需jar包
03-27
rabbitmq，amqp-client，spring-amqp，spring-rabbit，spring-retry JAR包合集
rabbitmq安装包包括依赖rabbitmq安装包包括依赖
12-15
rabbitmq安装包包括依赖,erlang官网下载慢，所以上传到csdn
Java实现RabbitMQ以及Jar包的实现
热门推荐
Tom.Su的博客
03-28 1万+
java实现rabbitMQ的通讯测试之helloWorld，和打成jar运行。
初学RabbitMq---springboot控制mq
m0_62104821的博客
11-21 186
项目创建：创建一个父工程，再创建两个子工程，其均为springboot在父工程的pom中添加如下代码（子工程就不用再加了）在两个子工程中的application.yml中添加如下配置在web端的Rabbitmq中添加simple.queue。
RabbitMQ - 高级
Shine bright like a diamond ！
11-16 1134
每个RabbitTemplate只能配置一个ReturnCallback，因此需要在项目加载时配置：修改publisher服务ConfirmCallback可以在发送消息时指定，因为每个业务处理confirm成功或失败的逻辑不一定相同。// 1.消息体 String message = "hello, spring amqp!
RabbitMQ --- SpringAMQP
乌云的博客
04-25 559
SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。
rabbitmq--消息中间件&&五种模式的应用
qq_54605990的博客
04-20 156
rabbitMQ–消息中间件 一、什么是MQ？ MQ 是message queue ,消息队列，也叫消息中间件，是再消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。遵守JMS（java message service）规范的一种软件。(同时还有另一个叫AMQP的应用层协议，语言无关性不受产品 语言等限制，rabbitMQ支持这个 ) 是类似于数据库一样需要独立部署在服务器上的一种应用，提供接口给其他系统调用。 主要用于各个系统之间通信的解耦。 二、MQ的优缺点 优点： 异步处理：相比于传统的
rabbitmq详解
m0_67401499的博客
07-29 456
RabbitMQ是一个实现了AMQP（AdvancedMessageQueuingProtocol）高级消息队列协议的消息队列服务，用Erlang语言。是面向消息的中间件。你可以把它想像成一个邮局你把信件放入邮箱，邮递员就会把信件投递到你的收件人处。在这个比喻中，RabbitMQ是一个邮箱、邮局、邮递员。RabbitMQ和邮局的主要区别是，它处理的不是纸，而是接收、存储和发送二进制的数据——消息。主要流程。...
Spring boot 整合RabbitMQ（二）：工作队列（Work queues）
weixin_45821812的博客
03-05 584
现在，我们将发送一些字符串，把这些字符串当作复杂的任务。我们并没有一个真实的复杂任务，类似于图片大小被调整或 pdf 文件被渲染，所以我们通过 sleep () 方法来模拟这种情况。我们在字符串中加上点号（.）来表示任务的复杂程度，一个点（.）将会耗时 1 秒钟。比如 “Hello…” 就会耗时 3 秒钟。 如果您尚未设置项目，请参阅第一个教程中的设置。我们将遵循与第一个教程相同的模式：创建一个包...
spring整合rabbitmq（需要的jar包，spring如何整合rabbitmq）
三易专栏
01-15 9822
spring整合rabbitmq
RabbitMQ的常见队列模型，simple模式、work模式、fanout模式、direct模式、topic模式、headers模式、RPC
毅呀毅呀哟
09-01 5914
目录 一、simple模式 simple模式实现-生产者 simple模式实现-消费者 二、work模式（能者多劳模式） work模式实现-生产者 work模式实现-消费者 三、订阅模式-fanout fanout模式实现-生产者 fanout模式实现-消费者 四、订阅模式-direct direct模式实现-生产者 direct模式实现-消费者 五、订阅模式-topic topic模式实现-生产者 topic模式实现-消费者 六、订阅模式-headers 七...
RabbitMQ五种队列介绍（一、Simple Queue与Work Queue）
MrJDR的博客
08-09 1630
本文将从三个方便了解的RabbitMQ 1，RabbitMQ的是什么 2，为什么要有的RabbitMQ  3，RabbitMQ的五种队列的实现 一，RabbitMQ的是什么 首先在了解RabbitMQ之间我们要知道什么是MQ，MQ的全称为Message Queue也就是消息队列，是一种应用程序之间的通信方法 ;应用程序通过读写消息队列的消息（针对应用程序的数据）来通信，而无需专门用连接来...
rabbitmq几种工作模式_RabbitMQ学习
weixin_39629947的博客
11-22 357
本篇文章主要介绍了RabbitMQ这种消息队列，从消息队列的概念、应用场景、安装方式到它的核心概念、五种工作模式。在安装的时候推荐使用Docker方式进行安装。重点需要理解的就是消息队列的应用场景、核心概念和RabbitMQ的五种工作模式，其中用的比较多的就是发布订阅模式、主题模式。Message Queue队列(Queue)是一种常见的数据结构，其最大的特性就是先进先出(Firist In Fi...
SpringBoot的RabbitMQ消息队列: 三、第二模式"Work queues"
lxhjh的专栏
04-04 1万+
上一节的两个工程，一个负责发送，一个负责接收，也就是一一对于的关系。      只要消息发出了，接收者就处理；当接收效率较低时，就会出现接收者处理不过来，我们就可能会处理不过来，于是我们就可能多配置接受者。这个模式就是"Work queues",它的结构如下     多个接收者，它们会出现什么情况呢？是否像大锅饭，有的人撑死，有的人饿死。这个通过例子验证。 一、再建一个接收者工程 H
基于MATLAB的肤色的人数统计系统，以地铁车厢为实际背景，通过预测的方式，结合肤色统计人脸得到车厢人数，从而估计拥挤度
最新发布
10-04
【作品名称】：基于MATLAB的肤色的人数统计系统，以地铁车厢为实际背景，通过预测的方式，结合肤色统计人脸得到车厢人数，从而估计拥挤度 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：该课题为基于MATLAB的肤色的人数统计系统，以地铁车厢为实际背景，通过预测的方式，结合肤色统计人脸得到车厢人数，从而估计拥挤度，将结果反馈给车站里的视频，让乘客得知每节车厢的拥挤程度，从而合理分配车厢乘客，避免资源浪费和拥挤，本设计带有一个GUI交互界面。是一个人数统计类课题，该课题可以应用于教室人数统计，十字路口行人统计等等方面。 【资源声明】：本资源作为“参考资料”而不是“定制需求”，代码只能作为参考，不能完全复制照搬。需要有一定的基础能够看懂代码，能够自行调试代码并解决报错，能够自行添加功能修改代码。
LabVIEW 入门教程：从零开始掌握图形化编程
10-04
亲爱的工程师和技术爱好者们， 您是否想学习一种强大的图形化编程语言，以便在自动化、数据采集、测试测量等领域大展身手？LabVIEW 是您的最佳选择！我们为您精心准备了一份全面的 LabVIEW 入门教程，帮助您从零开始，逐步掌握这门强大的工具。 为什么选择 LabVIEW？ 直观易学：图形化编程界面，无需编写复杂的代码。 广泛应用：适用于工业自动化、数据采集、仪器控制、图像处理等多个领域。 强大功能：内置丰富的函数库和工具包，满足各种复杂需求。 社区支持：庞大的用户社区和丰富的在线资源，助您解决各种问题。 本教程适合谁？ 初学者：从未接触过 LabVIEW 的新手。 工程师：希望提升技能，提高工作效率的专业人士。 学生：对自动化和测试测量感兴趣的在校学生。 研究人员：需要进行数据采集和分析的研究人员。 课程内容 LabVIEW 基础：安装与配置、界面介绍、基本概念。 图形化编程：创建 VI（虚拟仪器）、使用控件和指示器。 数据流编程：理解数据流的概念，编写简单的程序。 常用函数库：了解并使用常用
rabbitmq --list-vhost
06-06
虚拟主机是 RabbitMQ 的一个重要概念，它可以帮助我们在一个 RabbitMQ 服务器中运行多个独立的消息代理。使用该命令需要先安装 RabbitMQ，并且在命令行中运行 `rabbitmqctl` 命令。具体使用方法如下： 1. 打开终端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值