java每日精进 2.20 MQ相关复健-EW帮帮网

在 RabbitMQ 中，消息消费者对消息的签收（acknowledgment）可以通过三种方式进行管理：自动签收、手动签收 和 拒绝签收。它们主要控制消费者如何处理消息确认和消息的重新排队。下面详细讲解它们的区别，并通过代码示例展示。

1. 自动签收（Auto Acknowledgment）

在自动签收模式下，RabbitMQ 会在消息被传递到消费者时自动进行消息确认（acknowledge），无需消费者明确地通知 RabbitMQ 消息已经被成功处理。这意味着只要消费者接受到消息，它就认为消息已成功处理并确认。

优点：
- 消费者的代码较为简单，不需要手动确认。
缺点：
- 如果消费者处理消息时发生错误，RabbitMQ 已经认为消息被成功处理，可能会导致消息丢失或无法重新投递。

2. 手动签收（Manual Acknowledgment）

在手动签收模式下，消费者需要显式地通知 RabbitMQ 消息已经被成功处理。消费者通过调用 channel.basicAck() 来手动确认消息。这种模式提供了更大的控制，可以确保只有在消息成功处理后才确认消息。

优点：
- 可以确保消息在处理成功后才会被确认，失败时可以拒绝签收并重新投递。
缺点：
- 需要开发者手动管理确认过程，代码相对复杂。

3. 拒绝签收（Reject Acknowledgment）

拒绝签收指的是消费者告知 RabbitMQ 它无法处理某个消息，可以通过 channel.basicReject() 或 channel.basicNack() 来拒绝该消息。拒绝签收的消息可以被重新投递到队列中或者直接丢弃，具体取决于设置的参数。

优点：
- 可以明确告诉 RabbitMQ 消息无法处理，并且可以选择将消息重新排队，供其他消费者处理。
缺点：
- 如果消息被拒绝并重新排队，可能会导致消息的重复消费。

代码示例

下面展示了 自动签收、手动签收 和 拒绝签收 的代码示例。

1. 自动签收（Auto Acknowledgment）

package com.home.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class AutoAckConsumer {

    // 自动签收
    @RabbitListener(queues = "myQueue", ackMode = "AUTO")
    public void handleMessage(String msg) {
        System.out.println("Received message (Auto Acknowledgment): " + msg);
        // 处理完消息后自动确认
    }
}

在自动签收模式下，消息会在 handleMessage 方法执行完毕后自动被 RabbitMQ 确认。

2. 手动签收（Manual Acknowledgment）

package com.home.consumer;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.listener.MessageListener;
import org.springframework.stereotype.Component;

@Component
public class ManualAckConsumer {

    // 手动签收
    @RabbitListener(queues = "myQueue", ackMode = "MANUAL")
    public void handleMessage(String msg, Message message) {
        System.out.println("Received message (Manual Acknowledgment): " + msg);
        
        // 处理完消息后显式调用 channel.basicAck() 来确认
        try {
            // 消息处理逻辑
            // 如果处理成功，手动确认消息
            message.getMessageProperties().getChannel().basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            // 处理失败时拒绝签收消息
            message.getMessageProperties().getChannel().basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
        }
    }
}

在手动签收模式下，您需要在代码中手动调用 basicAck() 来确认消息，或者在出现错误时使用 basicNack() 或 basicReject() 来拒绝消息。

3. 拒绝签收（Reject Acknowledgment）

package com.home.consumer;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.listener.MessageListener;
import org.springframework.stereotype.Component;

@Component
public class RejectAckConsumer {

    // 拒绝签收
    @RabbitListener(queues = "myQueue", ackMode = "MANUAL")
    public void handleMessage(String msg, Message message) {
        System.out.println("Received message (Reject Acknowledgment): " + msg);
        
        // 如果消息处理失败，则拒绝签收
        if (msg.contains("error")) {
            try {
                // 拒绝消息并重新排队
                message.getMessageProperties().getChannel().basicReject(message.getMessageProperties().getDeliveryTag(), true);
            } catch (Exception e) {
                System.out.println("Failed to reject the message.");
            }
        } else {
            // 处理成功时确认消息
            try {
                message.getMessageProperties().getChannel().basicAck(message.getMessageProperties().getDeliveryTag(), false);
            } catch (Exception e) {
                System.out.println("Failed to acknowledge the message.");
            }
        }
    }
}

在拒绝签收模式下，当消费者无法处理某个消息时，可以调用 basicReject() 或 basicNack() 来拒绝该消息，并根据需要选择是否将其重新排队。如果选择不重新排队，消息将会丢失。

总结

