rabbitmq重试机制

已于 2022-08-18 10:27:49 修改
阅读量1.2k 收藏
点赞数
文章标签： java-rabbitmq rabbitmq java
于 2022-08-17 14:56:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yulingli42/article/details/126386134
版权

windows安装rabbitmq和启动
https://baijiahao.baidu.com/s?id=1720472084636520996&wfr=spider&for=pc

配置文件：

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        default-requeue-rejected: false
        acknowledge-mode: auto
        retry:
          enabled: true #是否开启消费者重试（为false时关闭消费者重试，这时消费端代码异常会一直重复收到消息）
          max-attempts: 4 #最大重试次数
          initial-interval: 1000 #重试间隔时间（单位毫秒）
          max-interval: 1200000 #重试最大时间间隔（单位毫秒）
          multiplier: 5 #应用于前一重试间隔的乘法器。

RabbitMQConfig：

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


import java.util.HashMap;
import java.util.Map;

@Configuration
public class RabbitMQConfig {

    public static final String BUSINESS_EXCHANGE_NAME = "dead.letter.demo.simple.business.exchange";
    public static final String BUSINESS_QUEUEA_NAME = "dead.letter.demo.simple.business.queuea";
    public static final String DEAD_LETTER_EXCHANGE = "dead.letter.demo.simple.deadletter.exchange";
    public static final String DEAD_LETTER_QUEUEA_ROUTING_KEY = "dead.letter.demo.simple.deadletter.queuea.routingkey";
    public static final String DEAD_LETTER_QUEUEA_NAME = "dead.letter.demo.simple.deadletter.queuea";

    // 声明业务Exchange
    @Bean("businessExchange")
    public FanoutExchange businessExchange() {
        return new FanoutExchange(BUSINESS_EXCHANGE_NAME);
    }

    // 声明死信Exchange
    @Bean("deadLetterExchange")
    public DirectExchange deadLetterExchange() {
        return new DirectExchange(DEAD_LETTER_EXCHANGE);
    }

    // 声明业务队列A
    @Bean("businessQueueA")
    public Queue businessQueueA() {
        Map<String, Object> args = new HashMap<>(2);
//       x-dead-letter-exchange    这里声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE);
//       x-dead-letter-routing-key  这里声明当前队列的死信路由key
        args.put("x-dead-letter-routing-key", DEAD_LETTER_QUEUEA_ROUTING_KEY);
//        args.put("x-message-ttl", 10000);
        return QueueBuilder.durable(BUSINESS_QUEUEA_NAME).withArguments(args).build();
    }


    // 声明死信队列A
    @Bean("deadLetterQueueA")
    public Queue deadLetterQueueA() {
        return new Queue(DEAD_LETTER_QUEUEA_NAME);
    }


    // 声明业务队列A绑定关系
    @Bean
    public Binding businessBindingA(@Qualifier("businessQueueA") Queue queue,
                                    @Qualifier("businessExchange") FanoutExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange);
    }


    // 声明死信队列A绑定关系
    @Bean
    public Binding deadLetterBindingA(@Qualifier("deadLetterQueueA") Queue queue,
                                      @Qualifier("deadLetterExchange") DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(DEAD_LETTER_QUEUEA_ROUTING_KEY);
    }


}

BusinessMessageSender ：

@Component
public class BusinessMessageSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMsg(MsgLog msgLog) {
        rabbitTemplate.convertSendAndReceive(RabbitMQConfig.BUSINESS_EXCHANGE_NAME, "",msgLog);
    }
}

BusinessMessageReceiver ：

@Slf4j
@Component
public class BusinessMessageReceiver {

    @Autowired
    private MsgLogMapper msgLogMapper;

    @Value("${spring.rabbitmq.listener.simple.retry.max-attempts}")
    private int max_attempts;

