发帖
翼度科技»论坛 › 云主机 › 服务器技术 › 查看内容

Docker启动RabbitMQ实现生产者与消费者的详细过程

富裕来袭

7

主题

7

帖子

21

积分

新手上路

Rank: 1

积分
21
显示全部楼层
一、Docker拉取镜像并启动RabbitMQ

拉取镜像
  1. docker pull rabbitmq:3.8.8-management
复制代码
查看镜像
  1. docker images rabbitmq
复制代码

  启动镜像
  1. docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:3.8.8-management
复制代码
Linux虚拟机记得开放5672端口或者关闭防火墙，在window通过 主机ip:15672 访问rabbitmq控制台

  用户名密码默认为guest


二、Hello World


（一）依赖导入

  1. <!--指定 jdk 编译版本-->
  2.     <build>
  3.         <plugins>
  4.             <plugin>
  5.                 <groupId>org.apache.maven.plugins</groupId>
  6.                 <artifactId>maven-compiler-plugin</artifactId>
  7.                 <configuration>
  8.                     <source>8</source>
  9.                     <target>8</target>
  10.                 </configuration>
  11.             </plugin>
  12.         </plugins>
  13.     </build>
  14.     <dependencies>
  15.         <!--rabbitmq 依赖客户端-->
  16.         <dependency>
  17.             <groupId>com.rabbitmq</groupId>
  18.             <artifactId>amqp-client</artifactId>
  19.             <version>5.8.0</version>
  20.         </dependency>
  21.         <!--操作文件流的一个依赖-->
  22.         <dependency>
  23.             <groupId>commons-io</groupId>
  24.             <artifactId>commons-io</artifactId>
  25.             <version>2.6</version>
  26.         </dependency>
  27.     </dependencies>
复制代码

（二）消息生产者

工作原理



  • Broker：接收和分发消息的应用，RabbitMQ Server 就是 Message Broker
  • Connection：publisher／consumer 和 broker 之间的 TCP 连接
  • Channel：如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection 的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个 thread 创建单独的 channel 进行通讯，AMQP method 包含了 channel id 帮助客户端和 message broker 识别 channel，所以 channel 之间是完全隔离的。Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销
  • Exchange：message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到 queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and fanout (multicast)
  • Queue：消息最终被送到这里等待 consumer 取走
我们需要先获取连接(Connection)，然后通过连接获取信道(Channel)，这里我们演示简单例子，可以直接跳过交换机(Exchange)发送队列(Queue)
  1. public class Producer {

  3.     private final static String QUEUE_NAME = "hello";

  5.     public static void main(String[] args) throws Exception {
  6.         //创建一个连接工厂
  7.         ConnectionFactory factory = new ConnectionFactory();
  8.         // 设置主机ip
  9.         factory.setHost("182.92.234.71");
  10.         // 设置用户名
  11.         factory.setUsername("guest");
  12.         // 设置密码
  13.         factory.setPassword("guest");
  14.         //channel 实现了自动 close 接口 自动关闭 不需要显示关闭
  15.         Connection connection = factory.newConnection();
  16.         // 获取信道
  17.         Channel channel = connection.createChannel();
  18.         /*
  19.          * 生成一个队列
  20.          * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
  21.                                  Map<String, Object> arguments)
  22.          * 1.队列名称
  23.          * 2.队列里面的消息是否持久化 默认消息存储在内存中
  24.          * 3.该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
  25.          * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true 自动删除
  26.          * 5.其他参数
  27.          **/
  28.         channel.queueDeclare(QUEUE_NAME, false, false, false, null);
  29.         String message = "hello rabbitmq";
  30.         /*
  31.          * 发送一个消息
  32.          * basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
  33.          * 1.发送到哪个交换机
  34.          * 2.路由的key是哪个
  35.          * 3.其他的参数信息
  36.          * 4.发送消息的消息体
  37.          *
  38.          **/
  39.         channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
  40.         System.out.println("发送成功");
  41.     }
  42. }
复制代码

（三）消息消费者

  1. public class Consumer {

  3.     private static final String QUEUE_NAME = "hello";

  5.     public static void main(String[] args) throws Exception {
  6.         //创建一个连接工厂
  7.         ConnectionFactory factory = new ConnectionFactory();
  8.         // 设置主机ip
  9.         factory.setHost("182.92.234.71");
  10.         // 设置用户名
  11.         factory.setUsername("guest");
  12.         // 设置密码
  13.         factory.setPassword("guest");
  14.         //channel 实现了自动 close 接口 自动关闭 不需要显示关闭
  15.         Connection connection = factory.newConnection();
  16.         // 获取信道
  17.         Channel channel = connection.createChannel();

  19.         // 推送的消息如何进行消费的回调接口
  20.         DeliverCallback deliverCallback = (consumerTag, message) -> {
  21.             System.out.println(new String(message.getBody()));
  22.         };
  23.         // 取消消费的一个回调接口，如在消费的时候队列被删除了
  24.         CancelCallback cancelCallback = (consumerTag) -> {
  25.             System.out.println("消息消费被中断");
  26.         };
  27.         /*
  28.          * 消费者消费消息
  29.          * basicConsume(String queue, boolean autoAck,
  30.          * DeliverCallback deliverCallback, CancelCallback cancelCallback)
  31.          * 1.消费哪个队列
  32.          * 2.消费成功之后是否要自动应答 true 代表自动应答 false 手动应答
  33.          * 3.消费者未成功消费的回调
  34.          **/
  35.         channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
  36.     }
  37. }
