在Java中，可以使用消息队列来实现消息的异步处理，其中常用的消息队列有 RabbitMQ、ActiveMQ、Kafka 等。

　　为了避免消息被重复消费，可以使用以下几种方法：

　　1.消息队列提供的幂等性机制

　　常见的消息队列如 Kafka、RocketMQ等提供了幂等性机制，能够确保同一条消息被消费多次时只会产生一次影响。在Kafka中，可以通过设置消息的key来实现幂等性。

　　2.消费者自己维护消费记录

　　消费者可以在消费一条消息后，将其在数据库中或者内存中记录下来。在消费下一条消息时，先查询是否已经消费过该消息，如果已经消费过，则不再处理。

　　3.使用分布式锁

　　在消费消息时，可以使用分布式锁来保证同一条消息只会被一个消费者处理。常见的分布式锁实现有 ZooKeeper、Redis 等。

　　接下来我们以使用RabbitMQ消息队列为例，演示如何实现消息的幂等性。

　　(1)首先，需要使用RabbitMQ的Java客户端库，可以通过Maven引入以下依赖：

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.12.0</version>
</dependency>

　　(2)接着，可以使用以下代码向RabbitMQ发送消息：

ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();

String message = "Hello World!";
String exchangeName = "test_exchange";
String routingKey = "test_routing_key";
String messageId = UUID.randomUUID().toString();

AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
        .messageId(messageId)
        .build();

channel.basicPublish(exchangeName, routingKey, properties, message.getBytes());

System.out.println("Sent message: " + message);

channel.close();
connection.close();

　　在发送消息时，使用了 UUID.randomUUID().toString()生成了一个唯一的消息 ID，作为消息的messageId 属性。

　　(3)然后，可以使用以下代码消费 RabbitMQ 中的消息，并实现幂等性：

ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();

String exchangeName = "test_exchange";
String queueName = "test_queue";
String routingKey = "test_routing_key";

channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT, true);
channel.queueDeclare(queueName, true, false, false, null);
channel.queueBind(queueName, exchangeName, routingKey);

channel.basicQos(1);

Consumer consumer = new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        String messageId = properties.getMessageId();
        String message = new String(body, StandardCharsets.UTF_8);

        if (!isMessageProcessed(messageId)) {
            processMessage(message);
            saveProcessedMessage(messageId);
        }

        channel.basicAck(envelope.getDeliveryTag(), false);
    }
};

channel.basicConsume(queueName, false, consumer);

System.out.println("Waiting for messages...");

　　在消费消息时，首先从消息的properties中获取messageId属性，并使用isMessageProcessed()方法查询该消息是否已经被处理过。如果没有被处理过，则调用processMessage()方法处理该消息，并使用 saveProcessedMessage()方法保存已经处理过的消息。

　　在处理完消息后，还需要调用channel.basicAck(envelope.getDeliveryTag(), false)方法确认消息已经被消费。这是因为RabbitMQ是一个消息的投递机制，只有在消费者确认了消息已经被处理后，才会从消息队列中删除该消息。

　　以上代码演示了如何在RabbitMQ中实现消息的幂等性。在消费消息时，通过查询已经处理过的消息来避免重复处理。同时，使用了唯一的消息ID来确保同一条消息只会被处理一次。

　　笔者开篇列举的3种方法均可保证消息不被重复消费，但需要根据实际情况选择适合自己的方案。