（二）RabbitMQ消息模型——1基本消息模型

最新推荐文章于 2024-04-30 16:09:10 发布
最新推荐文章于 2024-04-30 16:09:10 发布
阅读量183 收藏
点赞数
分类专栏： RabbitMQ深入研究 文章标签： rabbitmq 队列 基本消息模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yilvqingtai/article/details/115441248
版权

目录

1. 模型简介

 2. 示例流程

2.1 生产者发送消息

2.2 消费者获取消息（自动ACK）

2.3 消息确认机制（ACK）

2.3.1 消费者获取消息（手动ACK）

2.3.2 自动ACK存在的问题

2.3.3  手动ACK

1. 模型简介

 

RabbitMQ是一个消息代理：它接受和转发消息。 你可以把它想象成一个邮局：当你把邮件放在邮箱里时，你可以确定邮差先生最终会把邮件发送给你的收件人。 在这个比喻中，RabbitMQ是邮政信箱，邮局和邮递员。

RabbitMQ与邮局的主要区别是它不处理纸张，而是接受，存储和转发数据消息的二进制数据块。

  1. P（producer/ publisher）：生产者，一个发送消息的用户应用程序。
  2. C（consumer）：消费者，消费和接收有类似的意思，消费者是一个主要用来等待接收消息的用户应用程序
  3. 队列（红色区域）：rabbitmq内部类似于邮箱的一个概念。虽然消息流经rabbitmq和你的应用程序，但是它们只能存储在队列中。队列只受主机的内存和磁盘限制，实质上是一个大的消息缓冲区。许多生产者可以发送消息到一个队列，许多消费者可以尝试从一个队列接收数据。

 

 2. 示例流程

我们将用Java编写两个程序;发送单个消息的生产者，以及接收消息并将其打印出来的消费者。我们将详细介绍Java API中的一些细节，这是一个消息传递的“Hello！！ World！！！”。

我们将调用我们的消息发布者（发送者）Send和我们的消息消费者（接收者）Recv。发布者将连接到RabbitMQ，发送一条消息，然后退出。

2.1 生产者发送消息

 

 

 

 

package com.example.demorabbitmq.simple;


import com.example.demorabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

/**
 * 生产者
 */
public class Send {

    private final static String QUEUE_NAME = "simple_queue_demo";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 从连接中创建通道，使用通道才能完成消息相关的操作
        Channel channel = connection.createChannel();
        // 声明（创建）队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 消息内容
        String message = "Hello World!";
        // 向指定的队列中发送消息
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());

        System.out.println(" [x] Sent '" + message + "'");

        //关闭通道和连接
        channel.close();
        connection.close();
    }
}

 

2.2 消费者获取消息

采用自动ACK应答机制

package com.example.demorabbitmq.simple;

import java.io.IOException;

import com.example.demorabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;


/**
 * 消费者
 */
public class Recv {
    private final static String QUEUE_NAME = "simple_queue_demo";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [x] received : " + msg + "!");
            }
        };
        // 监听队列，第二个参数：是否自动进行消息确认。
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

我们发现，消费者已经获取了消息，但是程序没有停止，一直在监听队列中是否有新的消息。一旦有新的消息进入队列，就会立即打印.

 

2.3 消息确认机制（ACK）

 

通过刚才的案例可以看出，消息一旦被消费者接收，队列中的消息就会被删除。

那么问题来了：RabbitMQ怎么知道消息被接收了呢？

如果消费者领取消息后，还没执行操作就挂掉了呢？或者抛出了异常？消息消费失败，但是RabbitMQ无从得知，这样消息就丢失了！

因此，RabbitMQ有一个ACK机制。当消费者获取消息后，会向RabbitMQ发送回执ACK，告知消息已经被接收。不过这种回执ACK分两种情况：

  • 自动ACK：消息一旦被接收，消费者自动发送ACK
  • 手动ACK：消息接收后，不会发送ACK，需要手动调用

这需要看消息的重要性：

  • 如果消息不太重要，丢失也没有影响，那么自动ACK会比较方便
  • 如果消息非常重要，不容丢失。那么最好在消费完成后手动ACK，否则接收消息后就自动ACK，RabbitMQ就会把消息从队列中删除。如果此时消费者宕机，那么消息就丢失了。

2.3.1 消费者获取消息（手动ACK）

package com.example.demorabbitmq.simple;

import java.io.IOException;

import com.example.demorabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

/**
 * 消费者,手动进行ACK
 */
public class Recv2 {
    private final static String QUEUE_NAME = "simple_queue_demo";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        final Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println(" [x] received : " + msg + "!");
                // 手动进行ACK
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 监听队列，第二个参数false，手动进行ACK  
        // 如果第二个参数为true，则会自动进行ACK；如果为false，则需要手动ACK。则需要手动ACK。
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

2.3.2 自动ACK存在的问题

运行消费者时，如果消费者程序抛出异常，但是消息依然被消费。

 

