如何基于IBM MQ实现支持多消息类型的JMS监听器？

首先直接回应你的疑问：你不一定必须创建两个JMS监听器，但如果要优雅处理两种不同类型的消息，有多种可行方案——既可以复用同一个队列（通过消息选择器区分），也可以使用独立的队列通道。下面结合你的代码和场景详细说明：

为什么当前代码会崩溃？ #

你的自定义MappingJackson2MessageConverter被配置为将所有TextMessage尝试反序列化为MyMessage类型，当收到非JSON格式的纯String消息时，Jackson无法完成反序列化，会抛出MessageConversionException，进而导致监听器处理失败崩溃。

方案1：修改现有监听器，兼容两种消息类型 #

如果不想新增监听器或队列，可以调整监听器方法，直接接收原始Message对象，自行判断并处理不同类型的消息：

@Component
public class MyMessageListener {
    // 可以保留原转换器（如果仍需要发送POJO消息），或者移除它，自己处理接收逻辑
    @Bean
    public MessageConverter converter() {
        MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter() {
            @Override
            public Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
                TextMessage message = (TextMessage) super.toMessage(object, session);
                System.out.println("outgoing JSON: " + message.getText());
                return message;
            }
        };
        converter.setTargetType(MessageType.TEXT);
        converter.setTypeIdPropertyName("_type");
        return converter;
    }

    @JmsListener(destination = "${input.queue}")
    public void listener(Message message) throws JMSException {
        if (!(message instanceof TextMessage)) {
            System.out.println("Unsupported message type - only TextMessage is handled");
            return;
        }

        TextMessage textMessage = (TextMessage) message;
        String content = textMessage.getText();
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // 尝试反序列化为MyMessage
            MyMessage myMessage = objectMapper.readValue(content, MyMessage.class);
            System.out.println("Received POJO message: " + myMessage);
            // 这里添加POJO消息的业务处理逻辑
        } catch (JsonProcessingException e) {
            // 反序列化失败，当作纯String消息处理
            System.out.println("Received plain String message: " + content);
            // 这里添加纯String消息的业务处理逻辑
        }
    }
}

这种方式的好处是不需要调整队列结构，一个监听器就能处理两种消息，适合消息类型混杂且无法控制发送方的场景。

方案2：使用两个监听器，复用同一个队列（通过消息选择器） #

如果可以让消息发送方为不同类型的消息添加属性标记（比如messageType），你可以用消息选择器让两个监听器分别处理对应类型的消息，无需额外队列：

@Component
public class MyMessageListener {
    @Bean
    public MessageConverter converter() {
        MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter() {
            @Override
            public Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
                TextMessage message = (TextMessage) super.toMessage(object, session);
                // 发送POJO消息时添加属性标记
                message.setStringProperty("messageType", "JSON");
                System.out.println("outgoing JSON: " + message.getText());
                return message;
            }
        };
        converter.setTargetType(MessageType.TEXT);
        converter.setTypeIdPropertyName("_type");
        return converter;
    }

    // 处理JSON/POJO消息：只接收messageType为JSON的消息
    @JmsListener(destination = "${input.queue}", selector = "messageType = 'JSON'")
    public void pojoListener(MyMessage myMessage) {
        System.out.println("Received POJO message: " + myMessage);
        // 处理POJO逻辑
    }

    // 处理纯String消息：接收messageType为STRING或未设置属性的消息
    @JmsListener(destination = "${input.queue}", selector = "messageType = 'STRING' OR messageType IS NULL")
    public void stringListener(String message) {
        System.out.println("Received plain String message: " + message);
        // 处理纯String逻辑
    }
}

这种方式逻辑分离更清晰，各监听器专注处理自己的消息类型，性能也更优，适合能控制发送方消息属性的场景。

方案3：使用两个独立的队列通道 #

如果业务上希望完全隔离两种类型的消息，可以创建两个独立的IBM MQ队列，分别接收JSON/POJO消息和纯String消息，然后配置两个监听器：

@Component
public class MyMessageListener {
    @Bean
    public MessageConverter converter() {
        MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter() {
            @Override
            public Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
                TextMessage message = (TextMessage) super.toMessage(object, session);
                System.out.println("outgoing JSON: " + message.getText());
                return message;
            }
        };
        converter.setTargetType(MessageType.TEXT);
        converter.setTypeIdPropertyName("_type");
        return converter;
    }

    @JmsListener(destination = "${input.queue.json}")
    public void pojoListener(MyMessage myMessage) {
        System.out.println("Received POJO message: " + myMessage);
        // 处理POJO逻辑
    }

    @JmsListener(destination = "${input.queue.string}")
    public void stringListener(String message) {
        System.out.println("Received plain String message: " + message);
        // 处理纯String逻辑
    }
}

这种方式彻底避免了消息类型混淆，维护性最好，但需要调整发送方的目标队列配置，适合业务逻辑完全分离的场景。

总结 #

• 如果消息类型混杂且无法控制发送方：选择方案1
• 可以标记消息属性且希望逻辑分离：选择方案2
• 业务需要完全隔离消息：选择方案3

内容的提问来源于stack exchange，提问作者Peter the Cruel