Spring整合JMS（三）——MessageConverter介绍

小咪咪 2022-04-23 15:14 198阅读 0赞

# Spring整合JMS（三）——MessageConverter介绍 #

## ***1.4 消息转换器MessageConverter*** ##

*MessageConverter*的作用主要有两方面，一方面它可以把我们的非标准化*Message*对象转换成我们的目标*Message*对象，这主要是用在发送消息的时候；另一方面它又可以把我们的*Message*对象转换成对应的目标对象，这主要是用在接收消息的时候。

下面我们就拿发送一个对象消息来举例，假设我们有这样一个需求：我们平台有一个发送邮件的功能，进行发送的时候我们只是把我们的相关信息封装成一个*JMS*消息，然后利用*JMS*进行发送，在对应的消息监听器进行接收到的消息处理时才真正的进行消息发送。

假设我们有这么一个*Email*对象：

public class Email implements Serializable {
    
    
    private static final long serialVersionUID = -658250125732806493L;
    
    
    private String receiver;
    
    private String title;
    
    private String content;
    
    
    public Email(String receiver, String title, String content) {
    
    this.receiver = receiver;
    
    this.title = title;
    
    this.content = content;
    
    }
    
    
    public String getReceiver() {
    
    return receiver;
    
    }
    
    
    public void setReceiver(String receiver) {
    
    this.receiver = receiver;
    
    }
    
    
    public String getTitle() {
    
    return title;
    
    }
    
    
    public void setTitle(String title) {
    
    this.title = title;
    
    }
    
    
    public String getContent() {
    
    return content;
    
    }
    
    
    public void setContent(String content) {
    
    this.content = content;
    
    }
    
    
    @Override
    
    public String toString() {
    
    StringBuilder builder = new StringBuilder();
    
    builder.append("Email [receiver=").append(receiver).append(", title=")
    
    .append(title).append(", content=").append(content).append("]");
    
    return builder.toString();
    
    }
    
    
    }

这个*Email*对象包含了一个简单的接收者*email*地址、邮件主题和邮件内容。我们在发送的时候就把这个对象封装成一个*ObjectMessage*进行发送。代码如下所示：

public class ProducerServiceImpl implements ProducerService {
    
    
    @Autowired
    
    private JmsTemplate jmsTemplate;
    
    
    public void sendMessage(Destination destination, final Serializable obj) {
    
    jmsTemplate.send(destination, new MessageCreator() {
    
    
    public Message createMessage(Session session) throws JMSException {
    
    ObjectMessage objMessage = session.createObjectMessage(obj);
    
    return objMessage;
    
    }
    
    
    });
    
    }
    
    
    }

这是对应的在没有使用MessageConverter的时候我们需要new一个MessageCreator接口对象，然后在其抽象方法createMessage内部使用session创建一个对应的消息。在使用了MessageConverter的时候我们在使用JmsTemplate进行消息发送时只需要调用其对应的convertAndSend方法即可。如：

public void sendMessage(Destination destination, final Serializable obj) {
    
    //未使用MessageConverter的情况
    
    /*jmsTemplate.send(destination, new MessageCreator() {
    
    
    public Message createMessage(Session session) throws JMSException {
    
    ObjectMessage objMessage = session.createObjectMessage(obj);
    
    return objMessage;
    
    }
    
    
    });*/
    
    //使用MessageConverter的情况
    
    jmsTemplate.convertAndSend(destination, obj);
    
    }

这样*JmsTemplate*就会在其内部调用预定的*MessageConverter*对我们的消息对象进行转换，然后再进行发送。

这个时候我们就需要定义我们的*MessageConverter*了。要定义自己的*MessageConverter*很简单，只需要实现*Spring*为我们提供的*MessageConverter*接口即可。我们先来看一下*MessageConverter*接口的定义：

public interface MessageConverter {
    
    
    Message toMessage(Object object, Session session) throws JMSException, MessageConversionException;
    
    
    Object fromMessage(Message message) throws JMSException, MessageConversionException;
    
    
    }

我们可以看到其中一共定义了两个方法*fromMessage*和*toMessage*，*fromMessage*是用来把一个*JMS Message*转换成对应的*Java*对象，而*toMessage*方法是用来把一个*Java*对象转换成对应的*JMS Message*。因为我们已经知道上面要发送的对象就是一个*Email*对象，所以在这里我们就简单地定义一个*EmailMessageConverter*用来把*Email*对象和对应的*ObjectMessage*进行转换，其代码如下：

