Rabbitmq简单模式和消息的手动应答以及Rabbitmq持久化

最新推荐文章于 2024-12-03 23:24:21 发布
最新推荐文章于 2024-12-03 23:24:21 发布
阅读量1.8w 收藏 2
点赞数 80
文章标签： java rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51406695/article/details/121287508
版权

Hello模式

在idea中新建一个空工程
在这里插入图片描述
设置项目
在这里插入图片描述
添加模块
在这里插入图片描述
选择模块类型
在这里插入图片描述
设置模块
在这里插入图片描述

在pom文件中导入jar包依赖
在这里插入图片描述

书写生产者代码:

public class HelloProduct {

//    创建队列名称

    public static  final String queue_name = "hello";
    //发消息
    public static void main(String[] args) throws Exception{
        //创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置工厂ip 连接rabbitmq队列
        factory.setHost("192.168.14.131");
        //连接用户名
        factory.setUsername("admin");
        //密码
        factory.setPassword("admin");
        //创建连接
        Connection connection = factory.newConnection();
        //获取通道
        Channel channel = connection.createChannel();
        /*
        * 生成一个队列
        * 1 队列名称
        * 2 队列里的消息是否持久化(存储到磁盘中) 默认情况下消息存储在内存中
        * 3 该队列是否只供一个消费者进行消费 是否进行消息共享 true:可以多个消费者共享 false:不可以多个消费者共享
        * 4 是否自动删除 最后一个消费者断开连接后 该队列是否自动删除 true自动删除 false不自动删除
        * 5 其他参数
        * */
        channel.queueDeclare(queue_name,false,false,false,null);
        //发消息
        String message = "hello world";//初次使用

        /*
        * 发送一个消费
        * 1 发送到哪个交换机
        * 2 路由的key值是哪个 本次是队列的名称
        * 3 其他参数信息
        * 4 发送消息的消息体
        * */
        channel.basicPublish("",queue_name,null,message.getBytes());
        System.out.println("消息发送完毕");
    }

}

启动运行:
在这里插入图片描述
在web端找到刚才发送的队列:
在这里插入图片描述
书写消费者:

public static void main(String[] args) throws Exception{
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置ip
        factory.setHost("192.168.14.131");
        factory.setUsername("admin");
        factory.setPassword("admin");

        Connection connection = factory.newConnection();

        Channel channel = connection.createChannel();


         System.out.println("消费者开始消费消息");
        //声明 接收消息
        DeliverCallback deliverCallback = (consumerTag,message) ->{

            System.out.println(new String(message.getBody()));
        };

        //取消消息时的回调
        CancelCallback cancelCallback = consumerTag ->{
            System.out.println("消息消费被中断");
        };
        /*
        * 消费者消费
        * 1 消费哪个队列
        * 2 消费成功后是否要自动应答 true: 自动应答 false: 手动应答
        * 3 消费者未成功的消费得回调
        * 4 消费者取消消费的回调
        * */
        channel.basicConsume(queue_name,true,deliverCallback,cancelCallback);
    }
}

运行消费者开始消费生产者生成的消息
在这里插入图片描述

由于在生产者和消费者中都需要建立连接工厂,代码重复,所以在这里可以将建立连接工厂的代码提取出来当做一个工具类来使用:
在这里插入图片描述

消息的轮询分配
创建工作线程队列:

public class Work1 {
    private static final String queue_name= "helllo";

    public static void main(String[] args) throws Exception{
        Channel channel = Rabbitmqutil.getChannel();

        //消息的接收
        DeliverCallback deliverCallback =(consumerTag,message)->{
            System.out.println("接收到的消息:"+new String(message.getBody()));
        };
        //消息接收被取消时 执行下面的内容
        CancelCallback cancelCallback =(consumerTag)->{
            System.out.println(consumerTag +"消费者取消消费接口回调逻辑");
        };
        System.out.println("C1接收消息");
        channel.basicConsume(queue_name,true,deliverCallback,cancelCallback);

    }
}

运行main方法
在这里插入图片描述
在这里插入图片描述
设置允许多线程启动
在这里插入图片描述
在这里插入图片描述
再次启动main方法

在这里插入图片描述
多线程启动成功

书写生产者代码:

public class WorkProduct {
    private static final String queue_name= "hello";