  • 修改消费者Recv的代码：
package com.example.demorabbitmq.simple;

import java.io.IOException;

import com.example.demorabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;


/**
 * 消费者
 */
public class Recv {
    private final static String QUEUE_NAME = "simple_queue_demo";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                int i = 100/0; //todo 异常抛出点
                System.out.println(" [x] received : " + msg + "!");
            }
        };
        // 监听队列，第二个参数：是否自动进行消息确认。
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

 

  • send生产者发消息

 

 

  • 运行消费者Recv 程序抛出异常

  • 查看rabbitmq界面，生产者发送的消息已经被消费掉

 

 

2.3.3  手动ACK

修改消费者Recv2，把自动改成手动

package com.example.demorabbitmq.simple;

import java.io.IOException;

import com.example.demorabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

/**
 * 消费者,手动进行ACK
 */
public class Recv2 {
    private final static String QUEUE_NAME = "simple_queue_demo";

    public static void main(String[] argv) throws Exception {
        // 获取到连接
        Connection connection = ConnectionUtil.getConnection();
        // 创建通道
        final Channel channel = connection.createChannel();
        // 声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 定义队列的消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            // 获取消息，并且处理，这个方法类似事件监听，如果有消息的时候，会被自动调用
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                int i = 100/0;
                System.out.println(" [x] received : " + msg + "!");
                // 手动进行ACK
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 监听队列，第二个参数false，手动进行ACK
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

 

 

运行生产者send代码：

 

运行Recv2代码：

 

管理界面：

 

没有被消费掉。

青苔猿猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RabbitMq消息队列指南.docx
07-05
RabbitMQ还支持多种消息模型，如基本模型、Direct、Fanout、Topic和Header等，以适应不同场景的需求。例如，基本模型是最简单的，生产者直接将消息发送到队列，而消费者直接从队列中取出消息。其他模型则提供了更...
RabbitMQ系统升级相关1
08-03
1. **remove_user_scope**：这可能涉及到用户权限管理的更新，移除旧的用户范围或权限设置，以适应新的安全模型。 2. **hash_passwords**：密码哈希策略的改变，确保新版本RabbitMQ支持的加密方式与旧版本兼容，...
RabbitMQ(05)——RabbitMQ的Topic消息模型
万里顾一程的博客
01-11 1224
文章目录RabbitMQ——RabbitMQ的Topic消息模型1、Topic消息模型之发布者发布消息2、Topic消息模型之消费者消费消息 RabbitMQ——RabbitMQ的Topic消息模型 Topic 类型的 Exchange 与 Direct相比，都是可以根据 Routingkey 把消息路由到不同的队列。只不过 Topic类型 Exchange 可以让队列在绑定 Routingkey 的时候使用通配符 。 假设在一个日志系统中，如果我们使用Topic 交换机，我们可以根据日志的来源订阅日志，比
【消息队列】RabbitMQ五种消息模式
最新发布
weixin_62513677的博客
04-30 2584
Spring AMQP是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息，包含两部分，其中Spring-amqp是基础抽象，spring-rabbit是底层的默认实现。这是为了防止消息队列中的队列不存在，在进行消息队列初始化的时候不知道是先建立消费者，还是先建立生产者，所以都执行创建函数，但是创建的队列只有一个不会重复。发布者发送消息时，指定消息的RoutingKey，Exchange将消息路由到BindingKey与消息RoutingKey一致的队列。Work queue，工作队列。
RabbitMQ(04)——RabbitMQ的Direct消息模型
万里顾一程的博客
01-11 368
文章目录RabbitMQ——RabbitMQ的Direct消息模型1、Direct消息模型之发布者发布消息2、Direct消息模型之消费者消费消息 RabbitMQ——RabbitMQ的Direct消息模型 在 Fanout 消息模型中，使用Fanout交换机，一条消息发出去后，会被交换机发送给所有订阅的队列，再被队列对应的消费者消费。但是，再某些情况下，我们希望不同的消息能被不同的队列消费。这时就要用到Direct消息模型的Direct交换机。 Direct消息模型结构图 P：生产者，向Exchan
RabbitMQ(03)——RabbitMQ的Fanout消息模型
万里顾一程的博客
01-11 1010
RabbitMQ——RabbitMQ的Fanout消息模型 Fanout消息模型结构 Fanout消息模型可以有多个消费者； 每个消费者都绑定有自己的队列queue（临时队列）； 每个队列绑定到交换机exchange，这里使用的交换机是扇型交换机（funout exchange）； 生产者生产的消息，只能发送到交换机，由交换机决定发送给哪个队列，生产者通常不知道消息是否会被传递到哪个队列； 交换机把消息发送给绑定到该交换机的所有队列，这也是扇型交换机的特点，所以也叫广播模型； 队列的消费者都能拿到消息
RabbitMQ(02)——RabbitMQ的Work消息模型
万里顾一程的博客
01-11 1161
文章目录RabbitMQ——RabbitMQ的Work消息模型1、Work消息模型之发布者发布消息2、Work消息模型之消费者消费消息3、消息自动确认机制 RabbitMQ——RabbitMQ的Work消息模型 1、Work消息模型之发布者发布消息 Wlork queues ，也被称为（Task queues )，任务模型。当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多无法及时处理。此时就可以使用work模型：让多个消费者绑定到一个队列，共同消费队列中的
RabbitMQ(01)——RabbitMQ的HelloWorld消息模型
万里顾一程的博客
01-10 507
文章目录RabbitMQ——RabbitMQ的HelloWorld消息模型（直连）1、HelloWorld消息模型之发布者发布消息2、HelloWorld消息模型之消费者消费消息3、连接工具类的封装 RabbitMQ——RabbitMQ的HelloWorld消息模型（直连） AMPQ模型 AMQP（高级消息队列协议）是一个网络协议。它支持符合要求的客户端应用（application）和消息中间件代理（messaging middleware broker）之间进行通信。 AMPQ结构图为： 1、Hel
rabbitmq基础1——发展起源、模型架构
百慕卿君博客
12-08 1030
rabbitmq的发展起源讲解，生产者、消费者、信道、连接、交换器多种模式以及和队列的路由绑定关系说明。 绑定键的含义，AMQP协议介绍
（二）RabbitMQ消息模型——3 Publish/subscribe（交换机类型：Fanout，也称为广播 ）
04-07 182
https://www.cnblogs.com/ifme/p/12024064.html#gallery-9
Rabbitmq消息队列——NWU_LK
NWU_LK的博客
08-22 297
Rabbitmq消息队列 消息队列简介 消息队列（Message Queue）别名消息中间件，是经典的生产者消费者模型。生产者不断向消息队列发送消息，消费者从消息队列消费消息，因此消息的生产和消费都是异步的。 目前消息中间件主要的几种有：RabbitMQ、ActiveMQ、Kafka、RocketMQ等。 ActiveMQ Apache出品的产品，行业中最流行、能力最强的消息中间件，提供丰富的API，在中小型企业很受欢迎。缺点就是吞吐量小，性能相对较弱。 Kafka 高吞吐量，设计的初衷用在大数据中，但是
RabbitMQ之基本消息模型
gloamer的博客
07-03 399
介绍： RabbitMQ提供了6中消息模型 但第6种其实是RPC（远程过程调用）并不是MQ (message queue 消息队列) 所以暂时咱还不研究 如果想去了解RPC的话可以去学习一下dubbo 它就是一个轻量级的开源 RPC框架,今天咱们学习第一种 RrabbitMQ消息模型——基本消息模型 如图所示 基本消息模型就是生产者------->消息队列------>消费者，消息生产者对应一个消息消费者： 搭建示例工程： 项目目录结构： ...
rabbitmq-server-3.8.14.zip
04-12
在"rabbitmq-server-3.8.14.zip"这个压缩包中，包含的是RabbitMQ服务器针对Windows操作系统的最新版本——3.8.14。 **1. 消息队列概念** 消息队列是分布式系统中的重要组件，它作为一个中间人，接收并存储来自生产...
java消息服务（第二版）
07-11
3. **消息模型**：JMS支持两种消息模型——点对点（Point-to-Point, PTP）和发布/订阅（Publish/Subscribe, Pub/Sub）。PTP模型基于队列，消息由一个生产者发送到一个队列，然后被一个或多个消费者接收。Pub/Sub模型...
（三）RabbitMQ管理界面使用——用户权限vhost等设置
04-06 2295
目录 1. 创建账号 2. 添加vhost 2.1 新创建一个vhost 2.2 添加成功后 3. 账号授权 3.1 选择新增的vhost 3.2 设置新增用户权限 3.3 创建成功后 1. 创建账号 1.1 点击Admin,再点击Add a user add一个账号角色选择Admin如下图 1.2 创建成功 2. 添加vhost 2.1 新创建一个vhost 2.2 添加成功后 3. 账号授权 ...
docker安装rabbitmq启动报错 .erlang.cookie must be accessible by owner only
09-03 1821
启动错误:.erlang.cookie must be accessible by owner only 进入到该容器内： 解决方法chmod 600 /var/lib/rabbitmq/.erlang.cookie
（一）RabbitMQ——消息队列简介
04-05 609
目录 1. 消息队列使用背景 2. 消息队列定义 2.1 遵循设计原则 2.2 消息队列定义 3. 应用场景 3.1 任务异步处理 3.2 应用程序解耦合 4. 实现MQ两种主流方式AMQP、JMS 4.1 AMQP JMS区别和联系 4.2 常见MQ产品 5. RabbitMQ的基本结构介绍 5.1 RabbitMQ结构图 5.2 组成部分说明 5.2.1 Broker 5.2.2 Exchange 5.2.3 Queue 5.2.4 Producer 5.2.5 ..
使用RabbitMQ解决服务间耦合——消息队列解析
"这篇文档是关于RabbitMQ的学习资料，主要涵盖了RabbitMQ的基本概念、AMQP和JMS的区别、消息队列的应用场景以及RabbitMQ的安装与使用。此外，还提到了其他常见的消息队列产品如ActiveMQ和RocketMQ。" 在IT行业中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

青苔猿猿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值