java每日精进 2.20 MQ相关复健

在 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 可以删除该消息。