    public static void main(String[] args) throws Exception{
        Channel channel = Rabbitmqutil.getChannel();

        channel.queueDeclare(queue_name,false,false,false,null);


        System.out.println("请输入发送的消息:");
        //从控制台接收信息
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            System.out.println("请输入发送的消息:");
            /*
            * 发送一个消息
            * 1 发送到哪交换机
            * 2 路由的key值是哪一个 本次是队列的名称
            * 3 其他参数信息
            * 4 发送消息的消息体 消息以二进制传输 这里获取到消息的二进制文件
            * */
            String message = scanner.next();
            channel.basicPublish("",queue_name,null,message.getBytes());
        }
    }
}

启动生产者,并在控制台中输入发送的4条消息:
A1,A2,A3,A4
在这里插入图片描述

根据消息的轮询消费,应该是C1消费A1和A3,C2消费A2和A4,查看结果是否符合预期:
在这里插入图片描述

在这里插入图片描述
符合预期,说明消息消费轮询验证成功

消息应答

Message acknowledgment（消息应答）
执行一个任务可能需要花费几秒钟，你可能会担心如果一个消费者在执行任务过程中挂掉了。一旦RabbitMQ将消息分发给了消费者，就会从内存中删除。在这种情况下，如果正在执行任务的消费者宕机，会丢失正在处理的消息和分发给这个消费者但尚未处理的消息。
但是，我们不想丢失任何任务，如果有一个消费者挂掉了，那么我们应该将分发给它的任务交付给另一个消费者去处理。
为了确保消息不会丢失，RabbitMQ支持消息应答。消费者发送一个消息应答，告诉RabbitMQ这个消息已经接收并且处理完毕了。RabbitMQ就可以删除它了。

如果一个消费者挂掉却没有发送应答，RabbitMQ会理解为这个消息没有处理完全，然后交给另一个消费者去重新处理。这样，你就可以确认即使消费者偶尔挂掉也不会丢失任何消息了。
没有任何消息超时限制；只有当消费者挂掉时，RabbitMQ才会重新投递。即使处理一条消息会花费很长的时间。

消息应答是默认打开的。我们通过显示的设置autoAsk=true关闭这种机制。现即自动应答开，一旦我们完成任务，消费者会自动发送应答。通知RabbitMQ消息已被处理，可以从内存删除。如果消费者因宕机或链接失败等原因没有发送ACK（不同于ActiveMQ，在RabbitMQ里，消息没有过期的概念），则RabbitMQ会将消息重新发送给其他监听在队列的下一个消费者。

创建生产者:

* 消息在手动应答时是不丢失 放回队列中会重新消费
 **/

public class Task {
    //队列名称
    public static final  String task_queue_name = "ack_queue";

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

        //创建通道
        Channel channel = Rabbitmqutil.getChannel();
        //声明队列
        channel.queueDeclare(task_queue_name,false,false,false,null);
        //从控制台中输入信息
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish("",task_queue_name,null,message.getBytes("UTF-8"));
            System.out.println("生产者发出消息:"+message);
        }
    }
}

创建一个睡眠工具类,以便于直接对不同的消费者进行不同时间的睡眠执行:

public class SleepUtil {
    public static void sleep(int second){
        try{
            Thread.sleep(1000*second);
        }catch (InterruptedException e){
            Thread.currentThread().interrupt();
        }
    }
}

创建消费者work1,沉睡时间设置为1s:

public class Work1 {

    //队列名称
    public static  final String task_queue_name = "ack_queue";

    //接收消息
    public static void main(String[] args) throws Exception{
        //创建通道
        Channel channel = Rabbitmqutil.getChannel();
        System.out.println("C1等待接收消息,处理时间短");

        DeliverCallback deliverCallback = (consumerTag,message)->{
            //沉睡1s
            SleepUtil.sleep(1);
            System.out.println("接收到的消息"+new String(message.getBody(),"UTF-8"));
            //手动应答
            /*
            * 1 消息的标记 tag
            * 2 是否批量应答 false :不批量应答通道中的消息 true:批量
            * */
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        //采用手动应答
        boolean autoAck = false;
        channel.basicConsume(task_queue_name,autoAck,deliverCallback,(consumerTag,message)->{
            System.out.println(consumerTag+"消费者取消消费接口回调逻辑");
        });
    }
}

创建消费者2,沉睡时间设置为30s:

public class Work2 {

