一、Hello world
在下图中,“ P”是我们的生产者,“ C”是我们的消费者。中间的框是一个队列-RabbitMQ 代
表使用者保留的消息缓冲区
项目 pom 配置如下
<dependencies>
<!--rabbitmq 依赖客户端-->
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.8.0</version>
</dependency>
<!--操作文件流的一个依赖-->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.6</version>
</dependency>
</dependencies>
1.生产者
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Producer {
private final static String QUEUE_NAME = "hello";
public static void main(String[] args) throws Exception {
// 创建一个连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 工厂IP
factory.setHost("192.168.168.220");
// rabbitmq 用户名
factory.setUsername("admin");
// 密码
factory.setPassword("123");
// 创建一个连接
Connection connection = factory.newConnection();
// 获取信道
Channel channel = connection.createChannel();
/**
* 生成一个队列
* 第一个参数:队列名称
* 第二个参数: 队列中的消息是否持久化,默认消息是存储在内存中
* 第三个参数:消息消费时,可否被多个消费者消费
* 第四个参数:是否自动删除,最后一个消费者断开连接后,该对列是否自动删除 true 自动删除
* 第五个参数: 其它参数
*/
channel.queueDeclare(QUEUE_NAME,false,false,false,null);
// 发送的消息
String message = "hello world";
/**
* 发送消息
* 第一个参数: 发送到哪个交换机
* 第二个参数: 队列名称,消息发送到该队列
* 第三个参数: 其它参数
* 第四个参数: 发送消息的消息体
*/
channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
System.out.println("消息发送完毕");
}
}
2.消费者
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer {
private final static String QUEUE_NAME = "hello";
public static void main(String[] args) throws Exception {
// 创建一个连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 工厂IP
factory.setHost("192.168.168.220");
// rabbitmq 用户名
factory.setUsername("admin");
// 密码
factory.setPassword("123");
// 创建一个连接
Connection connection = factory.newConnection();
// 获取信道
Channel channel = connection.createChannel();
System.out.println("等待接收消息....");
// 推送的消息如何消费的接口回调
DeliverCallback deliverCallback = (consumerTag,delivery) ->{
String msg = new String(delivery.getBody());
System.out.println(msg);
};
// 取消消费的一个回调接口
CancelCallback cancelCallback = (consumerTag)->{
System.out.println("消息消费被中断");
};
/**
* 消费者消费消息
* 第一个参数: 消费哪个队列
* 第二个参数: 消费成功后,是否需要自动应答,true 自动应答 false 手动应答
*/
channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
}
}
3.测试
运行生产者
查看 rabbitmq 控制后台,提示有一条消息
运行消费者,已打印出消息
查看 rabbitmq 控制台,消息已经被消费
二、工作队列
工作队列(又称任务队列)的主要思想是避免立即执行资源密集型任务,而不得不等待它完成。
相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进
程将弹出任务并最终执行作业。 当有多个工作线程时,这些工作线程将一起处理这些任务。
0.创建信道工具抽取
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class RabbitMqUtils {
public static Channel getChannel() throws Exception {
// 创建一个连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 工厂IP
factory.setHost("192.168.168.220");
// rabbitmq 用户名
factory.setUsername("admin");
// 密码
factory.setPassword("123");
// 创建一个连接
Connection connection = factory.newConnection();
// 获取信道
Channel channel = connection.createChannel();
return channel;
}
}
下面的案例启动两个消费线程,一个消息生产线程,看消息是如何被消费的,答案是轮训消费
1.消费线程1 :worker01
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zym.rabbitmq.utils.RabbitMqUtils;
public class Worker01 {
private final static String QUEUE_NAME = "hello";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
// 推送的消息如何消费的接口回调
DeliverCallback deliverCallback = (consumerTag, delivery) ->{
String msg = new String(delivery.getBody());
System.out.println(msg);
};
// 取消消费的一个回调接口
CancelCallback cancelCallback = (consumerTag)->{
System.out.println("消息消费被中断");
};
System.out.println("C1消费者启动等待消费....");
/**
* 消费者消费消息
* 第一个参数: 消费哪个队列
* 第二个参数: 消费成功后,是否需要自动应答,true 自动应答 false 手动应答
*/
channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
}
}
2.消费线程2跟线程1代码一样:Worker02
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zym.rabbitmq.utils.RabbitMqUtils;
public class Worker02 {
private final static String QUEUE_NAME = "hello";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
// 推送的消息如何消费的接口回调
DeliverCallback deliverCallback = (consumerTag, delivery) ->{
String msg = new String(delivery.getBody());
System.out.println(msg);
};
// 取消消费的一个回调接口
CancelCallback cancelCallback = (consumerTag)->{
System.out.println("消息消费被中断");
};
System.out.println("C2消费者启动等待消费....");
/**
* 消费者消费消息
* 第一个参数: 消费哪个队列
* 第二个参数: 消费成功后,是否需要自动应答,true 自动应答 false 手动应答
*/
channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
}
}
3.生产消息线程:Task01
import com.rabbitmq.client.Channel;
import com.zym.rabbitmq.utils.RabbitMqUtils;
import java.util.Scanner;
public class Task01 {
private final static String QUEUE_NAME = "hello";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
/**
* 生成一个队列
* 第一个参数:队列名称
* 第二个参数: 队列中的消息是否持久化,默认消息是存储在内存中
* 第三个参数:消息消费时,可否被多个消费者消费
* 第四个参数:是否自动删除,最后一个消费者断开连接后,该对列是否自动删除 true 自动删除
* 第五个参数: 其它参数
*/
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);
}
}
}
4.测试结果
在消息生产控制台输入四次消息
查看消费线程1
查看消费线程2
三、消息应答
1.概念
消费者完成一个任务可能需要一段时间,如果其中一个消费者处理一个长的任务并仅只完成
了部分突然它挂掉了,会发生什么情况。 RabbitMQ 一旦向消费者传递了一条消息,便立即将该消息标记为删除。在这种情况下,突然有个消费者挂掉了,我们将丢失正在处理的消息。以及后续
发送给该消费这的消息,因为它无法接收到。为了保证消息在发送过程中不丢失, rabbitmq 引入消息应答机制,消息应答就是:消费者在接收到消息并且处理该消息之后,告诉 rabbitmq 它已经处理了, rabbitmq 可以把该消息删除了。
1.1自动应答
消息发送后立即被认为已经传送成功,这种模式需要在高吞吐量和数据传输安全性方面做权
衡,因为这种模式如果消息在接收到之前,消费者那边出现连接或者 channel 关闭,那么消息就丢
失了,当然另一方面这种模式消费者那边可以传递过载的消息, 没有对传递的消息数量进行限制,
当然这样有可能使得消费者这边由于接收太多还来不及处理的消息,导致这些消息的积压,最终
使得内存耗尽,最终这些消费者线程被操作系统杀死, 所以这种模式仅适用在消费者可以高效并
以某种速率能够处理这些消息的情况下使用。
1.2手动应答
默认消息采用的是自动应答,所以我们要想实现消息消费过程中不丢失,需要把自动应答改为手动应答。
1.3消息重新入队
如果消费者由于某些原因失去连接(其通道已关闭,连接已关闭或 TCP 连接丢失), 导致消息
未发送 ACK 确认, RabbitMQ 将了解到消息未完全处理,并将对其重新排队。如果此时其他消费者可以处理,它将很快将其重新分发给另一个消费者。这样,即使某个消费者偶尔死亡,也可以确
保不会丢失任何消息。
2.消费者手动应答案例
这里依然创建两个消费线程一个生产线程,一个消费线程等待1秒,一个消费线程等待30秒(为了演示消费者接收消息后,未处理完,我们关闭该消费线程,看看另一个消费线程是否接收重新入队消息进行消费) ;
睡眠工具类
public class SleepUtils {
public static void sleep(int second){try {
Thread.sleep(1000*second);
} catch (InterruptedException _ignored) {
Thread.currentThread().interrupt();
}
}
}
消费线程1:work03
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zym.rabbitmq.utils.RabbitMqUtils;
import com.zym.rabbitmq.utils.SleepUtils;
public class Work03 {
private final static 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 msg = new String(delivery.getBody());
SleepUtils.sleep(1);
System.out.println("接收到的消息: "+msg);
// 第一个参数: 消息标记 tag
// 第二个参数:是否批量应答未应答消息 false 不批量
channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
};
// 取消消费的一个回调接口
CancelCallback cancelCallback = (consumerTag)->{
System.out.println("消息消费被中断");
};
// 采用手动应答
boolean autoAck = false;
/**
* 消费者消费消息
* 第一个参数: 消费哪个队列
* 第二个参数: 消费成功后,是否需要自动应答,true 自动应答 false 手动应答
*/
channel.basicConsume(ACK_QUEUE_NAME,autoAck,deliverCallback,cancelCallback);
}
}
消费线程2:work04
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.zym.rabbitmq.utils.RabbitMqUtils;
import com.zym.rabbitmq.utils.SleepUtils;
public class Work04 {
private final static 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 msg = new String(delivery.getBody());
SleepUtils.sleep(30);
System.out.println("接收到的消息: "+msg);
// 第一个参数: 消息标记 tag
// 第二个参数:是否批量应答未应答消息 false 不批量
channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
};
// 取消消费的一个回调接口
CancelCallback cancelCallback = (consumerTag)->{
System.out.println("消息消费被中断");
};
// 采用手动应答
boolean autoAck = false;
/**
* 消费者消费消息
* 第一个参数: 消费哪个队列
* 第二个参数: 消费成功后,是否需要自动应答,true 自动应答 false 手动应答
*/
channel.basicConsume(ACK_QUEUE_NAME,autoAck,deliverCallback,cancelCallback);
}
}
生产线程:Task02
import com.rabbitmq.client.Channel;
import com.zym.rabbitmq.utils.RabbitMqUtils;
import java.util.Scanner;
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);
}
}
}
}
测试:
启动生产线程 Task02 --> 启动两个消费线程 --> 在生产线程发送四条信息 ---> 运行二三十秒后故意关闭消费线程2,查看结果
Task02
work03
work04
四、队列持久化
1.刚刚我们已经看到了如何处理任务不丢失的情况,但是如何保障当 RabbitMQ 服务停掉以后消
息生产者发送过来的消息不丢失。默认情况下 RabbitMQ 退出或由于某种原因崩溃时,它忽视队列和消息,除非告知它不要这样做。确保消息不会丢失需要做两件事: 我们需要将队列和消息都标记为持久化。
2.队列持久化
在声明队列的时候把 durable 参数设置为持久化
// 让队列持久化
boolean durable = true;
channel.queueDeclare(TASK_QUEUE_NAME, durable, false, false, null);
D 代表改队列是持久化的
3.消息持久化
要想让消息实现持久化需要在消息生产者修改代码MessageProperties.PERSISTENT_TEXT_PLAIN 添加这个属性。
channel.basicPublish("", TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes("UTF-8"));