RabbitMQ：第一章：6 种工作模式以及消息确认机制（理论与代码相结合）

最新推荐文章于 2024-08-20 08:45:30 发布
最新推荐文章于 2024-08-20 08:45:30 发布
阅读量746 收藏 17
点赞数 21
分类专栏： 程序员 文章标签： rabbitmq ruby 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84002271/article/details/138334465
版权

private static ConnectionFactory connectionFactory = new ConnectionFactory();

static {

connectionFactory.setHost(“你的rabbitmq的ip地址”);

connectionFactory.setPort(5672);//RabbitMQ的默认端口号，根据实际情况修改

connectionFactory.setUsername(“你的rabbitmq的用户名称”);

connectionFactory.setPassword(“你的rabbitmq的用户密码”);

connectionFactory.setVirtualHost(“你的rabbitmq的虚拟机”);

}

public static Connection getConnection(){

Connection conn = null;

try {

conn = connectionFactory.newConnection();

return conn;

} catch (Exception e) {

throw new RuntimeException(e);

}

}

}

简单模式：

为了区分好理解，我每个模式都去创建一个虚拟机，这里我先去rabbitMq管控页面创建一个虚拟机

在这里插入图片描述

修改工具类的虚拟机：

在这里插入图片描述

生产者：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

public class Producer {

public static void main(String[] args) throws Exception {

//获取TCP长连接

Connection conn = RabbitUtils.getConnection();

//创建通信“通道”，相当于TCP中的虚拟连接

Channel channel = conn.createChannel();

//创建队列,声明并创建一个队列，如果队列已存在，则使用这个队列

//channel.queueDeclare的五个参数

//第一个参数：队列名称ID

//第二个参数：是否持久化，false对应不持久化数据，MQ停掉数据就会丢失

//第三个参数：是否队列私有化，false则代表所有消费者都可以访问，true代表只有第一次拥有它的消费者才能一直使用，其他消费者不让访问

//第四个：是否自动删除,false代表连接停掉后不自动删除掉这个队列

//其他额外的参数, null

channel.queueDeclare(RabbitConstant.QUEUE_TEST,false, false, false, null);

String message = “要发送的message”;

//channel.basicPublish的四个参数

//exchange 交换机，暂时用不到，在后面进行发布订阅时才会用到

//队列名称

//额外的设置属性

//最后一个参数是要传递的消息字节数组

channel.basicPublish(“”, RabbitConstant.QUEUE_TEST, null,message.getBytes());

channel.close();

conn.close();

System.out.println(“=发送成功=”);

}

}

消费者：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer {

public static void main(String[] args) throws Exception{

//获取TCP长连接

Connection conn = RabbitUtils.getConnection();

//创建通信“通道”，相当于TCP中的虚拟连接

Channel channel = conn.createChannel();

//创建队列,声明并创建一个队列，如果队列已存在，则使用这个队列

//第一个参数：队列名称ID

//第二个参数：是否持久化，false对应不持久化数据，MQ停掉数据就会丢失

//第三个参数：是否队列私有化，false则代表所有消费者都可以访问，true代表只有第一次拥有它的消费者才能一直使用，其他消费者不让访问

//第四个：是否自动删除,false代表连接停掉后不自动删除掉这个队列

//其他额外的参数, null

channel.queueDeclare(RabbitConstant.QUEUE_TEST,false, false, false, null);

//从MQ服务器中获取数据

//创建一个消息消费者

//第一个参数：队列名

//第二个参数代表是否自动确认收到消息，false代表手动编程来确认消息，这是MQ的推荐做法

//第三个参数要传入DefaultConsumer的实现类

channel.basicConsume(RabbitConstant.QUEUE_TEST, false, new Reciver(channel));

}

}

class Reciver extends DefaultConsumer {

private Channel channel;

//重写构造函数,Channel通道对象需要从外层传入，在handleDelivery中要用到

public Reciver(Channel channel) {

super(channel);

this.channel = channel;

}

@Override

public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

String message = new String(body);

System.out.println(“消费者接收到的消息：”+message);

System.out.println(“消息的TagId：”+envelope.getDeliveryTag());

//false只确认签收当前的消息，设置为true的时候则代表签收该消费者所有未签收的消息

channel.basicAck(envelope.getDeliveryTag(), false);

}

