Rabbitmq取消预取机制配置，配置手动确认后仍然java.lang.IllegalStateException: Channel closed； cannot ack/nack的问题

ChengQinHong

已于 2022-10-12 13:47:52 修改

阅读量3k

点赞数

CC 4.0 BY-SA版权

分类专栏： RabbitMQ 文章标签： rabbitmq

于 2022-10-09 14:28:32 首次发布

本文链接：https://blog.youkuaiyun.com/ChengQinHong/article/details/127223224

RabbitMQ 专栏收录该内容

2 篇文章

订阅专栏

背景

根据教程写了工作队列，然后发现2个消费者是公平消费的，即10条消息，2个队列，分别取到了5条消息进行消费，由于教程设置2个消费者分别线程休眠时间不一样，目的是让其消费速度不一致，模仿实际生产中消息消费过程时间有长有短。（一个消费慢，一个消费快，若公平消费的话，即平分当前消息量，快的消费者已经干完事在休息了，慢的消费者还有一大堆消息等着处理呢，明显不符合资源调配利用，应该能者多劳）

配置

因为想要实现“能者多劳”的功能，所以消息的应答方式一定要设置成手动应答manual，参数prefetch的含义表示RabbitMQ服务器节点上最多的没有确认的消息个数. 这个参数设置为0时,表示不对消息个数进行限制, RabbitMQ服务器会投递尽可能多的消息到consumer，这里我设置成1

#yml配置
spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条，处理完成才能获取下一条
        acknowledge-mode: manual #一定改为要手动确认模式

报错

org.springframework.amqp.rabbit.support.ListenerExecutionFailedException: Listener method 'public void com.example.rabbitmq.consumer.PrefetchReceiver.myListener2(org.springframework.amqp.core.Message,com.rabbitmq.client.Channel) throws java.io.IOException,java.lang.InterruptedException' threw exception
	at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.invokeHandler(MessagingMessageListenerAdapter.java:271) ~[spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.invokeHandlerAndProcessResult(MessagingMessageListenerAdapter.java:208) ~[spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.onMessage(MessagingMessageListenerAdapter.java:147) ~[spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.doInvokeListener(AbstractMessageListenerContainer.java:1670) ~[spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.actualInvokeListener(AbstractMessageListenerContainer.java:1589) ~[spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.invokeListener(AbstractMessageListenerContainer.java:1577) ~[spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.doExecuteListener(AbstractMessageListenerContainer.java:1568) ~[spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer.executeListener(AbstractMessageListenerContainer.java:1512) ~[spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer.doReceiveAndExecute(SimpleMessageListenerContainer.java:993) [spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer.receiveAndExecute(SimpleMessageListenerContainer.java:940) [spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer.access$1600(SimpleMessageListenerContainer.java:84) [spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer$AsyncMessageProcessingConsumer.mainLoop(SimpleMessageListenerContainer.java:1317) [spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer$AsyncMessageProcessingConsumer.run(SimpleMessageListenerContainer.java:1223) [spring-rabbit-2.4.6.jar:2.4.6]
	at java.lang.Thread.run(Thread.java:748) [na:1.8.0_181]
Caused by: java.lang.IllegalStateException: Channel closed; cannot ack/nack
	at org.springframework.amqp.rabbit.connection.CachingConnectionFactory$CachedChannelInvocationHandler.invoke(CachingConnectionFactory.java:1153) ~[spring-rabbit-2.4.6.jar:2.4.6]
	at com.sun.proxy.$Proxy81.basicAck(Unknown Source) ~[na:na]
	at com.example.rabbitmq.consumer.PrefetchReceiver.myListener2(PrefetchReceiver.java:27) ~[classes/:na]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_181]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_181]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_181]
	at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_181]
	at org.springframework.messaging.handler.invocation.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:169) ~[spring-messaging-5.3.21.jar:5.3.21]
	at org.springframework.messaging.handler.invocation.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:119) ~[spring-messaging-5.3.21.jar:5.3.21]
	at org.springframework.amqp.rabbit.listener.adapter.HandlerAdapter.invoke(HandlerAdapter.java:75) ~[spring-rabbit-2.4.6.jar:2.4.6]
	at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.invokeHandler(MessagingMessageListenerAdapter.java:262) ~[spring-rabbit-2.4.6.jar:2.4.6]
	... 13 common frames omitted

代码-生产者

@Component
public class PrefetchSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void prefetch() {
        String exchange = "prefetch";
        String queue = "prefetch.queue";
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend(exchange, queue, "消息" + i);
        }
    }
}

// 测试类方法
@Test
    void prefetch() {
        prefetchSender.prefetch();
    }

代码-消费者

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class PrefetchReceiver {
    // 消费者1，快
    @RabbitListener(queuesToDeclare = @Queue("prefetch.queue"))  // queuesToDeclare 自动声明队列
    public void myListener1(Message message, Channel channel) throws IOException, InterruptedException {
        Thread.sleep(200);
        System.out.println("1收到的消息是：" + new String(message.getBody(), "utf-8"));
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
    }

    // 消费者2，慢
    @RabbitListener(queuesToDeclare = @Queue("prefetch.queue"))  // queuesToDeclare 自动声明队列
    public void myListener2(Message message, Channel channel) throws IOException, InterruptedException {
        Thread.sleep(1000);
        System.out.println("2收到的消息是：" + new String(message.getBody(), "utf-8"));
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
    }
}

思考

已经配置了手动确认（spring.rabbitmq.listener.simple.acknowledge-mode: manual），还有每次获取消息处理是1条，处理完消息才能拿下1条（spring.rabbitmq.listener.simple.prefetch: 1），为什么通道关闭，确认消息失败呢？

翻看一些帖子后，发现有些项目使用了消息转换json，我这个demo也使用了消息转json，目的是后台管理的界面可以看到发送的消息是json格式（未加密，但中文会乱码），但是消息接收的时候也需要进行json转换，需要在项目中加rabbitmq的配置类，连接工厂对象会在这个类里加工一下，所以发现问题所在了，配置类加工连接的时候漏了，需要我们"手动加上的"。

import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.listener.RabbitListenerContainerFactory;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {
    @Bean
    public RabbitListenerContainerFactory<?> rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setMessageConverter(new Jackson2JsonMessageConverter()); // json转消息
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL); // 手动确认（手动加上的）
        factory.setPrefetchCount(1); // 每次只能获取一条，处理完成才能获取下一条（手动加上的）
        return factory;
    }
}