RabbitMq之发布确认

保证消息不丢失，除了队列开启持久化，消息开启持久化之后，还要发布确认才能完全保证消息不丢失
发布确认有三种
1.单个确认发布
一种同步确认发布的方式，也就是发一个消息以后只有他被确认发布，后续的才能继续发布。最大的缺点是：发布速度特别慢

//单个确认
    public static void publishMessageSingle() throws Exception{
        Channel channel = Util.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());
            //单个消息就马上发布确认
            boolean flag = channel.waitForConfirms();
            if(flag){
                System.out.println("消息发送成功");
            }
        }
        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("发布"+MESSAGE_COUNT+"个单独确认消息，耗时"+(end-begin)+"ms");
    }

结果如下：耗时557ms

2.批量确认发布
与单个等待确认消息相比，先发布一批消息然后一起确认可以极大地提高吞吐量，当然这种方式的缺点就是:当发生故障导致发布出现问题时，不知道是哪个消息出现问题了，我们必须将整个批处理保存在内存中，以记录重要的信息而后重新发布消息。当然这种方案仍然是同步的，也一样阻塞消息的发布。

//批量确认
    public static void publishMessageBatch() throws Exception{
        Channel channel = Util.getChannel();
        //队列的声明
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();
        //批量确认消息大小
        int batchSize = 100;
        //开始时间
        long begin = System.currentTimeMillis();
        //批量发消息 批量发布确认
        for (int i = 0; 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)+"ms");
    }

结果如下：耗时274ms

3.异步确认发布
异步确认虽然编程逻辑比上两个要复杂，但是性价比最高，无论是可靠性还是效率都没得说，他是利用回调函数来达到消息可靠性传递的,这个中间件也是通过函数回调来保证是否投递成功。

//异步发布确认
    public static void publishMessageAsync() throws Exception{
        Channel channel = Util.getChannel();
        //队列的声明
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();
        //开始时间
        long begin = System.currentTimeMillis();

        /**
         * deliveryTag:消息的标记
         * multiple：是否批量确认
         */
        //消息确认成功 回调函数
        ConfirmCallback ackCallback = (deliveryTag,multiple)->{
            System.out.println("确确认消息"+deliveryTag);
        };
        //消息确认失败 回调函数
        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)+"ms");
    }

结果如下：耗时21ms

要如何处理未发布确认的消息，需要在异步处理的情况下增加下面四步:(1)(2)(3)(4)步骤标注如下

//异步发布确认
    public static void publishMessageAsync() throws Exception{
        Channel channel = Util.getChannel();
        //队列的声明
        String queueName = UUID.randomUUID().toString();
        channel.queueDeclare(queueName,true,false,false,null);
        //开启发布确认
        channel.confirmSelect();

        /**
         * (1)
         * 线程安全有序的一个哈希表，适用于高并发的情况下
         *  1.将序号与消息进行关联
         *  2.批量删除条目 只要给到序号
         *  3.支持高并发(多线程)
         */
        ConcurrentSkipListMap<Long,String> outsConfirms = new ConcurrentSkipListMap<>();

        //开始时间
        long begin = System.currentTimeMillis();

        /**
         * deliveryTag:消息的标记
         * multiple：是否批量确认
         */
        //消息确认成功 回调函数
        ConfirmCallback ackCallback = (deliveryTag,multiple)->{
            //(3)删除到已经确认的消息，剩下的就是未确认的消息
            if(multiple){//批量确认 很少用要保证消息不丢失
                ConcurrentNavigableMap<Long, String> longStringConcurrentNavigableMap =
                        outsConfirms.headMap(deliveryTag);
                longStringConcurrentNavigableMap.clear();
            }else {//单个确认
                outsConfirms.remove(deliveryTag);
            }
            System.out.println("已确认消息"+deliveryTag);
        };
        //消息确认失败 回调函数
        ConfirmCallback nackCallback = (deliveryTag,multiple)->{
            //(4)处理打印未确认的消息
            String message = outsConfirms.get(deliveryTag);
            System.out.println("未确认消息"+deliveryTag+":"+message);
        };
        //准备消息监听器 监听那些消息成功，那些消息失败
        /**
         * 1.监听成功
         * 2.监听失败
         */
         channel.addConfirmListener(ackCallback,nackCallback);//异步通知
        //批量发送消息
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = i + "";
            channel.basicPublish("",queueName,null,message.getBytes());
            //(2)此处要记录发送的消息
            outsConfirms.put(channel.getNextPublishSeqNo(),message);
        }
        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("发布"+MESSAGE_COUNT+"个异步发布确认消息，耗时"+(end-begin)+"ms");
    }

最后

以上就是鲤鱼小刺猬为你收集整理的RabbitMq之发布确认的全部内容，希望文章能够帮你解决RabbitMq之发布确认所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。