我先启动消费者后启动生产者，这样只要生产者一生产消息，消费者就可以立马消费。

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

Work queues 工作队列模式：

为了区分好理解，我每个模式都去创建一个虚拟机，这里我先去rabbitMq管控页面创建一个虚拟机

在这里插入图片描述修改工具类的虚拟机

在这里插入图片描述

为了模拟某些业务，这里使用自定义实体类发送消息，所以我新建了一个自定义实体类

/**

  • 自定义的实体类：发送内容

*/

public class SenderContent {

private String name;

private String content;

public SenderContent(String name, String content) {

this.name = name;

this.content = content;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getContent() {

return content;

}

public void setContent(String content) {

this.content = content;

}

}

生产者：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.google.gson.Gson;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

/**

  • 生成者

*/

public class Producer {

public static void main(String[] args) throws Exception {

Connection connection = RabbitUtils.getConnection();

Channel channel = connection.createChannel();

channel.queueDeclare(RabbitConstant.QUEUE_SENDER_CONTENT, false, false, false, null);

for(int i = 1 ; i <= 100 ; i++) {

SenderContent senderContent = new SenderContent(“姓名：” + i, “内容：” + i);

String jsonSMS = new Gson().toJson(senderContent);

channel.basicPublish(“” , RabbitConstant.QUEUE_SENDER_CONTENT , null , jsonSMS.getBytes());

}

System.out.println(“发送数据成功”);

channel.close();

connection.close();

}

}

消费者一：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.*;

import java.io.IOException;

/**

  • 消费者1

*/

public class ConsumerOne {

public static void main(String[] args) throws Exception {

Connection connection = RabbitUtils.getConnection();

final Channel channel = connection.createChannel();

channel.queueDeclare(RabbitConstant.QUEUE_SENDER_CONTENT, false, false, false, null);

//如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者

//basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的

channel.basicQos(1);//处理完一个取一个

channel.basicConsume(RabbitConstant.QUEUE_SENDER_CONTENT , false , new DefaultConsumer(channel){

@Override

public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

String jsonSMS = new String(body);

System.out.println(“ConsumerOne-发送成功:” + jsonSMS);

try {

Thread.sleep(10);

} catch (Exception e) {

e.printStackTrace();

}

//确认签收

channel.basicAck(envelope.getDeliveryTag() , false);

}

});

}

}

消费者二：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.*;

import java.io.IOException;

/**

  • 消费者2

*/

public class ConsumerTwo {

public static void main(String[] args) throws IOException {

Connection connection = RabbitUtils.getConnection();

final Channel channel = connection.createChannel();

channel.queueDeclare(RabbitConstant.QUEUE_SENDER_CONTENT, false, false, false, null);

//如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者

//basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的

channel.basicQos(1);//处理完一个取一个

channel.basicConsume(RabbitConstant.QUEUE_SENDER_CONTENT , false , new DefaultConsumer(channel){

@Override

public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

String jsonSMS = new String(body);

System.out.println(“ConsumerTwo-发送成功:” + jsonSMS);

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

//确认签收

channel.basicAck(envelope.getDeliveryTag() , false);

}

});

}

}

消费者三：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.*;

import java.io.IOException;

/**

  • 消费者3

*/

public class ConsumerThree {

public static void main(String[] args) throws IOException {

Connection connection = RabbitUtils.getConnection();

final Channel channel = connection.createChannel();

channel.queueDeclare(RabbitConstant.QUEUE_SENDER_CONTENT, false, false, false, null);

//如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者

//basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的

channel.basicQos(1);//处理完一个取一个

channel.basicConsume(RabbitConstant.QUEUE_SENDER_CONTENT , false , new DefaultConsumer(channel){

@Override

public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

String jsonSMS = new String(body);

System.out.println(“ConsumerThree-发送成功:” + jsonSMS);

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

//确认签收

channel.basicAck(envelope.getDeliveryTag() , false);

}

});

}

}

这里对每个消费者设置不同的休眠时间演示每个消费者处理业务的时间不同，查看消息消费的情况

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

可以看出消费者一消费的最多，消费者三消费的最少，因为代码中设置了这个