    @RabbitListener(queues = RabbitMQConfig.BUSINESS_QUEUEA_NAME)
    public void receiveA(MsgLog msgLog, Message message, Channel channel) throws IOException {
        String msg = msgLog.toString();
        log.info("收到业务消息：{}", msg);
        JSONObject retJson = new JSONObject();
        String ret = null;
//      ret = HttpRequest.post(msgLog.getUrl()).body(msgLog.getMsg()).execute().body();
//        retJson = JSONObject.parseObject(ret);
//        log.info("ret" + ret);
        retJson.put("resultCode", 301);
        msgLog.setTime(LocalDateTime.now());
        msgLog.setResult(ret);
        int count = 1;
        Map<String, Object> headers = message.getMessageProperties().getHeaders();
        log.info(headers.toString());
        if (headers.get("failed_count_for_send_to_exchange") != null) {
            count = (int) headers.get("failed_count_for_send_to_exchange");
        }
        if (count == max_attempts) {
            msgLog.setStatus(4);
            msgLog.setRetryCount(max_attempts);
            msgLogMapper.updateById(msgLog);
        }
        if (!retJson.get("resultCode").equals(200)) {
            headers.put("failed_count_for_send_to_exchange", count + 1);
            throw new RuntimeException("重试");
        } else {
            msgLog.setRetryCount(count);
            msgLog.setStatus(3);
            msgLogMapper.updateById(msgLog);
        }
    }
}

死信队列：

@Slf4j
@Component
public class DeadLetterMessageReceiver {

    @RabbitListener(queues = RabbitMQConfig.DEAD_LETTER_QUEUEA_NAME)
    public void receiveA(MsgLog msgLog, Message message, Channel channel) {
        log.info("收到死信消息：" + msgLog.toString());
    }
}

MsgLog ：

@Data
@Accessors(chain = true)
@ApiModel(value = "MsgLog对象", description = "消息投递日志")
public class MsgLog implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "消息唯一标识")
    @TableId(type = IdType.AUTO)
    private Integer id;

    @ApiModelProperty(value = "消息体, json格式化")
    private String msg;

    @ApiModelProperty(value = "请求地址")
    private String url;

    @ApiModelProperty(value = "请求时间")
    private LocalDateTime time;

    @ApiModelProperty(value = "请求结果")
    private String result;

    @ApiModelProperty(value = "状态，1：请求成功 2：重试中 3：重试后成功 4：重试后失败")
    private Integer status;

    @ApiModelProperty(value = "重试次数")
    private Integer retryCount;
}

ServiceImpl：

    @Override
    public void send(String msg) {

        JSONObject orderJson = new JSONObject();
        log.info("接口入参" + orderJson);
        String uri = "";
        JSONObject retJson = new JSONObject();
        String ret = "";
//        String ret = HttpRequest.post(msgLog.getUrl()).body(msgLog.getMsg()).execute().body();
//        retJson = JSONObject.parseObject(ret);
//        log.error("ret" + ret);
        retJson.put("resultCode", 301);
        MsgLog msgLog = new MsgLog();
//            msgLog.setMsg(JSONUtil.toJsonPrettyStr(orderJson));
        msgLog.setMsg(msg);
        msgLog.setUrl(uri);
        msgLog.setResult(ret);
        msgLog.setTime(LocalDateTime.now());
        if (!retJson.get("resultCode").equals(200)) {
            msgLog.setRetryCount(0);
            msgLog.setStatus(2);
            msgLogMapper.insert(msgLog);
            businessMessageSender.sendMsg(msgLog);
        } else {
            msgLog.setStatus(1);
            msgLogMapper.insert(msgLog);
        }
    }

控制台结果：

