RibbitMQ学习笔记之MQ练习(二)

简介: RibbitMQ学习笔记之MQ练习

3.1.2. 启动两个工作线程

public class Worker01 {
private static final String QUEUE_NAME="hello";
public static void main(String[] args) throws Exception { Channel channel = RabbitMqUtils.getChannel();
DeliverCallback deliverCallback=(consumerTag,delivery)->{ String receivedMessage = new String(delivery.getBody());
System.out.println("接收到消息:"+receivedMessage);
};
CancelCallback cancelCallback=(consumerTag)-
>{ System.out.println(consumerTag+"消费者取消消费接口回调逻辑");
};
System.out.println("C2 消费者启动等待消费.................. ");
channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
}
}
package com.atguigu.rabbitmq.two;
import com.atguigu.rabbitmq.utils.RabbitMqutils;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
 *
 *
 * 这是一个工作的线程 相当于之前的消费
 */
public class Worker01 {
 //队列名称
     public static final String QUEUE_NAME="hello";
     //接受消息
     public static void main(String[] args) throws IOException, TimeoutException {
         Channel channel = RabbitMqutils.getChannel();
         DeliverCallback deliverCallback=(var1,var2)->{
             System.out.println("接受到的消息"+new String(var2.getBody()));
         };
        CancelCallback cancelCallback=var1->{
            System.out.println(var1+"消费者取消的消费接口回调");
        };
         //消息的接受
         /**
          * 消费者消费信息
          *1.表示消费那个队列
          * 2.消费成功之后 是否自动应答ture自动应答 false手动应打 默认false
          * 3.消费未成功消费的回调
          * 4.消费者取消消费的回调
          *
          */
         System.out.println("C2等待接受消息......");
         channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
     }
}

3.1.3. 启动一个发送线程

public class Task01 {
private static final String QUEUE_NAME="hello";
public static void main(String[] args) throws Exception { try(Channel channel=RabbitMqUtils.getChannel();)
{ channel.queueDeclare(QUEUE_NAME,false,false,false,null);
//从控制台当中接受信息
Scanner scanner = new Scanner(System.in); while (scanner.hasNext()){
String message = scanner.next(); channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
System.out.println("发送消息完成:"+message);
}
}
}
}
package com.atguigu.rabbitmq.two;
import com.atguigu.rabbitmq.utils.RabbitMqutils;
import com.rabbitmq.client.Channel;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;
/**
 * 生产者发送大量的消息
 */
public class TASK01 {
    //队列名称
    public static final String QUEUE_NAME="hello";
    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqutils.getChannel();
        /**
         * 生成一个队列
         * 1.队列名称
         * 2.队列中的消息是否持久化  默认消息存储在内存中 否不持久化 (持久化放在磁盘中)
         *3.该队列是否只供一个消费者进行消费 是否共享  true 可以多个消费者消费  默认false,只能一个消费者消费
         4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true自动删除 false不删除
         5.其他参数
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //从控制台输入消息
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message=scanner.next();
            //发消息了开始
            /**
             * 发送一个消息
             * 1.发送到那个交换机  此不考虑不写
             * 2.路由key值是那个 本次是队列的名称
             * 3.其他参数信息
             *4.发送的消息 的消息体   发送要发送他的二进制 才能发送出去消息
             */
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
            System.out.println("发送消息完成"+message);
        }
    }
}

3.1.4. 结果展示

通过程序执行发现生产者总共发送 4 个消息,消费者 1 和消费者 2 分别分得两个消息,并且是按照有序的一个接收一次消息




视频地址如有不解可查看:

https://www.bilibili.com/video/BV1cb4y1o7zz?p=22&spm_id_from=pageDriver

3.2. 消息应答

3.2.1. 概念

消费者完成一个任务可能需要一段时间,如果其中一个消费者处理一个长的任务并仅只完成了部分突然它挂掉了,会发生什么情况。RabbitMQ 一旦向消费者传递了一条消息,便立即将该消息标记为删除。在这种情况下,突然有个消费者挂掉了,我们将丢失正在处理的消息。以及后续发送给该消费这的消息,因为它无法接收到。

为了保证消息在发送过程中不丢失,rabbitmq 引入消息应答机制,消息应答就是:消费者在接收到消息并且处理该消息之后,告诉 rabbitmq 它已经处理了,rabbitmq 可以把该消息删除了。

3.2.2. 自动应答