import javax.jms.JMSException;
    
    import javax.jms.Message;
    
    import javax.jms.ObjectMessage;
    
    import javax.jms.Session;
    
    
    import org.springframework.jms.support.converter.MessageConversionException;
    
    import org.springframework.jms.support.converter.MessageConverter;
    
    
    public class EmailMessageConverter implements MessageConverter {
    
    
    public Message toMessage(Object object, Session session)
    
    throws JMSException, MessageConversionException {
    
    return session.createObjectMessage((Serializable) object);
    
    }
    
    
    public Object fromMessage(Message message) throws JMSException,
    
    MessageConversionException {
    
    ObjectMessage objMessage = (ObjectMessage) message;
    
    return objMessage.getObject();
    
    }
    
    
    }

这样当我们利用*JmsTemplate*的*convertAndSend*方法发送一个*Email*对象的时候就会把对应的*Email*对象当做参数调用我们定义好的*EmailMessageConverter*的*toMessage*方法。

定义好我们的*EmailMessageConverter*之后就需要指定我们用来发送*Email*对象的*JmsTemplate*对象的*messageConverter*为*EmailMessageConverter*，这里我们在*Spring*的配置文件中定义*JmsTemplate bean*的时候就指定：

<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
            
            <property name="connectionFactory" ref="connectionFactory"/>
            
            <property name="messageConverter" ref="emailMessageConverter"/>
        </bean>
        
        <bean id="emailMessageConverter" class="com.tiantian.springintejms.converter.EmailMessageConverter"/>

到此我们的*MessageConverter*就定义好了，也能够进行使用了，接着我们来进行测试一下，定义测试代码如下所示：

@Test
    
    public void testObjectMessage() {
    
    Email email = new Email("zhangsan@xxx.com", "主题", "内容");
    
    producerService.sendMessage(destination, email);
    
    }

上面*destination*对应的接收处理的*MessageListener*方法如下所示：

public class ConsumerMessageListener implements MessageListener {
    
    
    public void onMessage(Message message) {
    
    
    if (message instanceof ObjectMessage) {
    
    ObjectMessage objMessage = (ObjectMessage) message;
    
    try {
    
    Object obj = objMessage.getObject();
    
    Email email = (Email) obj;
    
    System.out.println("接收到一个ObjectMessage，包含Email对象。");
    
    System.out.println(email);
    
    } catch (JMSException e) {
    
    e.printStackTrace();
    
    }
    
    }
    
    }
    
    
    }

之前说了*MessageConverter*有两方面的功能，除了把*Java*对象转换成对应的*Jms Message*之外还可以把*Jms Message*转换成对应的*Java*对象。我们看上面的消息监听器在接收消息的时候接收到的就是一个*Jms Message*，如果我们要利用*MessageConverter*来把它转换成对应的*Java*对象的话，只能是我们往里面注入一个对应的*MessageConverter*，然后在里面手动的调用，如：

public class ConsumerMessageListener implements MessageListener {
    
    
    private MessageConverter messageConverter;
    
    
    public void onMessage(Message message) {
    
    
    if (message instanceof ObjectMessage) {
    
    ObjectMessage objMessage = (ObjectMessage) message;
    
    try {
    
    /*Object obj = objMessage.getObject();
    
    Email email = (Email) obj;*/
    
    Email email = (Email) messageConverter.fromMessage(objMessage);
    
    System.out.println("接收到一个ObjectMessage，包含Email对象。");
    
    System.out.println(email);
    
    } catch (JMSException e) {
    
    e.printStackTrace();
    
    }
    
    
    }
    
    }
    
    
    public MessageConverter getMessageConverter() {
    
    return messageConverter;
    
    }
    
    
    public void setMessageConverter(MessageConverter messageConverter) {
    
    this.messageConverter = messageConverter;
    
    }
    
    
    }

当我们使用*MessageListenerAdapter*来作为消息监听器的时候，我们可以为它指定一个对应的*MessageConverter*，这样*Spring*在处理接收到的消息的时候就会自动地利用我们指定的*MessageConverter*对它进行转换，然后把转换后的*Java*对象作为参数调用指定的消息处理方法。这里我们再把前面讲解*MessageListenerAdapter*时定义的*MessageListenerAdapter*拿来做一个测试，我们指定它的*MessageConverter*为我们定义好的*EmailMessageConverter*。

<bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
            <property name="delegate">
                <bean class="com.tiantian.springintejms.listener.ConsumerListener"/>
            </property>
            <property name="defaultListenerMethod" value="receiveMessage"/>
            <property name="messageConverter" ref="emailMessageConverter"/>
        </bean>
        
        <bean id="messageListenerAdapterContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
            <property name="connectionFactory" ref="connectionFactory"/>
            <property name="destination" ref="adapterQueue"/>
            <property name="messageListener" ref="messageListenerAdapter"/>
        </bean>

然后在我们的真正用于处理接收到的消息的*ConsumerListener*中添加一个*receiveMessage*方法，添加后其代码如下所示：

public class ConsumerListener {
    
    
    public void receiveMessage(String message) {
    
    System.out.println("ConsumerListener通过receiveMessage接收到一个纯文本消息，消息内容是：" + message);
    
    }
    
    
    public void receiveMessage(Email email) {
    
    System.out.println("接收到一个包含Email的ObjectMessage。");
    
    System.out.println(email);
    
    }
    
    
    }

然后我们定义如下测试代码：

@Test
    
    public void testObjectMessage() {
    
    Email email = new Email("zhangsan@xxx.com", "主题", "内容");
    
    producerService.sendMessage(adapterQueue, email);
    
    }

因为我们给*MessageListenerAdapter*指定了一个*MessageConverter*，而且是一个*EmailMessageConverter*，所以当*MessageListenerAdapter*接收到一个消息后，它会调用我们指定的*MessageConverter*的*fromMessage*方法把它转换成一个*Java*对象，根据定义这里会转换成一个*Email*对象，然后会把这个*Email*对象作为参数调用我们通过*defaultListenerMethod*属性指定的默认处理器方法，根据定义这里就是*receiveMessage*方法，但是我们可以看到在*ConsumerListener*中我们一共定义了两个*receiveMessage*方法，因为是通过转换后的*Email*对象作为参数进行方法调用的，所以这里调用的就应该是参数类型为*Email*的*receiveMessage*方法了。上述测试代码运行后会输出如下结果：  
*![ee3a2dc6-82ce-3d4c-a7a5-30f5adca1499.png][]*  
说到这里可能有读者就会有疑问了，说我们在之前讲解*MessageListenerAdapter*的时候不是没有指定对应的*MessageConverter*，然后发送了一个*TextMessage*，结果*Spring*还是把它转换成一个*String*对象，调用了*ConsumerListener*参数类型为*String*的*receiveMessage*方法吗？那你这个*MessageConverter*在*MessageListenerAdapter*进行消息接收的时候也没什么用啊。

其实还是有用的，在我们使用*MessageListenerAdapter*时，在对其进行初始化也就是调用其构造方法时，它会默认*new*一个*Spring*已经为我们实现了的*MessageConverter*——*SimpleMessageConverter*作为其默认的*MessageConverter*，这也就是为什么我们在使用*MessageListenerAdapter*的时候不需要指定*MessageConverter*但是消息还是会转换成对应的*Java*对象的原因。所以默认情况下我们使用*MessageListenerAdapter*时其对应的*MessageListener*的处理器方法参数类型必须是一个普通*Java*对象，而不能是对应的*Jms Message*对象。

那如果我们在处理*Jms Message*的时候想使用*MessageListenerAdapter*，然后又希望处理最原始的*Message*，而不是经过*MessageConverter*进行转换后的*Message*该怎么办呢？这个时候我们只需要在定义*MessageListenerAdapter*的时候指定其*MessageConverter*为空就可以了。

那么这个时候我们的真实*MessageListener*的处理器方法参数类型就应该是*Jms Message*或对应的*Jms Message*子类型了，不然就会调用不到对应的处理方法了。这里因为我们发送的是一个*ObjectMessage*，所以这里就添加一个对应的参数类型为*ObjectMessage*的*receiveMessage*方法了。

public void receiveMessage(ObjectMessage message) throws JMSException {
    
    System.out.println(message.getObject());
    
    }

