如何让@RabbitListener配合自定义MessageConverter接收任意类型的@Payload Object参数

问题背景 #

我正在从IBM MQ迁移到RabbitMQ，之前在JMS里可以这样接收消息：

@JmsListener(destination = "${jms.topic}")
public void receiveMessage(@NonNull Message<Object> message) {
    Object payload = message.getPayload();     
    processByType(payload); 
}  

我希望在RabbitMQ里实现类似的逻辑，用自定义的myMessageConverter根据__TypeId__头自动转换消息到对应对象，然后直接接收@Payload Object参数：

@RabbitListener(queues = "${queue-name}", messageConverter = "myMessageConverter")
public void receiveMessage(@Payload Object payload) { 
    // 复用现有逻辑
    processByType(payload);
}

但实际运行时，这个方法收到的是Message对象本身，而不是转换后的payload。我知道如果指定具体的类型（比如MyPayload）或者公共父接口（比如MyInboundPayload）是可以正常工作的，但问题是有一半的payload类型是外部服务的库类，我无法让它们实现自定义接口。

我的当前MessageConverter配置如下：

@Bean
public MessageConverter myMessageConverter() {
    ObjectMapper objectMapper = new ObjectMapper()
            .registerModule(new JavaTimeModule())
            .registerModule(new ParanamerModule())
            .registerModule(new SingleArgConstructorModule("com.xyz.api"))
            .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    return new Jackson2JsonMessageConverter(objectMapper);
}

我不想手动处理Message对象再转换，想知道有没有办法借助@RabbitListener的能力直接实现需求？

解决方案 #

嗨，我来帮你搞定这个问题！其实核心问题是Spring AMQP默认对@Payload Object参数的处理逻辑是传递整个Message对象，而不是调用转换器后的payload。这里有几个可行的方案：

方案1：自定义参数解析器（最推荐）

我们可以写一个自定义的HandlerMethodArgumentResolver，专门拦截@Payload Object类型的参数，强制调用你的myMessageConverter来转换消息体：

首先创建解析器类：

@Component
public class ObjectPayloadArgumentResolver implements HandlerMethodArgumentResolver {

    private final MessageConverter messageConverter;

    // 注入你自定义的MessageConverter
    public ObjectPayloadArgumentResolver(MessageConverter messageConverter) {
        this.messageConverter = messageConverter;
    }

    // 判断是否处理当前参数：带有@Payload注解且类型是Object
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(Payload.class) 
                && parameter.getParameterType() == Object.class;
    }

    // 执行转换逻辑，调用转换器获取payload
    @Override
    public Object resolveArgument(MethodParameter parameter, Message<?> message,
                                  BindingContext bindingContext) throws Exception {
        // 把Spring Messaging的Message转换成Spring AMQP的Message，再调用转换器
        org.springframework.amqp.core.Message amqpMessage = 
                (org.springframework.amqp.core.Message) message.getPayload();
        return messageConverter.fromMessage(amqpMessage);
    }
}

然后在RabbitMQ配置类里注册这个解析器：

@Configuration
public class RabbitConfig implements RabbitListenerConfigurer {

    private final ObjectPayloadArgumentResolver argumentResolver;

    public RabbitConfig(ObjectPayloadArgumentResolver argumentResolver) {
        this.argumentResolver = argumentResolver;
    }

    @Override
    public void configureRabbitListeners(RabbitListenerEndpointRegistrar registrar) {
        // 给消息处理方法工厂添加自定义解析器
        registrar.getMessageHandlerMethodFactory().addArgumentResolver(argumentResolver);
    }

    // 你的myMessageConverter Bean保持不变，补充类型头配置
    @Bean
    public MessageConverter myMessageConverter() {
        ObjectMapper objectMapper = new ObjectMapper()
                .registerModule(new JavaTimeModule())
                .registerModule(new ParanamerModule())
                .registerModule(new SingleArgConstructorModule("com.xyz.api"))
                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        Jackson2JsonMessageConverter converter = new Jackson2JsonMessageConverter(objectMapper);
        // 确保开启类型头处理（默认已开启，显式声明更稳妥）
        converter.setTypeIdHeaderEnabled(true);
        // 如果__TypeId__里的类型名不是全类名，添加映射（比如第三方类）
        // converter.setTypeIdMapping("ThirdPartyType", com.other.service.ThirdPartyType.class);
        return converter;
    }
}

这样配置后，你的@Payload Object参数就能正确收到转换后的对象了，完全复用你现有的processByType逻辑。

方案2：简化版（手动调用转换器）

如果觉得自定义解析器有点复杂，也可以直接在方法里接收Spring AMQP的Message对象，然后手动调用转换器，代码其实也很简洁：

@RabbitListener(queues = "${queue-name}")
public void receiveMessage(org.springframework.amqp.core.Message message) { 
    Object payload = myMessageConverter.fromMessage(message);
    processByType(payload);
}

虽然你说不想手动处理，但这个方式不需要额外配置，实现成本很低，也能达到目的。

关键配置注意点

• 确保你的Jackson2JsonMessageConverter开启了TypeIdHeaderEnabled（默认是true），这样它会读取__TypeId__头来确定反序列化的类型。
• 如果第三方类的__TypeId__头不是全类名，一定要用setTypeIdMapping把类型名映射到对应的类，否则Jackson无法找到目标类进行反序列化。

备注：内容来源于stack exchange，提问作者PavloK