channel.basicQos(1);//处理完一个取一个

消费者处理完一个消息后（确认后），在从队列中获取一个新的。

Pub/Sub 订阅模式 ：

为了区分好理解，我每个模式都去创建一个虚拟机，这里我先去rabbitMq管控页面创建一个虚拟机

在这里插入图片描述创建一个交换机：这里用广播模式作为交换机的类型用来演示

在这里插入图片描述

修改工具类的虚拟机

在这里插入图片描述

生产者：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import java.util.Scanner;

/**

  • 发布者

*/

public class Producer {

public static void main(String[] args) throws Exception {

Connection connection = RabbitUtils.getConnection();

//键盘输入

String input = new Scanner(System.in).next();

Channel channel = connection.createChannel();

//第一个参数交换机名字 其他参数和之前的一样

channel.basicPublish(RabbitConstant.EXCHANGE_CONTENT,“” , null , input.getBytes());

channel.close();

connection.close();

}

}

消费者一：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.*;

import java.io.IOException;

/**

  • 消费者1

*/

public class ConsumerOne {

public static void main(String[] args) throws IOException {

//获取TCP长连接

Connection connection = RabbitUtils.getConnection();

//获取虚拟连接

final Channel channel = connection.createChannel();

//声明队列信息

channel.queueDeclare(RabbitConstant.QUEUE_ONE, false, false, false, null);

//queueBind用于将队列与交换机绑定

//参数1：队列名 参数2：交互机名 参数三：路由key（暂时用不到)

channel.queueBind(RabbitConstant.QUEUE_ONE, RabbitConstant.EXCHANGE_CONTENT, “”);

channel.basicQos(1);

channel.basicConsume(RabbitConstant.QUEUE_ONE , false , new DefaultConsumer(channel){

@Override

public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

System.out.println(“消费者一收到信息：” + new String(body));

channel.basicAck(envelope.getDeliveryTag() , false);

}

});

}

}

消费者二：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.*;

import java.io.IOException;

/**

  • 消费者2

*/

public class ConsumerTwo {

public static void main(String[] args) throws IOException {

//获取TCP长连接

Connection connection = RabbitUtils.getConnection();

//获取虚拟连接

final Channel channel = connection.createChannel();

//声明队列信息

channel.queueDeclare(RabbitConstant.QUEUE_TWO, false, false, false, null);

//queueBind用于将队列与交换机绑定

//参数1：队列名 参数2：交互机名 参数三：路由key（暂时用不到)

channel.queueBind(RabbitConstant.QUEUE_TWO, RabbitConstant.EXCHANGE_CONTENT, “”);

channel.basicQos(1);

channel.basicConsume(RabbitConstant.QUEUE_TWO , false , new DefaultConsumer(channel){

@Override

public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

System.out.println(“消费者二收到信息：” + new String(body));

channel.basicAck(envelope.getDeliveryTag() , false);

}

});

}

}

演示效果：

在这里插入图片描述

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

Routing 路由模式：

为了区分好理解，我每个模式都去创建一个虚拟机，这里我先去rabbitMq管控页面创建一个虚拟机

在这里插入图片描述修改工具类的虚拟机

在这里插入图片描述

创建交换机：这里的交换机type类型一定要改成routing模式，如果还是广播模式的fanout的话，跟上面发布和订阅模式出现的效果会是一样的。

错误实例：

在这里插入图片描述正确的实例：

在这里插入图片描述生产者：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

/**

  • 发布者

*/

public class Producer {

public static void main(String[] args) throws Exception {

Map area = new LinkedHashMap<String, String>();

area.put(“routing.one.a.20201127”, “中国湖南长沙20201127私密数据”);

area.put(“routing.one.d.20201128”, “中国河北石家庄20201128私密数据”);

area.put(“routing.two.b.20201127”, “中国湖北武汉20201127私密数据”);

area.put(“routing.two.e.20201128”, “中国湖北武汉20201128私密数据”);

area.put(“routing.three.c.20201127”, “中国湖南株洲20201128私密数据”);

area.put(“routing.three.f.20201128”, “中国河南郑州20201128私密数据”);

area.put(“us.one.a.20201127”, “美国加州洛杉矶20201127私密数据”);

area.put(“us.two.b.20201128”, “美国加州洛杉矶20201128私密数据”);

Connection connection = RabbitUtils.getConnection();

Channel channel = connection.createChannel();

Iterator<Map.Entry<String, String>> itr = area.entrySet().iterator();

while (itr.hasNext()) {

Map.Entry<String, String> me = itr.next();

//第一个参数交换机名字 第二个参数作为 消息的routing key

channel.basicPublish(RabbitConstant.EXCHANGE_CONTENT_ROUTING,me.getKey() , null , me.getValue().getBytes());

}

channel.close();

connection.close();

}

}