签收模式	描述	优点	缺点
自动签收	消费者收到消息后自动确认	代码简洁、开发快速	消息处理失败时可能丢失消息
手动签收	消费者需要显式确认消息处理成功或失败（使用 `basicAck`）	可确保消息成功处理后才确认，失败时可重试或重新排队	需要开发者手动管理确认过程，代码复杂
拒绝签收	消费者拒绝消息并可选择重新排队或丢弃	可以显式地告诉 RabbitMQ 消息无法处理，且重新排队	如果不设置合适的重试机制，可能导致消息重复消费

在实际使用时，选择何种签收方式依赖于您的应用需求，通常 手动签收 会提供更好的控制，尤其是在高可靠性需求的场景下。

拒绝签收后的操作

在 RabbitMQ 中，当你使用拒绝签收（basicReject() 或 basicNack()）时，可以选择是否将消息重新排队。你可以通过设置相应的参数来决定消息的处理方式。

basicReject() 和 basicNack() 方法的参数

这两个方法允许你传递一个参数，指示是否要重新排队消息：

requeue 参数：如果为 true，消息将被重新排队，等待其他消费者消费；如果为 false，消息将不会重新排队，可能会丢失（取决于配置）。

basicReject()

channel.basicReject(deliveryTag, requeue);

deliveryTag：是消息的唯一标识符，指示哪条消息被拒绝。
requeue：布尔值，指示消息是否应该重新排队。如果为 true，消息将重新排队到队列中；如果为 false，消息将丢失或直接被丢弃。

basicNack()

channel.basicNack(deliveryTag, multiple, requeue);

deliveryTag：与 basicReject() 中相同，用于标识消息。
multiple：是否拒绝所有比当前 deliveryTag 小的消息。如果为 true，则拒绝多个消息；如果为 false，则仅拒绝当前消息。
requeue：与 basicReject() 中相同，控制是否将消息重新排队。

1. 使用 `basicReject()` 来拒绝并重新排队

package com.home.consumer;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class RejectAndRequeueConsumer {

    @RabbitListener(queues = "myQueue", ackMode = "MANUAL")
    public void handleMessage(String msg, Message message) {
        System.out.println("Received message (Reject and Requeue): " + msg);

        // 如果消息处理失败，拒绝消息并重新排队
        if (msg.contains("error")) {
            try {
                // 拒绝并重新排队
                message.getMessageProperties().getChannel().basicReject(message.getMessageProperties().getDeliveryTag(), true);
                System.out.println("Message rejected and requeued");
            } catch (Exception e) {
                System.out.println("Failed to reject and requeue the message.");
            }
        } else {
            // 处理成功时确认消息
            try {
                message.getMessageProperties().getChannel().basicAck(message.getMessageProperties().getDeliveryTag(), false);
                System.out.println("Message processed successfully and acknowledged");
            } catch (Exception e) {
                System.out.println("Failed to acknowledge the message.");
            }
        }
    }
}

打印接收到的消息：首先，输出消息内容 msg。
消息失败处理：如果消息内容包含 "error"（通过 msg.contains("error") 检查），认为处理失败，执行以下操作：
- 拒绝并重新排队：通过 basicReject 方法拒绝消息，且设置 requeue = true，即将消息重新放回队列等待其他消费者处理。此时，RabbitMQ 会重新将消息排入队列，等待下一次消费。
- 异常处理：如果拒绝和重新排队消息过程中出现异常，捕获异常并打印错误信息。
消息成功处理：如果消息内容没有错误（即不包含 "error"），则认为消息处理成功，执行以下操作：
- 确认消息：通过 basicAck 方法手动确认消息已成功处理。
- 异常处理：如果在确认过程中发生异常，捕获并打印错误信息。

2. 使用 `basicReject()` 来拒绝并丢弃消息

package com.home.consumer;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class RejectAndDiscardConsumer {

    @RabbitListener(queues = "myQueue", ackMode = "MANUAL")
    public void handleMessage(String msg, Message message) {
        System.out.println("Received message (Reject and Discard): " + msg);

        // 如果消息处理失败，拒绝消息并丢弃
        if (msg.contains("error")) {
            try {
                // 拒绝并丢弃消息，不重新排队
                message.getMessageProperties().getChannel().basicReject(message.getMessageProperties().getDeliveryTag(), false);
                System.out.println("Message rejected and discarded");
            } catch (Exception e) {
                System.out.println("Failed to reject and discard the message.");
            }
        } else {
            // 处理成功时确认消息
            try {
                message.getMessageProperties().getChannel().basicAck(message.getMessageProperties().getDeliveryTag(), false);
                System.out.println("Message processed successfully and acknowledged");
            } catch (Exception e) {
                System.out.println("Failed to acknowledge the message.");
            }
        }
    }
}