复制代码

三、实现轮训分发消息


（一）抽取工具类

可以发现，上面获取连接工厂，然后获取连接，再获取信道的步骤是一致的，我们可以抽取成一个工具类来调用，并使用单例模式-饿汉式完成信道的初始化
  1. public class RabbitMqUtils {

  3.     private static Channel channel;

  5.     static {
  6.         ConnectionFactory factory = new ConnectionFactory();
  7.         // 设置ip地址
  8.         factory.setHost("192.168.23.100");
  9.         // 设置用户名
  10.         factory.setUsername("guest");
  11.         // 设置密码
  12.         factory.setPassword("guest");
  13.         try {
  14.             // 创建连接
  15.             Connection connection = factory.newConnection();
  16.             // 获取信道
  17.             channel = connection.createChannel();
  18.         } catch (Exception e) {
  19.             System.out.println("创建信道失败，错误信息：" + e.getMessage());
  20.         }
  21.     }

  23.     public static Channel getChannel() {
  24.         return channel;
  25.     }
  26. }
复制代码

（二）启动两个工作线程

相当于前面的消费者，我们只需要写一个类，通过ideal实现多线程启动即可模拟两个线程
  1. public class Worker01 {

  3.     private final static String QUEUE_NAME = "hello";

  5.     public static void main(String[] args) throws Exception {
  6.         Channel channel = RabbitMqUtils.getChannel();
  7.         DeliverCallback deliverCallback = ( consumerTag,  message) -> {
  8.             System.out.println("接受到消息：" + new String(message.getBody()));
  9.         };
  10.         CancelCallback cancelCallback = (cunsumerTag) -> {
  11.             System.out.println("消费者取消消费接口回调逻辑");
  12.         };
  13.         // 启动两次，第一次为C1， 第二次为C2
  14.         System.out.println("C2消费者等待消费消息");
  15.         channel.basicConsume(QUEUE_NAME, true, deliverCallback,cancelCallback);
  16.     }
  17. }
复制代码

（三）启动发送线程

  1. public class Test01 {

  3.     private final static String QUEUE_NAME = "hello";

  5.     public static void main(String[] args) throws IOException {
  6.         Channel channel = RabbitMqUtils.getChannel();

  8.         channel.queueDeclare(QUEUE_NAME, false, false, false, null);
  9.         // 通过控制台输入充当消息，使轮训演示更明显
  10.         Scanner scanner = new Scanner(System.in);
  11.         while(scanner.hasNext()) {
  12.             String message = scanner.next();
  13.             channel.basicPublish("", QUEUE_NAME,null, message.getBytes() );
  14.             System.out.println("消息发送完成：" + message);
  15.         }
  16.     }
  17. }
复制代码
结果


四、实现手动应答


（一）消息应答概念

消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成 了部分突然它挂掉了，会发生什么情况。RabbitMQ 一旦向消费者传递了一条消息，便立即将该消 息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息。以及后续 发送给该消费这的消息，因为它无法接收到。 为了保证消息在发送过程中不丢失，rabbitmq 引入消息应答机制，消息应答就是: 消费者在接 收到消息并且处理该消息之后，告诉 rabbitmq 它已经处理了，rabbitmq 可以把该消息删除了。
  1. <strong>自动应答</strong>：消费者发送后立即被认为已经传送成功。这种模式需要在<strong>高吞吐量和数据传输安全性方面做权</strong><strong>衡</strong>,因为这种模式如果消息在接收到之前，消费者那边出现连接或者 channel 关闭，那么消息就丢失了。当然另一方面这种模式消费者那边可以传递过载的消息， <strong>没有对传递的消息数量进行限制</strong> ， 当然这样有可能使得消费者这边由于接收太多还来不及处理的消息，导致这些消息的积压，最终 使得内存耗尽，最终这些消费者线程被操作系统杀死，<strong>所以这种模式仅适用在消费者可以高效并</strong> <strong>以某种速率能够处理这些消息的情况下使用</strong> 。
复制代码
  1. <strong>手动应答</strong>：消费者接受到消息并顺利完成业务后再调用方法进行确认，<strong>rabbitmq 才可以把该消息删除</strong>
复制代码

（二）消息应答的方法



  • Channel.basicAck(用于肯定确认)
  • RabbitMQ 已知道该消息并且成功的处理消息，可以将其丢弃了
  • Channel.basicNack(用于否定确认)
  • Channel.basicReject(用于否定确认)
  • 与 Channel.basicNack 相比少一个参数Multiple
  • multiple 的 true 和 false 代表不同意思
         true 代表批量应答 channel 上未应答的消息
        比如说 channel 上有传送 tag 的消息 5,6,7,8 当前 tag 是 8 那么此时
        5-8 的这些还未应答的消息都会被确认收到消息应答
        false 同上面相比
        只会应答 tag=8 的消息 5,6,7 这三个消息依然不会被确认收到消息应答


  • 不处理该消息了直接拒绝，可以将其丢弃了