消息发送后立即被认为已经传送成功,这种模式需要在高吞吐量和数据传输安全性方面做权衡,因为这种模式如果消息在接收到之前,消费者那边出现连接或者 channel 关闭,那么消息就丢失了,当然另一方面这种模式消费者那边可以传递过载的消息,没有对传递的消息数量进行限制, 当然这样有可能使得消费者这边由于接收太多还来不及处理的消息,导致这些消息的积压,最终使得内存耗尽,最终这些消费者线程被操作系统杀死,所以这种模式仅适用在消费者可以高效并以

某种速率能够处理这些消息的情况下使用。

3.2.3. 消息应答的方法

A.Channel.basicAck(用于肯定确认)

RabbitMQ 已知道该消息并且成功的处理消息,可以将其丢弃了

B.Channel.basicNack(用于否定确认)

C.Channel.basicReject(用于否定确认)

与 Channel.basicNack 相比少一个参数

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

3.2.4. Multiple 的解释

手动应答的好处是可以批量应答并且减少网络拥堵

multiple 使用的时候不建议批量处理 fasle
multiple 的 true 和 false 代表不同意思 true 代表批量应答 channel 上未应答的消息

比如说 channel 上有传送 tag 的消息 5,6,7,8 当前 tag 是 8 那么此时

5-8 的这些还未应答的消息都会被确认收到消息应答 false 同上面相比

只会应答 tag=8 的消息 5,6,7 这三个消息依然不会被确认收到消息应答

3.2.5. 消息自动重新入队

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

3.2.6. 消息手动应答代码

默认消息采用的是自动应答,所以我们要想实现消息消费过程中不丢失,需要把自动应答改为手动应答,消费者在上面代码的基础上增加下面画红色部分代码。

消息生产者

public class Task02 {
private static final String TASK_QUEUE_NAME = "ack_queue";
public static void main(String[] argv) throws Exception { try (Channel channel = RabbitMqUtils.getChannel())
{ channel.queueDeclare(TASK_QUEUE_NAME, false, false, false, null); Scanner sc = new Scanner(System.in);
System.out.println("请输入信息"); while (sc.hasNext()) {
String message = sc.nextLine();
channel.basicPublish("", TASK_QUEUE_NAME, null, message.getBytes("UTF-8"));
System.out.println("生产者发出消息" + message);
}
}
}
}

消费者 01

public class Work03 {
private static final String ACK_QUEUE_NAME="ack_queue"; public static void main(String[] args) throws Exception
{ Channel channel = RabbitMqUtils.getChannel(); System.out.println("C1 等待接收消息处理时间较短");
//消息消费的时候如何处理消息
DeliverCallback deliverCallback=(consumerTag,delivery)->{ String message= new String(delivery.getBody()); SleepUtils.sleep(1);
System.out.println("接收到消息:"+message);
/**
*  1.消息标记 tag
*  2.是否批量应答未应答消息
*/
channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
};
//采用手动应答 boolean autoAck=false;
channel.basicConsume(ACK_QUEUE_NAME,autoAck,deliverCallback,(consumerTag)->{
System.out.println(consumerTag+"消费者取消消费接口回调逻辑");
});
}
}

消费者 02

public class Work04 {
private static final String ACK_QUEUE_NAME="ack_queue"; public static void main(String[] args) throws Exception
{ Channel channel = RabbitMqUtils.getChannel();
System.out.println("C2 等待接收消息处理时间较长");
//消息消费的时候如何处理消息
DeliverCallback deliverCallback=(consumerTag,delivery)->{ String message= new String(delivery.getBody()); SleepUtils.sleep(30);
System.out.println("接收到消息:"+message);
/**
*  1.消息标记 tag
*  2.是否批量应答未应答消息
*/
channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
};
//采用手动应答 boolean autoAck=false;
channel.basicConsume(ACK_QUEUE_NAME,autoAck,deliverCallback,(consumerTag)->{
System.out.println(consumerTag+"消费者取消消费接口回调逻辑");
});
}
}

睡眠工具类

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

生产者

package com.atguigu.rabbitmq.three;
import com.atguigu.rabbitmq.utils.RabbitMqutils;
import com.rabbitmq.client.Channel;
import java.util.Scanner;
/**
 *
 * 消息应答时不丢失 放回队列重新消费
 */