打印接收到的消息：首先输出接收到的消息内容 msg。
消息失败处理：如果消息的内容包含 "error"（通过 msg.contains("error") 判断），就认为消息处理失败，并执行以下操作：
- 拒绝并丢弃消息：通过 basicReject 方法拒绝消息，并且将 requeue 设置为 false，即消息不会重新排回队列，而是直接丢弃。这样，该消息就不会再被其他消费者处理。
- 异常处理：如果拒绝和丢弃消息时发生异常，则捕获异常并打印错误信息。
消息成功处理：如果消息内容不包含 "error"，认为消息处理成功，执行以下操作：
- 确认消息：通过 basicAck 方法手动确认消息已被成功处理。
- 异常处理：如果确认消息时发生异常，则捕获并打印错误信息。

3.使用 `basicNack()` 来拒绝多个消息并重新排队

package com.home.consumer;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class NackAndRequeueConsumer {

    @RabbitListener(queues = "myQueue", ackMode = "MANUAL")
    public void handleMessage(String msg, Message message) {
        System.out.println("Received message (Nack and Requeue): " + msg);

        // 如果消息处理失败，拒绝多个消息并重新排队
        if (msg.contains("error")) {
            try {
                // 拒绝多个消息并重新排队
                message.getMessageProperties().getChannel().basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
                System.out.println("Message Nacked and requeued");
            } catch (Exception e) {
                System.out.println("Failed to nack and requeue the message.");
            }
        } else {
            // 处理成功时确认消息
            try {
                message.getMessageProperties().getChannel().basicAck(message.getMessageProperties().getDeliveryTag(), false);
                System.out.println("Message processed successfully and acknowledged");
            } catch (Exception e) {
                System.out.println("Failed to acknowledge the message.");
            }
        }
    }
}

打印接收到的消息：首先输出接收到的消息内容 msg。
消息失败处理：如果消息内容包含 "error"（通过 msg.contains("error") 判断），表示消息处理失败，执行以下操作：
- 拒绝多个消息并重新排队：通过 basicNack 方法拒绝消息，并设置以下参数：
  - multiple = false：表示只拒绝当前消息。如果设置为 true，则会拒绝当前消息以及所有较早的消息。
  - requeue = true：表示将消息重新排回队列等待其他消费者处理。
- 异常处理：如果在执行 basicNack 时出现异常，捕获异常并打印错误信息。
消息成功处理：如果消息内容不包含 "error"，则认为消息处理成功，执行以下操作：
- 确认消息：通过 basicAck 方法手动确认消息已经成功处理。
- 异常处理：如果在确认消息时发生异常，捕获并打印错误信息。

basicNack 和 basicAck 的区别：

basicNack：这个方法是用于拒绝消息（与 basicReject 类似）。basicNack 还可以处理多个消息，并允许你选择是否重新排队。与 basicReject 不同，basicNack 能够处理批量拒绝消息。
- multiple = false：表示仅拒绝当前消息。
- requeue = true：表示将消息重新排回队列。
basicAck：这是用来确认消息已经成功处理的。当消息被成功消费后，消费者需要调用该方法来告诉 RabbitMQ 消息已经被处理，RabbitMQ 可以删除该消息。

java每日精进 2.20 MQ相关复健

1. 自动签收（Auto Acknowledgment）

2. 手动签收（Manual Acknowledgment）

3. 拒绝签收（Reject Acknowledgment）

代码示例

1. 自动签收（Auto Acknowledgment）

2. 手动签收（Manual Acknowledgment）

3. 拒绝签收（Reject Acknowledgment）

总结

拒绝签收后的操作

1. 使用 `basicReject()` 来拒绝并重新排队

2. 使用 `basicReject()` 来拒绝并丢弃消息

3.使用 `basicNack()` 来拒绝多个消息并重新排队

网站公告

今日签到

热门文章

最新发布

java每日精进 2.20 MQ相关复健

1. 自动签收（Auto Acknowledgment）

2. 手动签收（Manual Acknowledgment）

3. 拒绝签收（Reject Acknowledgment）

代码示例

1. 自动签收（Auto Acknowledgment）

2. 手动签收（Manual Acknowledgment）

3. 拒绝签收（Reject Acknowledgment）

总结

拒绝签收后的操作

1. 使用 basicReject() 来拒绝并重新排队

2. 使用 basicReject() 来拒绝并丢弃消息

3.使用 basicNack() 来拒绝多个消息并重新排队

网站公告

今日签到

热门文章

最新发布

1. 使用 `basicReject()` 来拒绝并重新排队

2. 使用 `basicReject()` 来拒绝并丢弃消息

3.使用 `basicNack()` 来拒绝多个消息并重新排队