RabbitMQ学习07--消息重复消费

幂等性操作 ：可以重复执行的操作，可以不用保证消息重复消费。

非幂等性，需要保证消息不会被重复消费。

重复消费原因：消费者消费了消息，但并没有向rabbitmq发送ack。

为了解决消费重复消费的问题，可以使用Redis，在消费者消费之前，先将消息的id放到Redis中，

id-0(正在执行业务)

id-1(业务执行成功)

如果ack失败，在RabbitMQ将消息交给其他消费者时，先执行Redis的setnx。

如果key不存在，则当前消费者消费此消息，然后发送ack。

如果key已经存在，则判断其值：

value值为0，表示有消费者正在处理这个消息，则当前消费者不做操作。

value值为1，表示已经有其他消费者处理了这个消息，但是没有向RabbitMQ发送ack，则但钱消费者直接发送ack。

极端情况：某消费者在执行业务时出现了死锁，则需要在setnx的基础上，再设置一个生存时间。

发布者代码：

package com.yas.myreturn;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.io.IOException;
import java.util.UUID;

public class Publisher {
    @Test
    public void publish() throws Exception {
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建Channel
        Channel channel = connection.createChannel();

        //3.1 开启Confirm
        channel.confirmSelect();

        //判断消息发送是否成功
        //异步发送
        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("消息发送成功，标识：" + deliveryTag + ",是否是批量：" + multiple);
            }

            @Override
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("消息发送失败，标识：" + deliveryTag + ",是否是批量：" + multiple);
            }
        });

        //3.发布消息到exchange，同时指定路由规则

        //开启Return机制
        channel.addReturnListener(new ReturnListener() {
            //当消息没有送到queue时，才会执行
            @Override
            public void handleReturn(int replyCode, String replyText, String exchange, String routingKey, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(new String(body, "UTF-8") + "没有送到Queue中");
            }
        });

        //参数1：指定exchange，使用空字符串，表示默认exchange。
        //参数2：指定路由规则，使用具体的队列名称。
        //参数3：指定传递的消息所携带的properties。
        //参数4：指定发布的具体消息，字节数组类型byte[]
//        channel.basicPublish("", "HelloWorld", null, msg.getBytes());

        //生产者发送消息时，指定messageid
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder()
                .deliveryMode(1)//指定消息是否需要持久化，1需要，2不需要
                .messageId(UUID.randomUUID().toString())
                .build();
        String msg = "Hello World";
        //使用带return机制的发布,mandatory:true
        channel.basicPublish("", "HelloWorld", true, properties, msg.getBytes());

        //注意：exchange是不会将消息持久化到本地的，Queue有持久化的功能。

        System.out.println("生产者发布消息成功");

        //4.释放资源
        channel.close();
        connection.close();
    }
}

消费者代码：

package com.yas.myreturn;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;
import redis.clients.jedis.Jedis;

import java.io.IOException;

public class Consumer {
    @Test
    public void consume() throws Exception {
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();
        //3.生命队列-Hello World
        //参数1：queue，队列名称
        //参数2：durable，当前队列是否需要持久化
        //参数3：exclusive，是否排外
        //      影响1：当connection.close()时，当前队列会被自动删除
        //      影响2：当前队列只能被一个消费者消费
        //参数4：autoDelete，如果这个队列没有消费者消费，队列自动删除
        //参数5：arguments，指定当前队列的其他信息
        channel.queueDeclare("HelloWorld", true, false, false, null);
        //4.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                //1、连接Redis
                Jedis jedis = new Jedis("ubu", 6379);

                jedis.auth("123456");

                String messageId = properties.getMessageId();
                //2、操作Redis - redis的命令是什么jedis对应的方法就是什么
                //setnx，value值0
                String redisResult = jedis.set(messageId, "0", "NX", "EX", 10000);
                //如果setnx返回不为null(返回1)，表示设置成功，redis原本没有这个key
                if (redisResult != null && redisResult.equalsIgnoreCase("ok")) {
                    //消费成功，set messageid
                    System.out.println("接受到消息id：" + messageId + "，内容：" + new String(body, "UTF-8"));
                    jedis.set(messageId, "1");//redis标记修改为1，表示已经消费完成
                    channel.basicAck(envelope.getDeliveryTag(), false);
                } else {
                    //如果setnx返回null(返回0)，redis原本有这个key
                    String s = jedis.get(messageId);//读取原来的值
                    if ("1".equalsIgnoreCase(s)) {//  如果是1 表示原来的消费者已经消费了信息，但是没有发送ack，则当前消费者补发ack
                        System.out.println("对消息：" + s + "，补发ack");
                        channel.basicAck(envelope.getDeliveryTag(), false);//补发ack
                    } else {
                        //  如果是0 表示原来的消费者正在处理，现在的消费者不用做任何处理
                        System.out.println("无需对消息" + s + "做任何处理");
                    }
                }
                //3、释放资源
                jedis.close();
            }
        };
        //参数1：queue，指定消费哪个队列
        //参数2：deliverCallback，指定是否自动ACK，(true表示，接受到消息后，会立即通知RabbitMQ)
        //参数3：consumer，指定消费回调
        channel.basicConsume("HelloWorld", true, consumer);
        System.out.println("消费者开始监听队列");
        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}