有没有办法用Spring Boot为队列动态设置prefetchSize？

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {

    @Bean
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        // 设置prefetchCount
        factory.setPrefetchCount(10); // 可以根据需要动态设置
        return factory;
    }
}

@Autowired
private SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory;

public void updatePrefetchCount(int newPrefetchCount) {
    SimpleRabbitListenerContainer container = (SimpleRabbitListenerContainer) rabbitListenerContainerFactory.getObject();
    if (container != null) {
        container.setPrefetchCount(newPrefetchCount);
    }
}

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;

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

@Configuration
@EnableKafka
public class KafkaConfig {

    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory =
                new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        // 设置max.poll.records
        factory.getContainerProperties().setPollTimeout(3000);
        return factory;
    }

    @Bean
    public ConsumerFactory<String, String> consumerFactory() {
        return new DefaultKafkaConsumerFactory<>(consumerConfigs());
    }

    @Bean
    public Map<String, Object> consumerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "group-id");
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 50); // 可以根据需要动态设置
        return props;
    }
}

@Autowired
private ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory;

public void updateMaxPollRecords(int newMaxPollRecords) {
    Map<String, Object> consumerConfigs = new HashMap<>(kafkaListenerContainerFactory.getConsumerFactory().getConfiguration());
    consumerConfigs.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, newMaxPollRecords);
    ConsumerFactory<String, String> newConsumerFactory = new DefaultKafkaConsumerFactory<>(consumerConfigs);
    kafkaListenerContainerFactory.setConsumerFactory(newConsumerFactory);
}