消费者一：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.*;

import java.io.IOException;

/**

  • 消费者1

*/

public class ConsumerOne {

public static void main(String[] args) throws IOException {

Connection connection = RabbitUtils.getConnection();

final Channel channel = connection.createChannel();

channel.queueDeclare(RabbitConstant.QUEUE_ONE, false, false, false, null);

//queueBind用于将队列与交换机绑定

//参数1：队列名 参数2：交互机名 参数三：路由key

channel.queueBind(RabbitConstant.QUEUE_ONE, RabbitConstant.EXCHANGE_CONTENT_ROUTING, “routing.one.a.20201127”);

channel.queueBind(RabbitConstant.QUEUE_ONE, RabbitConstant.EXCHANGE_CONTENT_ROUTING, “us.one.a.20201127”);

channel.basicQos(1);

channel.basicConsume(RabbitConstant.QUEUE_ONE , false , new DefaultConsumer(channel){

@Override

public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

System.out.println(“消费者1收到信息：” + new String(body));

channel.basicAck(envelope.getDeliveryTag() , false);

}

});

}

}

消费者二：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.*;

import java.io.IOException;

/**

  • 消费者2

*/

public class ConsumerTwo {

public static void main(String[] args) throws IOException {

Connection connection = RabbitUtils.getConnection();

final Channel channel = connection.createChannel();

channel.queueDeclare(RabbitConstant.QUEUE_TWO, false, false, false, null);

//queueBind用于将队列与交换机绑定

//参数1：队列名 参数2：交互机名 参数三：路由key

channel.queueBind(RabbitConstant.QUEUE_TWO, RabbitConstant.EXCHANGE_CONTENT_ROUTING, “routing.one.d.20201128”);

channel.queueBind(RabbitConstant.QUEUE_TWO, RabbitConstant.EXCHANGE_CONTENT_ROUTING, “routing.two.e.20201128”);

channel.basicQos(1);

channel.basicConsume(RabbitConstant.QUEUE_TWO , false , new DefaultConsumer(channel){

@Override

public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

System.out.println(“消费者2收到信息：” + new String(body));

channel.basicAck(envelope.getDeliveryTag() , false);

}

});

}

}

效果：

在这里插入图片描述在这里插入图片描述在这里插入图片描述路由模式需要消费者指定路由key

Topics 通配符模式：

为了区分好理解，我每个模式都去创建一个虚拟机，这里我先去rabbitMq管控页面创建一个虚拟机

在这里插入图片描述修改工具类的虚拟机

在这里插入图片描述

创建交互机，类型为topic

在这里插入图片描述生产者：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

/**

  • 发布者

*/