（三）消息自动重新入队

如果消费者由于某些原因失去连接(其通道已关闭，连接已关闭或 TCP 连接丢失)，导致消息未发送 ACK 确认，RabbitMQ 将了解到消息未完全处理，并将对其重新排队。如果此时其他消费者可以处理，它将很快将其重新分发给另一个消费者。这样，即使某个消费者偶尔死亡，也可以确 保不会丢失任何消息。


（四）消息手动应答代码


1、生产者

  1. public class Test01 {

  3.     private final static String QUEUE_NAME = "ack";

  5.     public static void main(String[] args) throws IOException {
  6.         Channel channel = RabbitMqUtils.getChannel();

  8.         channel.queueDeclare(QUEUE_NAME, false, false, false, null);
  9.         Scanner scanner = new Scanner(System.in);
  10.         while(scanner.hasNext()) {
  11.             String message = scanner.next();
  12.             channel.basicPublish("", QUEUE_NAME,null, message.getBytes() );
  13.             System.out.println("消息发送完成：" + message);
  14.         }
  15.     }
  16. }
复制代码

2、睡眠工具类模拟业务执行

  1. public class SleepUtils {

  3.     public static void sleep(int second) {
  4.         try {
  5.             Thread.sleep(1000 * second);
  6.         } catch (InterruptedException _ignored) {
  7.             Thread.currentThread().interrupt();
  8.         }
  9.     }
  10. }
复制代码

3、消费者

  1. public class Worker01 {

  3.     private final static String QUEUE_NAME = "ack";

  5.     public static void main(String[] args) throws Exception {
  6.         System.out.println("C1，业务时间短");
  7.         Channel channel = RabbitMqUtils.getChannel();
  8.         DeliverCallback deliverCallback = ( consumerTag,  message) -> {
  9.             SleepUtils.sleep(1);  // 模拟业务执行1秒
  10.             System.out.println("接受到消息：" + new String(message.getBody()));
  11.             /*
  12.              * 1、消息标识
  13.              * 2、是否启动批量确认，false：否。
  14.              *    启用批量有可能造成消息丢失，比如未消费的消息提前被确然删除，后面业务消费该消息
  15.              *    时出现异常会导致该消息的丢失
  16.              */
  17.             channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
  18.         };
  19.         CancelCallback cancelCallback = (cunsumerTag) -> {
  20.             System.out.println("消费者取消消费接口回调逻辑");
  21.         };
  22.         boolean autoAck = false;
  23.         channel.basicConsume(QUEUE_NAME, autoAck, deliverCallback,cancelCallback);
  24.     }
  25. }

  27. ==============================================================================
  28. public class Worker02 {

  30.     private final static String QUEUE_NAME = "ack";

  32.     public static void main(String[] args) throws Exception {
  33.         System.out.println("C2，业务时间长");
  34.         Channel channel = RabbitMqUtils.getChannel();
  35.         DeliverCallback deliverCallback = ( consumerTag,  message) -> {
  36.             SleepUtils.sleep(15);  // 模拟业务执行15秒
  37.             System.out.println("接受到消息：" + new String(message.getBody()));
  38.             /*
  39.              * 1、消息标识
  40.              * 2、是否启动批量确认，false：否。
  41.              *    启用批量有可能造成消息丢失，比如未消费的消息提前被确然删除，后面业务消费该消息
  42.              *    时出现异常会导致该消息的丢失
  43.              */
  44.             channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
  45.         };
  46.         CancelCallback cancelCallback = (cunsumerTag) -> {
  47.             System.out.println("消费者取消消费接口回调逻辑");
  48.         };
  49.         boolean autoAck = false;
  50.         channel.basicConsume(QUEUE_NAME, autoAck, deliverCallback,cancelCallback);
  51.     }
  52. }
复制代码
worker01业务时间短，worker02业务时间长，我们提前终止worker02模拟出异常，可以看到消息dd会被放回队列由worker01接收处理。
注意：这里需要先启动生产者声明队列ack，不然启动消费者会报错

最后一个案例我们可以看到消息轮训+消息自动重新入队+手动应答。
到此这篇关于Docker启动RabbitMQ，实现生产者与消费者的文章就介绍到这了,更多相关Docker启动RabbitMQ内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源:https://www.jb51.net/article/276222.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！

上一篇: Dubbo 系列JDK SPI 原理解析

下一篇: k8s Ingress使用详解(云原生kubernetes)

发表于 2023-2-25 10:20:04

举报 回复 使用道具

返回列表 发新帖

Archiver|手机版|小黑屋|翼度科技

Copyright © 2001-2020, Tencent Cloud.　Powered by Discuz! X3.4