刚刚讲到*Spring*已经为我们实现了一个简单的*MessageConverter*，即*org.springframework.jms.support.converter.SimpleMessageConverter*，其实*Spring*在初始化*JmsTemplate*的时候也指定了其对应的*MessageConverter*为一个*SimpleMessageConverter*，所以如果我们平常没有什么特殊要求的时候可以直接使用*JmsTemplate*的*convertAndSend*系列方法进行消息发送，而不必繁琐的在调用*send*方法时自己*new*一个*MessageCreator*进行相应*Message*的创建。

这里我们也来看一下*SimpleMessageConverter*的定义，如果觉得它不能满足你的要求，那我们可以对它里面的部分方法进行重写，或者是完全实现自己的*MessageConverter*。

public class SimpleMessageConverter implements MessageConverter {
    
    
    public Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
    
    if (object instanceof Message) {
    
    return (Message) object;
    
    }
    
    else if (object instanceof String) {
    
    return createMessageForString((String) object, session);
    
    }
    
    else if (object instanceof byte[]) {
    
    return createMessageForByteArray((byte[]) object, session);
    
    }
    
    else if (object instanceof Map) {
    
    return createMessageForMap((Map) object, session);
    
    }
    
    else if (object instanceof Serializable) {
    
    return createMessageForSerializable(((Serializable) object), session);
    
    }
    
    
    else {
    
    throw new MessageConversionException("Cannot convert object of type [" +
    
    ObjectUtils.nullSafeClassName(object) + "] to JMS message. Supported message " +
    
    "payloads are: String, byte array, Map<String,?>, Serializable object.");
    
    }
    
    }
    
    
    public Object fromMessage(Message message) throws JMSException, MessageConversionException {
    
    if (message instanceof TextMessage) {
    
    return extractStringFromMessage((TextMessage) message);
    
    }
    
    else if (message instanceof BytesMessage) {
    
    return extractByteArrayFromMessage((BytesMessage) message);
    
    }
    
    else if (message instanceof MapMessage) {
    
    return extractMapFromMessage((MapMessage) message);
    
    }
    
    else if (message instanceof ObjectMessage) {
    
    return extractSerializableFromMessage((ObjectMessage) message);
    
    }
    
    else {
    
    return message;
    
    }
    
    }
    
    
    protected TextMessage createMessageForString(String text, Session session) throws JMSException {
    
    return session.createTextMessage(text);
    
    }
    
    
    protected BytesMessage createMessageForByteArray(byte[] bytes, Session session) throws JMSException {
    
    BytesMessage message = session.createBytesMessage();
    
    message.writeBytes(bytes);
    
    return message;
    
    }
    
    
    protected MapMessage createMessageForMap(Map<?, ?> map, Session session) throws JMSException {
    
    MapMessage message = session.createMapMessage();
    
    for (Map.Entry entry : map.entrySet()) {
    
    if (!(entry.getKey() instanceof String)) {
    
    throw new MessageConversionException("Cannot convert non-String key of type [" +
    
    ObjectUtils.nullSafeClassName(entry.getKey()) + "] to JMS MapMessage entry");
    
    }
    
    message.setObject((String) entry.getKey(), entry.getValue());
    
    }
    
    return message;
    
    }
    
    
    protected ObjectMessage createMessageForSerializable(Serializable object, Session session) throws JMSException {
    
    return session.createObjectMessage(object);
    
    }
    
    
    
    protected String extractStringFromMessage(TextMessage message) throws JMSException {
    
    return message.getText();
    
    }
    
    
    protected byte[] extractByteArrayFromMessage(BytesMessage message) throws JMSException {
    
    byte[] bytes = new byte[(int) message.getBodyLength()];
    
    message.readBytes(bytes);
    
    return bytes;
    
    }
    
    
    protected Map extractMapFromMessage(MapMessage message) throws JMSException {
    
    Map<String, Object> map = new HashMap<String, Object>();
    
    Enumeration en = message.getMapNames();
    
    while (en.hasMoreElements()) {
    
    String key = (String) en.nextElement();
    
    map.put(key, message.getObject(key));
    
    }
    
    return map;
    
    }
    
    
    protected Serializable extractSerializableFromMessage(ObjectMessage message) throws JMSException {
    
    return message.getObject();
    
    }
    
    
    }

[ee3a2dc6-82ce-3d4c-a7a5-30f5adca1499.png]: /images/20220226/fd4146872e2940bbb0ec789e033413d6.png