一、介绍
如何保证RabbitMQ服务停掉以后生产者发送过来的消息不丢失。默认情况下RabbitMQ退出或由于某种原因崩溃时，他将忽视队列和消息，除非告知它不要这样做。确保消息不丢失需要做两件事情：将队列和消息都标记为持久化
二、队列持久化
再声明队列的时候把durable参数改为true即可
boolean durable = true; //让队列持久化
channel.queueDeclare(TASK_QUEUE_NAME,durable,false,false,null);但是需要注意的是，如果之前声明的队列不是持久化的，需要把原先的队列先删除，或者重新创建一个持久化队列，不然会出现错误
删除之后
重启之后
三、消息持久化
需要在消息生产者修改代码，MessageProperties.PERSISTENT_TEXT_PLAIN添加这个属性
channel.basicPublish("",QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());将消息标注为持久化并不能完全保证不会丢失消息，尽管它告诉RabbitMQ将消息保存到磁盘，但是依然存在当消息刚刚准备存储在磁盘的时候，但是还没有存储完，消息还在缓存的一个间隔点。此时并没有真正写入磁盘。持久性保证并不强，仅使用于简单任务队列。
四、不公平分发
设置参数（在消费端）
//设置不公平分发
int prefetchCount = 1;
channel.basicQos(prefetchCount);五、预取值
//轮询
//int prefetchCount = 0;
//设置不公平分发
//int prefetchCount = 1;
//预取值
int prefetchCount = 2;
channel.basicQos(prefetchCount);六、发布确认
1、开启发布确认（默认没有开启）
//开启发布确认
channel.confirmSelect();2、单个确认发布
这是一种简单的确认方式，它是一种同步确认发布的方式，也就是发布一个消息之后只有它被确认发布后，后续的消息才能继续发布，waitForConfirmsOrDie(long)这个方法只有在消息被确认的时候才返回，如果在指定时间范围内这个消息没有被确认那么它将抛出异常。
缺点：发布速度特别慢，最多提供每秒不超过数百条发布消息的吞吐量。
3、批量确认发布
单个确认发布非常慢，而与单个确认发布相比，先发布一批消息然后一起确认可以极大提高吞吐量，缺点就是：当发生故障导致发布出现问题时，无法确定哪个消息出现问题了。我们必须将整个批处理保存在内存中，以记录重要的消息后重新发布。当然这种方案仍然是同步的，一样阻塞消息的发布。
4、异步确认发布
逻辑比较复杂，但性价比较高，可靠性和效率都比较好；是利用回调函数来达到消息可靠性传递的，这个中间件也是通过回调函数来保证是否投递成功。
/**
* @author
* @date
* 发布确认模式
* 1、单个确认
* 2、批量确认
* 3、异步批量确认
*/
public class ConfirmMessage {
public static final int MESSAGE_COUNT = 1000;
public static void main(String[] args) throws Exception {
//1、单个确认 558ms
//publishMessageIndividually();
//2、批量确认 121ms
//publicMessageBatch();
//3、异步发布确认 40ms
publishMessageAsync();
}
//单个确认
public static void publishMessageIndividually() throws Exception {
Channel channel = RabbitMqUtil.getChannel();
//队列声明
String queueName = UUID.randomUUID().toString();
channel.queueDeclare(queueName,true,false,false,null);
//开启发布确认
channel.confirmSelect();
//开始时间
long begin = System.currentTimeMillis();
//批量发消息
for (int i = 0; i < MESSAGE_COUNT; i++) {
String message = i+"";
channel.basicPublish("",queueName,null,message.getBytes());
System.out.println();
boolean flag = channel.waitForConfirms();
if(flag){
System.out.println("消息发送成功");
}
}
//结束时间
long end = System.currentTimeMillis();
System.out.println("发布"+MESSAGE_COUNT+"个单独确认消息耗时"+(end-begin));
}
//批量发布确认
public static void publicMessageBatch() throws Exception {
Channel channel = RabbitMqUtil.getChannel();
//队列声明
String queueName = UUID.randomUUID().toString();
channel.queueDeclare(queueName,true,false,false,null);
//开启发布确认
channel.confirmSelect();
//开始时间
long begin = System.currentTimeMillis();
//批量确认消息大小
int batchSize = 100;
//批量发消息 批量发布确认
for (int i = 1; i <= MESSAGE_COUNT; i++) {
String message = i+"";
channel.basicPublish("",queueName,null,message.getBytes());
//判断达到100条消息的时候，批量确认一次
if(i%batchSize == 0){
//发布确认
channel.waitForConfirms();
}
}
//结束时间
long end = System.currentTimeMillis();
System.out.println("发布"+MESSAGE_COUNT+"个批量确认消息耗时"+(end-begin));
}
//异步发布确认
public static void publishMessageAsync() throws Exception {
Channel channel = RabbitMqUtil.getChannel();
//队列声明
String queueName = UUID.randomUUID().toString();
channel.queueDeclare(queueName,true,false,false,null);
//开启发布确认
channel.confirmSelect();
//开始时间
long begin = System.currentTimeMillis();
//消息确认成功 回调函数
ConfirmCallback ackCallback = (deliveryTag, multiple) ->{
System.out.println("确认的消息："+deliveryTag);
};
//消息确认失败 回调函数
/**
* 1、消息的标识
* 2、是否为批量确认
*/
ConfirmCallback nackCallback = (deliveryTag, multiple) ->{
System.out.println("未确认的消息："+deliveryTag);
};
//准备消息的监听器 监听哪些消息发送成功了 哪些消息发送失败了、
/**
* 1、监听哪些消息确认成功了
* 2、监听哪些消息确认失败了
*/
channel.addConfirmListener(ackCallback,nackCallback);
//批量发消息 异步发布确认
for (int i = 0; i < MESSAGE_COUNT; i++) {
String message = i+"";
channel.basicPublish("",queueName,null,message.getBytes());
}
//结束时间
long end = System.currentTimeMillis();
System.out.println("发布"+MESSAGE_COUNT+"个异步确认消息耗时"+(end-begin));
}
}5、如何处理异步未确认消息
把未确认的消息放到一个基于内存的能被发布线程访问的队列，比如说用ConcurrentLinkedQueue这个队列在confirm callbacks与发布线程之间进行消息的传递
//异步发布确认
public static void publishMessageAsync() throws Exception {
Channel channel = RabbitMqUtil.getChannel();
//队列声明
String queueName = UUID.randomUUID().toString();
channel.queueDeclare(queueName,true,false,false,null);
//开启发布确认
channel.confirmSelect();
/**
* 线程安全有序的一个哈希表 适用于高并发情况
* 1、轻松的将序号与消息进行关联
* 2、轻松的批量删除条目 只要给到序号
* 3、支持高并发
*/
ConcurrentSkipListMap<Long,String> outstandingConfirm = new ConcurrentSkipListMap<>();
//消息确认成功 回调函数
ConfirmCallback ackCallback = (deliveryTag, multiple) ->{
if(multiple){
//2、删除已经确认的消息 剩下就是为确认的消息
ConcurrentNavigableMap<Long, String> confirmed =
outstandingConfirm.headMap(deliveryTag);
confirmed.clear();
}else{
outstandingConfirm.remove(deliveryTag);
}
System.out.println("确认的消息："+deliveryTag);
};
//消息确认失败 回调函数
/**
* 1、消息的标识
* 2、是否为批量确认
*/
ConfirmCallback nackCallback = (deliveryTag, multiple) ->{
//3、打印未确认的消息有哪些
String message = outstandingConfirm.get(deliveryTag);
System.out.println("未确认的消息:"+message+"未确认的消息标记："+deliveryTag);
};
//准备消息的监听器 监听哪些消息发送成功了 哪些消息发送失败了、
/**
* 1、监听哪些消息确认成功了
* 2、监听哪些消息确认失败了
*/
channel.addConfirmListener(ackCallback,nackCallback);
//开始时间
long begin = System.currentTimeMillis();
//批量发消息 异步发布确认
for (int i = 0; i < MESSAGE_COUNT; i++) {
String message = i+"";
channel.basicPublish("",queueName,null,message.getBytes());
//1、记录所有要发送的消息
outstandingConfirm.put(channel.getNextPublishSeqNo(),message);
}
//结束时间
long end = System.currentTimeMillis();
System.out.println("发布"+MESSAGE_COUNT+"个异步确认消息耗时"+(end-begin));
}