public class Producer {

public static void main(String[] args) throws Exception {

最后

分享一些资料给大家，我觉得这些都是很有用的东西，大家也可以跟着来学习，查漏补缺。

《Java高级面试》

《Java高级架构知识》

《算法知识》

模式都去创建一个虚拟机，这里我先去rabbitMq管控页面创建一个虚拟机

在这里插入图片描述修改工具类的虚拟机

在这里插入图片描述

创建交互机，类型为topic

在这里插入图片描述生产者：

import com.liao.rabbitmq.utils.RabbitConstant;

import com.liao.rabbitmq.utils.RabbitUtils;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

/**

  • 发布者

*/

public class Producer {

public static void main(String[] args) throws Exception {

最后

分享一些资料给大家，我觉得这些都是很有用的东西，大家也可以跟着来学习，查漏补缺。

《Java高级面试》

[外链图片转存中…(img-OIqoAHEF-1714438999323)]

《Java高级架构知识》

[外链图片转存中…(img-BKdSUFs8-1714438999324)]

《算法知识》

[外链图片转存中…(img-gPyJUKuG-1714438999324)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

2401_84002271
关注
专栏目录
微服务架构系列一：关键技术与原理研究
腾讯技术工程
08-15 4081
导语：人不为己，天诛地灭这个成语中的“为”念作wéi，阳平二声，是“修养，修为”的意思。成语的意思是：如果人不修身，那么就会为天地所不容。本意并不是经常被很多人曲解的人如...
SpringBoot Rabbitmq 消息发送手动确认demo
10-30
SpringBoot Rabbitmq 消息发送手动确认demo,通过实现RabbitTemplate.ConfirmCallback 的confirm方法来手动确认
MQ高级-消息确认
m0_65144570的博客
09-21 128
个人名片： 本项目基于B站黑马程序员Java《SpringCloud微服务技术栈》，SpringCloud+RabbitMQ+Docker+Redis+搜索+分布式消息从发送，到消费者接收，会经理多个过程： 首先，导入课前资料提供的项目工程(mq-advanced-demo)注意：首先，修改publisher服务中的application.yml文件的rabbitmq的IP地址，用户名，密码等配置，并添加下面的内容： 说明：修改publisher服务，添加一个： 定义ConfirmCallback
深度掌握 RabbitMQ 消息确认（ACK）机制，确保消息万无一失
最新发布
2401_84664550的博客
08-20 1814
自动 ACK：当消费者从队列中获取消息后，RabbitMQ 会自动将该消息标记为已确认，无需消费者手动进行确认操作。手动 ACK：消费者需要在处理完消息后，手动向 RabbitMQ 发送确认消息，告知 RabbitMQ 该消息已经被成功处理。关键知识点回顾：本文详细介绍了 RabbitMQ 的消息确认机制，包括 ACK 的定义和类型、自动 ACK 和手动 ACK 的工作流程和优缺点、消息重发策略、ACK 与消息持久化的结合、实际应用中的最佳实践等内容。对消息可靠传递的重要意义。
RabbitMQ 消息确认
江城宴的博客
06-05 238
正常情况下，如果消息经过交换器进入队列就可以完成消息的持久化，但如果消息在没有到达broker之前出现意外，那就造成消息丢失，有没有办法可以解决这个问题？ RabbitMQ有两种方式来解决这个问题： 一、事务使用 事务的实现主要是对信道（Channel）的设置，主要的方法有三个： channel.txSelect()声明事务模式； channel.txComment()提交事务； channel.txRollback()回滚事务； // 创建连接 ConnectionFactory facto.
RabbitMQ消息确认
我的博客
03-19 138
消费者从队列中获取到消息之后，这条消息就不存在队列中了，但是如果此时消费者所在的信道因为网络中断没有消费到，那这条消息就被永远的丢失了，所以，我们希望等待消费者成功消费掉这个消息之后再删除这条消息。而发送者是不知道这个消息有没有送达队列的，因此，我们需要在队列中进行消息确认。而在发送消息的时候也是这样的，生产者发消息给交换机，也不能保证消息准确发送过去了，消息就像石沉大海一样，所以这样需要一个消息确认。实际使用中，拉取消息是会降低系统吞吐量的，以及消费者很难实时获取消息，因此，一般使用的是push 模式。
RabbitMq消息确认模式
m0_59164927的博客
12-17 440
在mq消息传递时，为了避免消息丢失，mq引入了消息确认机制mq是一种生产者和消费者模式，中间以mq为中介进行消息分发，将生产者与消费者隔离，生产者不必关心消息何时被消费，消费者也不关心消息如何生产，使得两者不必同步处理。因此基于这种模式，可能会产生消息丢失问题，如何确保消费成功发送。以及消息成功接收，需要保证：1、生产者的确认模式2、消息和队列的持久化3、消费者的确认模式。
【Java并发编程模式】：学习和应用常见设计模式，优化并发程序的5个策略
![【Java并发编程模式】：学习和应用常见设计模式，优化并发程序的5个策略]...本章将对Java并发编程的基础概念、历史发展以及在现代应用中的重要性进行简要介绍。 ## 1.1 Java并发编程的发展历程 自Java诞生
Python并发应用任务调度：策略选择与实现方法
本章将带您深入了解Python并发编程的基础知识，以及任务调度的概念。 ## 1.1 并发编程的意义与应用 并发编程允许程序员在单个程序中同时执行多个任务，这在提高资源利用率、缩短响应时间以及增强程
【在线学习与实时决策】：决策树的角色与应用策略
![决策树在分类中的应用](https://img-blog.csdnimg.cn/5d397ed6aa864b7b9f88a5db2629a1d1.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbnVpc3RfX05KVVBU...在线学习与实时决策技术
【数据源整合高级教程】：在多源数据中发现异常的策略与实践
多源数据整合不仅仅是技术的集合，更是一种挑战业务流程、数据管理和技术实施能力的综合实践。本章将为您概述多源数据整合的概念、重要性、以及在不同业务环境中实现该实践的方法和挑战。 ## 1.1 数据整合的基本...
RabbitMQ发布确认
weixin_42942786的博客
06-15 345
RabbitMq发布确认
rabbitmq高级特性（消息手动确认）
qq_45533609的博客
10-13 754
为了保证消息不丢失，从生产者两种模式（确认模式和返回模式）到消费者手动确认的一个大整合 生产者 1.maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency>
RabbitMQ学习笔记（二）消息确认机制
qq_42331185的博客
07-14 2409
1、我的另一篇文章中介绍了RabbitMQ的交换机类型、消费类型，经过一系列的demo测试时，我们在RabbitMQ的后台监控中可以发现一个现象，就是消息在被成功消费后，队列中就没有这个消息了，也就是删除了，那么疑问来了，RabbitMQ是怎么知道这个消息该不该被删除？什么时候删除？2、除了消费者，那么生产者怎么知道自己消息是否发送成功到RabbitMQ中了？解决这个疑问的方式就是：RabbitMQ消息确认机制。
【RabbitMQ】RabbitMQ 消息的可靠性 —— 生产者和消费者消息的确认，消息的持久化以及消费失败的重试机制_rabbitmq 生产者消息确认
2401_84164527的博客
04-17 1320
本文将深入探讨如何应对这些挑战，介绍消息队列中的关键概念，并详细讨论 RabbitMQ 提供的解决方案，包括生产者消息的确认、消息的持久化、消费者消息的确认以及消息消费失败的重试机制。这个确认机制的目的是确保消息在发送到消息队列后，发送者能够获得有关消息处理状态的明确反馈，从而可以采取适当的措施，例如重发消息或记录失败信息。此时发现刚才的消息并没有丢失，至此我们就完成了持久化消息的发送，进一步确保了消息的可靠性。此时发现刚才的消息并没有丢失，至此我们就完成了持久化消息的发送，进一步确保了消息的可靠性。
rabbitmq 手动确认机制
昆仑山神
09-09 1003
## 背景 项目采用了rabbitmq作为消息中间件，并且开启了手动确认机制。但是抛出异常时没有主动确认，因此导致消息不断在消息队列中堆积，影响程序运行。因此花了一些时间查了rabbitmq的消息确认机制。 ## 消息确认机制 - auto（默认） - manual 援引rabbitmq官方文档的说法 > 在自动确认模式下，消息在发送后立即被视为成功投递。这种模式会牺牲更高的吞吐量（只要消费者能够跟上）以降低交付和消费者处理的安全性。这种模式通常被称为“即发即忘”。与手动确认模型不同，如果消
rabbitmq手动确认机制
weixin_43861630的博客
06-21 599
@Configuration public class MyRabbitConfig { private RabbitTemplate rabbitTemplate; @Primary @Bean public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) { RabbitTemplate rabbitTemplate = new RabbitTemplate(conn
RabbitMQ消息确认机制
ningxiaobai456的博客
12-29 1535
在使用RabbitMQ发送消息如果出现消息没有发送到，队列没有接收到情况。需要消息确认来排错。
RabbitMQ消息队列入门与五种应用模式详解
消息队列RabbitMQ入门与5种模式详解 RabbitMQ概述： 消息队列是应用程序和应用程序之间的通信方法，RabbitMQ是开源的，实现了AMQP协议的，采用Erlang（面向并发编程语言）编写的，可复用的企业级消息系统。RabbitMQ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值