    //队列名称
    public static  final String task_queue_name = "ack_queue";

    //接收消息
    public static void main(String[] args) throws Exception{
        //创建通道
        Channel channel = Rabbitmqutil.getChannel();
        System.out.println("C2等待接收消息,处理时间长");

        DeliverCallback deliverCallback = (consumerTag,message)->{
            //沉睡1s
            SleepUtil.sleep(30);
            System.out.println("接收到的消息"+new String(message.getBody(),"UTF-8"));
            //手动应答
            /*
            * 1 消息的标记 tag
            * 2 是否批量应答 false :不批量应答通道中的消息 true:批量
            * */
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        //采用手动应答
        boolean autoAck = false;
        channel.basicConsume(task_queue_name,autoAck,deliverCallback,(consumerTag,message)->{
            System.out.println(consumerTag+"消费者取消消费接口回调逻辑");
        });
    }
}

首先执行生产者,由生产者首先创建队列:
在这里插入图片描述
再分别执行消费者1和消费者2:
在这里插入图片描述
在这里插入图片描述
由生产者发送消息:11和22
在这里插入图片描述
可以看到消费者1很快就接收到了消息:
在这里插入图片描述
消费者2在生产者发送22消息后30s才收到消息:
在这里插入图片描述
测试:
生产者发送两条消息,“33"和"44”,消费者1在1s后收到消息33,消费者2应该在30s后收到消息44,那么如果消费者2在30s内还没有收到消息时候出现宕机情况,那么消息44是否会丢失,还是会被其他的消费者(消费者1)所消费掉呢?
开始测试,生产者发送消息33和44
在这里插入图片描述

消费者1很快收到消息33
在这里插入图片描述
在消费者2还未收到消息44之前手动使其宕机
在这里插入图片描述
然后查看正常运行的消费者1,可以看到消费者1接收到消息44将其消费掉
在这里插入图片描述
由此可以得出结论,消息并未丢失,而是由其他消费者消费掉

Rabbitmq持久化方式

消息持久化和队列持久化的联系：
队列设置为持久化，那么在RabbitMQ重启之后，持久化的队列也会存在，并会保持和重启前一致的队列参数。
消息设置为持久化，在RabbitMQ重启之后，持久化的消息也会存在。

队列持久化
在这里插入图片描述
可以看到上面截图中ack_queue这个队列的Features属性为null,而其他下面的队列都有个D(durable),也就是该队列是非持久化的,一旦服务器中的mq宕机或者重启,该队列就会消失,这个时候我们就需要设置该队列持久化来防止mq宕机或者重启时该队列消失的问题

在我们前面创建的生产者task中将ack_queue队列更改为持久化队列
在这里插入图片描述
这个时候启动生产者会报错:
在这里插入图片描述
也就是说mq中该队列原先已经为非持久化,不可以直接更改为持久化,此时我们可以直接在mq中将该队列删除掉,然后重新创建该队列:
在这里插入图片描述
在这里插入图片描述
可以看到队列列表中已经没有该队列了:
在这里插入图片描述
重新启动生产者创建ack_queue队列:
在这里插入图片描述
消息持久化
队列发送消息一般存储在内存中,mq宕机和重启后消息也会消失,我们可以将消息进行持久化,将消息存储到磁盘中实现持久化
在这里插入图片描述

不公平分发

RabbitMQ分发消息默认采用的轮训分发,但是在某种场景下这种策略并不是很好，比方说有两个消费者在处理任务，其中有个消费者1处理任务的速度非常快，而另外一个消费者 2处理速度却很慢，这个时候我们还是采用轮训分发的化就会到这处理速度快的这个消费者很大-部分时间处于空闲状态，而处理慢的那个消费者-直在干活， 这种分配方式在这种情况下其实就不太好，但是RabbitMQ并不知道这种情况它依然很公平的进行分发。

我们可以设置参数channel.basicQos(1);
在两个消费者中都进行设置:
在这里插入图片描述
启动生产者和消费者进行发送消息测试:
在这里插入图片描述
沉睡时间短的消费者1消费消息多
在这里插入图片描述
沉睡时间长的消费者2消费消息少,遵循能者多劳规则
在这里插入图片描述
预取值
表示分发时候,每个消费者可以分配到多少条消息,预取值为多少该消费者通道中就可以堆积多少条消息供其消费
设置消费者1
在这里插入图片描述
设置消费者2:
在这里插入图片描述
分别启动生产者消费者并生产消息:
生产者发送20条消息:
在这里插入图片描述
消费者1:
在这里插入图片描述
由于消费者1处理消息快,在消费者2堆积满5条或者还未满5条时消费者1就已经消费完队列中堆积的一条消息,队列中空出一个位置还可以堆积,于是造成消费者1多消费消息

但是仍然可以看到消费者2中堆积了5条消息
在这里插入图片描述
在这里插入图片描述
最后在消费者2消费完堆积的5条消息中的一条而又空出来一个位置后队列中就又会存进去等待消费

暗武逢天
关注
SpringBoot Rabbitmq 消息发送手动确认demo
10-30
SpringBoot Rabbitmq 消息发送手动确认demo,通过实现RabbitTemplate.ConfirmCallback 的confirm方法来手动确认
rabbitmq学习系列教程之消息应答(autoAck)、队列持久化(durable)及消息持久化
s13166803785的博客
01-24 156
在simple queue 和 work queue(轮询) 处理中，我们设置的消费者的消息监听都采用 channel.basicConsume(queue_name,true, consumer)，其中参数二 boolean autoAck为true，但在fair prefetch 公平分发中设置为false，这个设置在整个消息队列和消息消费者之间有什么影响呢？
什么都不必说--rabbitmq手动应答
weixin_33712987的博客
07-16 411
场景:业务需要,如果在消费者端出现异常或者特殊情况下,需要让消息回到队列再次进行消耗 复制代码在redisConfig中进行设置 @Autowired private TestReceiver testReceiver ; @Bean public SimpleMessageListenerContainer qrcodeListenerContainer(ConnectionFacto...
RabbitMQ之手动应答消息（消息不丢失）
qq_42212926的博客
03-25 4040
RabbitMQ之手动应答消息 1.为什么需要手动应答 当消费者完成一个任务需要一段时间，如果其中一个消费者处理一个长的任务并且只处理了部分突然他挂掉了，会发生什么情况。RabbitMQ一旦向消费者传递了一条消息，便立即将该条消息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息。以及后续发送给该消费者的消息，因为他无法接收到。 2.应答分类 2.1手动应答 相应的，使用手动应答时，需要把autoAck属性设置为false，然后进行手动应答。 消息手动应答 有如下几个方法 A.Chan
RabbitMQ实现手动应答机制
一恍过去
07-20 2万+
RabbitMQ实现手动应答机制
RabbitMQ消息应答------ack机制
热门推荐
实践出真知
02-15 5万+
Message acknowledgment（消息应答） 执行一个任务可能需要花费几秒钟，你可能会担心如果一个消费者在执行任务过程中挂掉了。一旦RabbitMQ将消息分发给了消费者，就会从内存中删除。在这种情况下，如果正在执行任务的消费者宕机，会丢失正在处理的消息和分发给这个消费者但尚未处理的消息。 但是，我们不想丢失任何任务，如果有一个消费者挂掉了，那么我们应该将分发给它的任务交付给
RabbitMQ消息应答与持久化机制解析
本文主要讨论了消息应答和消息持久化两个关键概念，这是确保消息可靠性传输的重要机制。" 在RabbitMQ中，消息应答（Message Acknowledgment）是一个关键特性，用于确保消息的正确处理。当设置 `autoAck` 为 `true`...
[RabbitMQ] 保证消息可靠性的三大机制------消息确认,持久化,发送方确认
最新发布
m0_74824954的博客
12-03 1025
???热门专栏:??Java基本语法(97平均质量分)??Collection与数据结构 (92平均质量分)??线程与网络(96平均质量分)??MySql数据库(93平均质量分)??算法(97平均质量分)??Spring(97平均质量分)??Redis(97平均质量分)??RabbitMQ(97平均质量分)
RabbitMQ - 如保证消息的可靠性？（消息确认、消息持久化、失败重试机制）
CYK_byte的博客
09-11 1377
4 种可靠性保证
RabbitMQ之消息模式简单易懂，超详细分享~~~
m0_56069948的博客
09-13 730
上一篇对RabbitMQ的流程和相关的理论进行初步的概述，如果小伙伴之前对消息队列不是很了解，那么在看理论时会有些困惑，这里以消息模式为切入点，结合理论细节和代码实践的方式一起来学习。RabbitMQ提供了多种模式应对各种业务，但匹配条件越是模糊或者参数化，那性能相对比较弱。再回顾一些常用的消息队列组件，是不是很多都是默认使用Direct模式，精确匹配的RoutingKey可以针对具体不同业务处理，匹配性能也相对比较高；当然其他模式小伙伴也可以针对业务情况进行使用。
rabbitMQ手动应答与自动应答
weixin_45326523的博客
08-28 1357
手动应答；自动应答
RabbitMQ消息手动应答（注意事项）
Leon_Jinhai_Sun的博客
01-28 198
RabbitMQ消息手动应答（注意事项）
RabbitMQ—消息应答
weixin_44755735的博客
07-02 422
RabbitMQ—消息应答 为什么要有消息应答 场景：消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成了部分突然它挂掉了，会发生什么情况。 造成的影响：RabbitMQ 一旦向消费者传递了一条消息，便立即将该消息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息。以及后续发送给该消费这的消息，因为它无法接收到。 保证消息不丢失 为了保证消息在发送过程中不丢失，rabbitmq 引入消息应答机制，消息应答就是:消费者在接收到消息并且处理该消息之后，告诉 r
Rabbitmq手动应答代码实现与测试
qq_45790384的博客
03-19 2022
rabbitmq作为现在流行的消息队列，它拥有流量削峰、应用解耦、异步处理等优点，使用数量也是较多的。其中重要的特性也就是手动应答避免消息丢失的特点更是使其更上一层楼。消息队列基础的处理流程是：生产者—》队列—》消费者。 rabbitmq的自动应答会导致在消息的分发途中，如果一台消费者角色的服务器宕机了，其处理的消息在自动应答模式下就会丢失，而手动应答则不会，而且退回队列分发给下一个消费者进行处理，有效的规避了因服务器宕机而造成的消息丢失。接下来进行代码演示： 首先我们进行创建一个生产者进行消息的输入： p
RabbitMq之应答模式
chd_sun的博客
01-27 735
1.自动应答： 不在乎消费者对消息处理是否成功，都会告诉队列删除消息。如果处理消息失败，实现自动补偿（队列投递过去 重新处理）。2.手动应答： 消费者处理完业务逻辑，手动返回ack（通知）告诉队列处理完了，队列进而删除消息。而手动应答有如下三个方法。
RabbitMQ的应答模式
Nothing is difficult if you put your heart into it
11-24 1264
Message acknowledgment 应答模式              RabbitMQ支持生产者生产消息后发送到服务器，服务器把消息传递到消费者，消费者消费后告诉服务器，服务器删除列队。 channel.basicConsume(QUEUE_NAME, false, consumer);  //设置应答模式为手动 channel.basicAck
springboot2.3.1整合RabbitMQ多种工作模式 发送确认，手动应答
胖虎儿的博客
07-15 1万+
springboot2.3.1整合RabbitMQ多种工作模式 发送确认，手动应答
RabbitMQ之消息的自动应答、手动应答和消息持久化（Java开发）
cold_Blooder的博客
04-09 4045
1、消息的自动和手动应答 boolean autoAck = true;//消息自动应答 channel.basicConsume(WQ_QUEUE,autoAck,consumer); 默认情况下，rabbitmq开启了消息的自动应答。此时，一旦rabbitmq将消息分发给了消费者，就会将消息从内存中删除。这种情况下，如果正在执行的消费者被“杀死”或“崩溃”，就会丢失正在处...
rabbitmq消费者应答模式
zhzjn的博客
10-04 1474
RabbitMQ 中的消息应答模式主要包括两种：自动应答（Automatic Acknowledgement）和手动应答（Manual Acknowledgement）。不在乎消费者对消息处理是否成功，都会告诉队列删除消息。如果处理消息失败，实现自动补偿（队列投递过去 重新处理）。在手动应答模式下，消费者在接收到消息后并不会立即向RabbitMQ确认消息已处理完毕。消费者需要显式调用basicAck方法来确认消息处理完成，RabbitMQ只有在接收到消费者的确认后才会将消息从队列中删除。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值