Java spring amqp中的非批处理消息

我正在使用

BatchingRabbitTemplate

将消息批量发送到amqp端点。现在，在另一个接收端，我可以使用

@RabbitListener

来接收消息，但我的问题是消息会自动分批处理，因此我不能使用

@RabbitHandler public void receive（List so）

。除了我这样做之外，还有没有更简单的非批处理消息的方法：

@RabbitListener（…，containerFactory=“nonDeBatchingContainerFactory”）

然后实现这个后处理器（这或多或少是现有代码的副本，用于反批处理）

公共类NonDeBatchingMessagePostProcessor实现MessagePostProcessor{
私有消息转换器；
公共非DebatchingMessagePostProcessor（MessageConverter payloadConverter）{
this.payloadConverter=payloadConverter；
}
@凌驾
公共消息后处理消息（消息消息）引发AmqpException{
对象batchFormat=message.getMessageProperties（）.getHeaders（）.get（MessageProperties.SPRING\u BATCH\u格式）；
if（MessageProperties.BATCH\u FORMAT\u LENGTH\u HEADER4.equals（batchFormat））{
列表在生产应用程序级别进行批处理（发送
列表
）可能比使用批处理模板更容易一些。这样，您就不需要消费者方面的任何东西了。
在生产应用程序级别进行批处理（发送
列表
）而不是使用批处理模板。这样，您就根本不需要用户端的任何东西。
这不是批处理模板的默认行为吗？然后取决于方法签名（列表或单个对象）它可以确定处理程序的方法吗？不幸的是，分批处理的级别要低得多——监听器容器不知道它的代码> MasaGelistor < /C> > -我们可以考虑在容器中添加一个标志“不要拆卸”。然后在
MessagingMessageListenerAdapter
中添加与您类似的代码。欢迎随时打开。并随时提供：）这不是批处理模板的默认行为吗？然后取决于方法签名（列表或单个对象）它可以确定处理程序的方法吗？不幸的是，分批处理的级别要低得多——监听器容器不知道它的代码> MasaGelistor < /C> > -我们可以考虑在容器中添加一个标志“不要拆卸”。然后在
MessagingMessageListenerAdapter
中添加与您的代码类似的代码。请随时打开。并且随时欢迎您的贡献：）
@Bean
public RabbitListenerContainerFactory nonDeBatchingContainerFactory(){
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    factory.setConnectionFactory(connectionFactory());
    factory.setDeBatchingEnabled(false);
    factory.setMessageConverter(jackson2JsonMessageConverter());
    factory.setAfterReceivePostProcessors(new NonDeBatchingMessagePostProcessor(jackson2JsonMessageConverter()));
    return factory;
    }

public class NonDeBatchingMessagePostProcessor implements MessagePostProcessor {

    private MessageConverter payloadConverter;

    public NonDeBatchingMessagePostProcessor(MessageConverter payloadConverter) {
        this.payloadConverter = payloadConverter;
    }

    @Override
    public Message postProcessMessage(Message message) throws AmqpException {
        Object batchFormat = message.getMessageProperties().getHeaders().get(MessageProperties.SPRING_BATCH_FORMAT);
        if (MessageProperties.BATCH_FORMAT_LENGTH_HEADER4.equals(batchFormat)) {
            List<? super Object> aggregatedObjects = new ArrayList<>();
            ByteBuffer byteBuffer = ByteBuffer.wrap(message.getBody());
            MessageProperties messageProperties = message.getMessageProperties();
            String singleObjectTypeId = messageProperties.getHeaders().get(DEFAULT_CLASSID_FIELD_NAME).toString();
            messageProperties.getHeaders().remove(MessageProperties.SPRING_BATCH_FORMAT);
            while (byteBuffer.hasRemaining()) {
                int length = byteBuffer.getInt();
                if (length < 0 || length > byteBuffer.remaining()) {
                    throw new ListenerExecutionFailedException("Bad batched message received",
                            new MessageConversionException("Insufficient batch data at offset " + byteBuffer.position()),
                            message);
                }
                byte[] body = new byte[length];
                byteBuffer.get(body);
                messageProperties.setContentLength(length);
                // Caveat - shared MessageProperties.
                Message fragment = new Message(body, messageProperties);
                Object singleObject = this.payloadConverter.fromMessage(fragment);
                aggregatedObjects.add(singleObject);
            }
            Message aggregatedMessages = this.payloadConverter.toMessage(aggregatedObjects, messageProperties);
            aggregatedMessages.getMessageProperties().getHeaders().put(DEFAULT_CONTENT_CLASSID_FIELD_NAME, singleObjectTypeId);
            return aggregatedMessages;
        }
        return null;
    }
}