2022-08-18 09:29:23.859  INFO 33992 --- [nio-9001-exec-1] .l.DirectReplyToMessageListenerContainer : Container initialized for queues: [amq.rabbitmq.reply-to]
2022-08-18 09:29:23.869  INFO 33992 --- [nio-9001-exec-1] .l.DirectReplyToMessageListenerContainer : SimpleConsumer [queue=amq.rabbitmq.reply-to, consumerTag=amq.ctag-8VFVj3Nm7FX4gnMtghuEsg identity=3a7c278d] started
2022-08-18 09:29:24.040  INFO 33992 --- [ntContainer#0-1] c.y.t.config.BusinessMessageReceiver     : 收到业务消息：MsgLog(id=41, msg=3, url=, time=2022-08-18T09:29:23.184, result=, status=2, retryCount=0)
2022-08-18 09:29:24.040  INFO 33992 --- [ntContainer#0-1] c.y.t.config.BusinessMessageReceiver     : {}
2022-08-18 09:29:25.057  INFO 33992 --- [ntContainer#0-1] c.y.t.config.BusinessMessageReceiver     : 收到业务消息：MsgLog(id=41, msg=3, url=, time=2022-08-18T09:29:23.184, result=, status=2, retryCount=0)
2022-08-18 09:29:25.057  INFO 33992 --- [ntContainer#0-1] c.y.t.config.BusinessMessageReceiver     : {failed_count_for_send_to_exchange=2}
2022-08-18 09:29:30.072  INFO 33992 --- [ntContainer#0-1] c.y.t.config.BusinessMessageReceiver     : 收到业务消息：MsgLog(id=41, msg=3, url=, time=2022-08-18T09:29:23.184, result=, status=2, retryCount=0)
2022-08-18 09:29:30.073  INFO 33992 --- [ntContainer#0-1] c.y.t.config.BusinessMessageReceiver     : {failed_count_for_send_to_exchange=3}
2022-08-18 09:29:55.080  INFO 33992 --- [ntContainer#0-1] c.y.t.config.BusinessMessageReceiver     : 收到业务消息：MsgLog(id=41, msg=3, url=, time=2022-08-18T09:29:23.184, result=, status=2, retryCount=0)
2022-08-18 09:29:55.080  INFO 33992 --- [ntContainer#0-1] c.y.t.config.BusinessMessageReceiver     : {failed_count_for_send_to_exchange=4}
2022-08-18 09:29:55.123  WARN 33992 --- [ntContainer#0-1] o.s.a.r.r.RejectAndDontRequeueRecoverer  : Retries exhausted for message (Body:'[B@92cf7a6(byte[352])' MessageProperties [headers={failed_count_for_send_to_exchange=5}, correlationId=1, replyTo=amq.rabbitmq.reply-to.g1h2AA5yZXBseUA3OTY0NjI5NwAABHEAAAAAYv2Rlw==.Hsw8oUWTg7ZabM+vBpqkgQ==, contentType=application/x-java-serialized-object, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=dead.letter.demo.simple.business.exchange, receivedRoutingKey=, deliveryTag=1, consumerTag=amq.ctag-zIRXwiHfxwFbi6cfMGBJOQ, consumerQueue=dead.letter.demo.simple.business.queuea])

org.springframework.amqp.rabbit.listener.exception.ListenerExecutionFailedException: Listener method 'public void com.yull.testyu.config.BusinessMessageReceiver.receiveA(com.yull.testyu.entity.MsgLog,org.springframework.amqp.core.Message,com.rabbitmq.client.Channel) throws java.io.IOException' threw exception
	at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.invokeHandler(MessagingMessageListenerAdapter.java:204) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.onMessage(MessagingMessageListenerAdapter.java:129) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.doInvokeListener(AbstractMessageListenerContainer.java:1542) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.actualInvokeListener(AbstractMessageListenerContainer.java:1468) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_172]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_172]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_172]
	at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_172]
	at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:343) ~[spring-aop-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:198) ~[spring-aop-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163) ~[spring-aop-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.retry.interceptor.RetryOperationsInterceptor$1.doWithRetry(RetryOperationsInterceptor.java:91) ~[spring-retry-1.2.4.RELEASE.jar:na]
	at org.springframework.retry.support.RetryTemplate.doExecute(RetryTemplate.java:287) [spring-retry-1.2.4.RELEASE.jar:na]
	at org.springframework.retry.support.RetryTemplate.execute(RetryTemplate.java:180) [spring-retry-1.2.4.RELEASE.jar:na]
	at org.springframework.retry.interceptor.RetryOperationsInterceptor.invoke(RetryOperationsInterceptor.java:115) ~[spring-retry-1.2.4.RELEASE.jar:na]
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:212) ~[spring-aop-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.$Proxy108.invokeListener(Unknown Source) ~[na:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.invokeListener(AbstractMessageListenerContainer.java:1456) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.doExecuteListener(AbstractMessageListenerContainer.java:1451) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.executeListener(AbstractMessageListenerContainer.java:1400) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer.doReceiveAndExecute(SimpleMessageListenerContainer.java:875) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer.receiveAndExecute(SimpleMessageListenerContainer.java:859) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer.access$1600(SimpleMessageListenerContainer.java:78) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer$AsyncMessageProcessingConsumer.mainLoop(SimpleMessageListenerContainer.java:1142) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer$AsyncMessageProcessingConsumer.run(SimpleMessageListenerContainer.java:1048) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at java.lang.Thread.run(Thread.java:748) ~[na:1.8.0_172]
Caused by: java.lang.RuntimeException: 重试
	at com.yull.testyu.config.BusinessMessageReceiver.receiveA(BusinessMessageReceiver.java:56) ~[classes/:na]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_172]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_172]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_172]
	at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_172]
	at org.springframework.messaging.handler.invocation.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:171) ~[spring-messaging-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.messaging.handler.invocation.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:120) ~[spring-messaging-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.adapter.HandlerAdapter.invoke(HandlerAdapter.java:50) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.invokeHandler(MessagingMessageListenerAdapter.java:196) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	... 26 common frames omitted

2022-08-18 09:29:55.124  WARN 33992 --- [ntContainer#0-1] s.a.r.l.ConditionalRejectingErrorHandler : Execution of Rabbit message listener failed.

org.springframework.amqp.rabbit.listener.exception.ListenerExecutionFailedException: Retry Policy Exhausted
	at org.springframework.amqp.rabbit.retry.RejectAndDontRequeueRecoverer.recover(RejectAndDontRequeueRecoverer.java:45) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.config.StatelessRetryOperationsInterceptorFactoryBean.lambda$getObject$0(StatelessRetryOperationsInterceptorFactoryBean.java:64) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.retry.interceptor.RetryOperationsInterceptor$ItemRecovererCallback.recover(RetryOperationsInterceptor.java:141) ~[spring-retry-1.2.4.RELEASE.jar:na]
	at org.springframework.retry.support.RetryTemplate.handleRetryExhausted(RetryTemplate.java:512) ~[spring-retry-1.2.4.RELEASE.jar:na]
	at org.springframework.retry.support.RetryTemplate.doExecute(RetryTemplate.java:351) ~[spring-retry-1.2.4.RELEASE.jar:na]
	at org.springframework.retry.support.RetryTemplate.execute(RetryTemplate.java:180) ~[spring-retry-1.2.4.RELEASE.jar:na]
	at org.springframework.retry.interceptor.RetryOperationsInterceptor.invoke(RetryOperationsInterceptor.java:115) ~[spring-retry-1.2.4.RELEASE.jar:na]
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:212) ~[spring-aop-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.$Proxy108.invokeListener(Unknown Source) ~[na:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.invokeListener(AbstractMessageListenerContainer.java:1456) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.doExecuteListener(AbstractMessageListenerContainer.java:1451) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.executeListener(AbstractMessageListenerContainer.java:1400) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer.doReceiveAndExecute(SimpleMessageListenerContainer.java:875) [spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer.receiveAndExecute(SimpleMessageListenerContainer.java:859) [spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer.access$1600(SimpleMessageListenerContainer.java:78) [spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer$AsyncMessageProcessingConsumer.mainLoop(SimpleMessageListenerContainer.java:1142) [spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer$AsyncMessageProcessingConsumer.run(SimpleMessageListenerContainer.java:1048) [spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at java.lang.Thread.run(Thread.java:748) [na:1.8.0_172]
Caused by: org.springframework.amqp.AmqpRejectAndDontRequeueException: null
	... 19 common frames omitted
Caused by: org.springframework.amqp.rabbit.listener.exception.ListenerExecutionFailedException: Listener method 'public void com.yull.testyu.config.BusinessMessageReceiver.receiveA(com.yull.testyu.entity.MsgLog,org.springframework.amqp.core.Message,com.rabbitmq.client.Channel) throws java.io.IOException' threw exception
	at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.invokeHandler(MessagingMessageListenerAdapter.java:204) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.onMessage(MessagingMessageListenerAdapter.java:129) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.doInvokeListener(AbstractMessageListenerContainer.java:1542) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.actualInvokeListener(AbstractMessageListenerContainer.java:1468) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_172]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_172]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_172]
	at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_172]
	at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:343) ~[spring-aop-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:198) ~[spring-aop-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163) ~[spring-aop-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.retry.interceptor.RetryOperationsInterceptor$1.doWithRetry(RetryOperationsInterceptor.java:91) ~[spring-retry-1.2.4.RELEASE.jar:na]
	at org.springframework.retry.support.RetryTemplate.doExecute(RetryTemplate.java:287) ~[spring-retry-1.2.4.RELEASE.jar:na]
	... 14 common frames omitted
Caused by: java.lang.RuntimeException: 重试
	at com.yull.testyu.config.BusinessMessageReceiver.receiveA(BusinessMessageReceiver.java:56) ~[classes/:na]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_172]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_172]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_172]
	at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_172]
	at org.springframework.messaging.handler.invocation.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:171) ~[spring-messaging-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.messaging.handler.invocation.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:120) ~[spring-messaging-5.1.12.RELEASE.jar:5.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.adapter.HandlerAdapter.invoke(HandlerAdapter.java:50) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.invokeHandler(MessagingMessageListenerAdapter.java:196) ~[spring-rabbit-2.1.12.RELEASE.jar:2.1.12.RELEASE]
	... 26 common frames omitted

2022-08-18 09:29:55.131  INFO 33992 --- [ntContainer#1-1] c.y.t.config.DeadLetterMessageReceiver   : 收到死信消息：MsgLog(id=41, msg=3, url=, time=2022-08-18T09:29:23.184, result=, status=2, retryCount=0)

消息流转的流程：

  1. 当请求外部地址返回的code不是成功的code时，将消息封装成MsgLog对象，发送到重试队列；
  2. 在重试队列中进行重新请求外部地址，如果还是失败，会抛出异常，进行重试，重试次数和间隔时间由配置文件决定；
  3. 到达最大重试次数后，重试队列会将消息发送到死信队列，死信队列的消费者费死信消息。

重试次数可以存放在message的header中，由于每次重试和发送到死信队列中的消息都是最开始放进发送到普通队列中的消息，所以选择在重试队列判断是否到了最大重试次数，从而更新数据库。

一只多比
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ重试机制
pan_junbiao的博客
01-23 8823
1、RabbitMQ重试机制的简介 RabbitMQ 不会为未确认的消息设置过期时间，它判断此消息是否需要重新投递给消费者的唯一依据是消费该消息连接是否已经断开，这个设置的原因是 RabbitMQ 允许消费者消费一条消息的时间可以很久很久。 RabbitMQ 的 Web 管理平台上可以看到当前队列中的 “Ready” 状态和 “Unacknowledged” 状态的消息数，分别对应等待投递给消费者的消息数和已经投递给消费者但是未收到确认信号的消息数。如下图： 注意事项： 如果在处理消息的过程中
RabbitMq 消费失败，重试机制
添砖加瓦
05-16 6026
方案一： 本地消息表 + 定时任务 本地消息表：主要用于存储 业务数据、交换机、队列、路由、次数 定时任务：定时扫描本地消息表，重新给业务队列投递消息。 方案二： 利用 rabbitmq_delayed_message_exchange 插件 实现延迟队列 具体思路：业务队列消费失败时，给延迟队列发送一条消息，消息包含业务数据、交换机、队列、次数、最大次数等，延迟队列收到消息后重新给业务队列投递消息。业务队列二次收到消息时，再次消费失败，校验最大次数，判断是否再次重试。...
RabbitMQ高级
柒柒柒柒
04-29 575
RabbitMQ高级
RabbitMQ中重试机制的坑
黄国攀的博客
01-27 6189
当我们消息消费失败的时候，可以进行重试，虽然SpringAMQP集成了retry机制，但是发现使用过程有点坑，等会细说 重试机制使用场景： 1.如果是业务代码，比如空指针之类的异常那重试机制其实没什么用 2.如果是调用第三方系统，网络抖动之类的那重试机制就有用 配置使用重试机制 spring.rabbitmq.listener.simple.retry.enabled=true 是否开启消费者重试（为false时重试不生效） spring.rabbitmq.listener.simple.retry.max
python rabbitmq 消息重试机制_rabbitMQ消息重试机制
weixin_39718083的博客
03-01 759
消费端在处理消息过程中可能会报错，此时该如何重新处理消息呢？解决方案有以下两种。在redis或者数据库中记录重试次数，达到最大重试次数以后消息进入死信队列或者其他队列，再单独针对这些消息进行处理；使用spring-rabbit中自带的retry功能；第一种方案我们就不再详细说了，我们主要来看一下第二种方案，老规矩，先上代码：spring:rabbitmq:listener:simple:ackno...
RabbitMQ重试机制：带有TTL +无效字母的简单RabbitMQ重试机制
02-06
输入TTL +死信动机不过，可以使用TTL（生存时间）发布消息。 这几乎意味着消息将一直保留在队列中，直到该特定时间到期为止： 邮件不会在队列中停留超过1秒queue.publish( " some message " , expiration: 1000) ...
rabbitmq面试题.pdf
最新发布
06-05
以下是针对RabbitMQ的一些面试题，覆盖了基础概念、架构、特性、使用场景、性能、监控与管理...12. 什么是RabbitMQ的消息重试机制？ 13. 解释RabbitMQ的集群，它是如何工作的？ 14. RabbitMQ的镜像队列（Mirrored Queue
rabbitmq解决分布式事务
01-28
答案：使用消息重试机制。(springboot默认有消息重试机制) 消费者获取到消息后，调用第三方接口，但接口暂时无法访问，是否需要重试?（需要重试机制） 消费者获取到消息后，抛出数据转换异常，是否需要重试?（不需要...
rabbitMQ笔记.docx
03-10
记录rabbit从入门都精通的实操过程，记录和分析了rabbitMQ的各种模式的使用，以及验证代码，包括与springboot整合搭建，演示了重试机制，死信队列的使用方法，手动应答等。
RabbitMQ双活架构设计.docx
10-13
在本文中，我们将介绍 RabbitMQ 双活架构设计的实现，包括消息 Publish 可靠性、消息 Consume 可靠性、消息延迟重试机制和消息延时消费等。 消息 Publish 可靠性 在 RabbitMQ 中，消息 Publish 可靠性是通过确认...
RabbitMQ消费失败重试策略、及重试策略应用场景详解
hkl_Forever的博客
12-01 8296
【2】比如我们在消费过程中，业务代码出现异常(空指针、除数为0等)这类代码不健壮导致的异常，那么这时候需要重试吗？当然不需要重试，因为业务代码异常就算重试再多次也依然会异常，代码异常需要发版修复解决，所以重试没有意义。RabbitMQ消费者一般情况下，如果消费失败出现异常，那么消费端默认是无限重试消费，这样就会带来非常不好的一个情况，就是陷入死循环，一直报错一直重试。【2】业务代码出现异常(空指针、除数为0等)这类代码不健壮导致的异常，不需要重试，没有意义。【3】异常不需要触发重试策略的消息，
Springboot (四) RabbitMQ消费者重试机制（spring retry）
大米饭
03-26 9325
1. 什么时候应该用MQ? 2. Rabbit 基础知识 3. docker 安装 RabbitMQ 3. Springboot (四) RabbitMQ入门 Springboot (四) RabbitMQ消费者重试机制（spring retry实现） 1. 新建配置类 ，上代码 重点在于，retryTemplate 设置重试 。 @Slf4j @Configuration public clas...
RabbitMQ高级特性
FYHannnnnn的博客
11-26 756
一，消息的可靠性 客户端代码中的异常捕获，包括生产者和消费者 消息发送过程通过try catch 方式捕获异常， 在异常处理理的代码块中执行行回滚业务操作或者执行行重发操作等。这是一种最大努力确保的方式， 并无法保证100%绝对可靠，因为这里没有异常并不代表消息就一定投递成功。 可以通过spring.rabbitmq.template.retry.enabled=true 配置开启发送端的重试 AMQP/RabbitMQ的事务机制 没有捕获到异常...
RabbitMQ 消息重试 和错误策略
qq_31614535的博客
03-29 212
这段代码就是声明一个 自动重试的 工厂 其中RejectAndDontRequeueRecoverer 是重试次数完后的策略 我这边设置的是 拒绝消息。但是请注意 想要拒绝消息 消息确认模式必须要是自动的！RabbitMQ标准支持消息重试，不需要自己去写这个逻辑。如果不满足当前业务要求 那可以自己写。它有几种模式 可以具体搜一下 比如消息转发 还有简单的日志记录模式。然后就可以在想用的@RabbitListener注解上使用了。手动确认 则不生效。
集成框架-RabbitMQ重试和确认
寿春
05-16 1011
在中，你可以使用yml格式的配置文件来配置RabbitMQ的重试机制。spring:rabbitmq:port: 5672listener:simple:retry:initial-interval: 5000 # 初始重试间隔时间（毫秒）max-attempts: 3 # 最大重试次数max-interval: 10000 # 最大重试间隔时间（毫秒）multiplier: 2.0 # 重试间隔时间倍数在这个配置中，启用了RabbitMQ 的重试机制，并指定了重试的初始间隔时间。
【spring cloud】stream集成rabbitMQ死信队列
不想睡觉的橘子君的博客
12-15 1583
如果多次重复消费依然不成功，总要有个兜底的，那就给它丢到死信队列（Dead Letter Queue, DLQ）里就好了。 在死信队列中的消息，不会主动向消费者发送消息，需要我们人工处理，比如将它们取出再次消费等。 引入依赖、创建topic等工作就不再赘述，可以参考上篇文章：【spring cloud】stream集成rabbitMQ，实现Topic订阅发布 配置如下： #死信队列 spring.cloud.stream.bindings.dlq-consumer.destination=dlq-topic
Springboot2整合Rabbitmq消息确认机制、幂等性、重试机制
小猪呀的博客
07-08 1762
1.消息确认机制 友情提示该文章是跟着上一篇文章继续的，连接:https://blog.csdn.net/qq_41085151/article/details/107102962 问题1：如果在发送消息的时候，消费者出现了异常，那么你监听的消息就会一直循环消费。比如 一.提供者： @Component public class HelloProvider{ @Autowired private RabbitTemplate rabbitTemplate1; publi
RabbitMQ 重试机制和消息幂等性
热门推荐
charming的专栏
05-10 1万+
幂等性 消费者在消费mq中的消息时，mq已把消息发送给消费者，消费者在给mq返回ack时网络中断，故mq未收到确认信息，该条消息会重新发给其他的消费者，或者在网络重连后再次发送给该消费者，但实际上该消费者已成功消费了该条消息，造成消费者消费了重复的消息； 解决办法 MQ消费者的幂等行的解决一般使用全局ID 或者写个唯一标识比如时间戳 或者UUID 或者订单 消费者消费mq中的消息：也可利用...
Spring-RabbitMq 参数配置详解
ystyaoshengting的专栏
04-02 6865
基础信息 spring.rabbitmq.host: 默认localhost spring.rabbitmq.port: 默认5672 spring.rabbitmq.username: 用户名 spring.rabbitmq.password: 密码 spring.rabbitmq.virtual-host: 连接到代理时用的虚拟主机 spring.rabbitmq.addresses: 连...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值