public class Task2 {
    public static final String TASK_QUEUE_NAME="闫文超ack";
    public static void main(String[] args) throws  Exception{
        Channel channel = RabbitMqutils.getChannel();
        /**
         * 生成一个队列
         * 1.队列名称
         * 2.队列中的消息是否持久化  默认消息存储在内存中 否不持久化 (持久化放在磁盘中)
         *3.该队列是否只供一个消费者进行消费 是否共享  true 可以多个消费者消费  默认false,只能一个消费者消费
         4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true自动删除 false不删除
         5.其他参数
         */
        //声明队列
        channel.queueDeclare(TASK_QUEUE_NAME,false,false,false,null);
        //从控制输入的信息
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            //发消息了开始
            /**
             * 发送一个消息
             * 1.发送到那个交换机  此不考虑不写
             * 2.路由key值是那个 本次是队列的名称
             * 3.其他参数信息
             *4.发送的消息 的消息体   发送要发送他的二进制 才能发送出去消息
             */
            channel.basicPublish("",TASK_QUEUE_NAME,null,message.getBytes("utf-8"));
            System.out.println("生产者发出消息的:"+message);
        }
    }
}


相关实践学习
RocketMQ一站式入门使用
从源码编译、部署broker、部署namesrv,使用java客户端首发消息等一站式入门RocketMQ。
消息队列 MNS 入门课程
1、消息队列MNS简介 本节课介绍消息队列的MNS的基础概念 2、消息队列MNS特性 本节课介绍消息队列的MNS的主要特性 3、MNS的最佳实践及场景应用 本节课介绍消息队列的MNS的最佳实践及场景应用案例 4、手把手系列:消息队列MNS实操讲 本节课介绍消息队列的MNS的实际操作演示 5、动手实验:基于MNS,0基础轻松构建 Web Client 本节课带您一起基于MNS,0基础轻松构建 Web Client
相关文章
|
1月前
|
消息中间件 存储 算法
RocketMQ学习笔记
RocketMQ学习笔记
101 0
|
1月前
|
传感器 网络协议 中间件
Mqtt学习笔记--交叉编译移植(1)
Mqtt学习笔记--交叉编译移植(1)
31 0
|
11月前
|
消息中间件 存储 缓存
RibbitMQ学习笔记之MQ练习(三)
RibbitMQ学习笔记之MQ练习
30 0
|
11月前
|
消息中间件 网络协议 数据中心
RabbmitMQ学习笔记-RabbitMQ集群架构模式
RabbmitMQ学习笔记-RabbitMQ集群架构模式
56 0
|
11月前
|
消息中间件 Java
RabbmitMQ学习笔记-RabbitMQ与SpringBoot2.0整合实战
在使用 RabbitMQ 的时候,作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。
93 0
|
11月前
|
消息中间件 中间件
RibbitMQ学习笔记之MQ发布确认
RibbitMQ学习笔记之MQ发布确认
39 0
|
4天前
|
消息中间件 测试技术 开发工具
消息队列 MQ操作报错合集之收到"WARN RocketmqClient - consumeMessage Orderly return"警告,是什么原因
在使用消息队列MQ时,可能会遇到各种报错情况。以下是一些常见的错误场景、可能的原因以及解决建议的汇总:1.连接错误、2.消息发送失败、3.消息消费报错、4.消息重试与死信处理、5.资源与权限问题、6.配置错误、7.系统资源限制、8.版本兼容性问题。
|
4天前
|
消息中间件 设计模式 网络安全
消息队列 MQ操作报错合集之broker启用controller配置时,遇到报错,是什么导致的
在使用消息队列MQ时,可能会遇到各种报错情况。以下是一些常见的错误场景、可能的原因以及解决建议的汇总:1.连接错误、2.消息发送失败、3.消息消费报错、4.消息重试与死信处理、5.资源与权限问题、6.配置错误、7.系统资源限制、8.版本兼容性问题。
|
4天前
|
消息中间件 Java 测试技术
消息队列 MQ操作报错合集之设置了setKeepAliveInterval(1)但仍然出现客户端未连接,该怎么解决
在使用消息队列MQ时,可能会遇到各种报错情况。以下是一些常见的错误场景、可能的原因以及解决建议的汇总:1.连接错误、2.消息发送失败、3.消息消费报错、4.消息重试与死信处理、5.资源与权限问题、6.配置错误、7.系统资源限制、8.版本兼容性问题。
|
4天前
|
消息中间件 Apache RocketMQ
消息队列 MQ操作报错合集之设置了controller后,有一主一从,但只显示一个,该怎么解决
在使用消息队列MQ时,可能会遇到各种报错情况。以下是一些常见的错误场景、可能的原因以及解决建议的汇总:1.连接错误、2.消息发送失败、3.消息消费报错、4.消息重试与死信处理、5.资源与权限问题、6.配置错误、7.系统资源限制、8.版本兼容性问题。

热门文章

最新文章