Spring学习总结（11）——Spring JMS MessageConverter介绍

Posted 2020-07-07 科技D人生

消息转换器MessageConverter

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

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

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

 

Java代码  

1. public class Email implements Serializable {  
2.    
3.     private static final long serialVersionUID = -658250125732806493L;  
4.    
5.     private String receiver;  
6.     private String title;  
7.     private String content;  
8.    
9.     public Email(String receiver, String title, String content) {  
10.         this.receiver = receiver;  
11.         this.title = title;  
12.         this.content = content;  
13.     }  
14.    
15.     public String getReceiver() {  
16.         return receiver;  
17.     }  
18.    
19.     public void setReceiver(String receiver) {  
20.         this.receiver = receiver;  
21.     }  
22.    
23.     public String getTitle() {  
24.         return title;  
25.     }  
26.    
27.     public void setTitle(String title) {  
28.         this.title = title;  
29.     }  
30.    
31.     public String getContent() {  
32.         return content;  
33.     }  
34.    
35.     public void setContent(String content) {  
36.         this.content = content;  
37.     }  
38.    
39.     @Override  
40.     public String toString() {  
41.         StringBuilder builder = new StringBuilder();  
42.         builder.append("Email [receiver=").append(receiver).append(", title=")  
43.                 .append(title).append(", content=").append(content).append("]");  
44.         return builder.toString();  
45.     }  
46.       
47. }  

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

Java代码  

1. public class ProducerServiceImpl implements ProducerService {  
2.    
3.     @Autowired  
4.     private JmsTemplate jmsTemplate;      
5.   
6.     public void sendMessage(Destination destination, final Serializable obj) {  
7.         jmsTemplate.send(destination, new MessageCreator() {  
8.    
9.             public Message createMessage(Session session) throws JMSException {  
10.                 ObjectMessage objMessage = session.createObjectMessage(obj);  
11.                 return objMessage;  
12.             }  
13.               
14.         });  
15.     }  
16.    
17. }  

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

 

Java代码  

1. public void sendMessage(Destination destination, final Serializable obj) {  
2.     //未使用MessageConverter的情况  
3.     /*jmsTemplate.send(destination, new MessageCreator() { 
4.  
5.         public Message createMessage(Session session) throws JMSException { 
6.             ObjectMessage objMessage = session.createObjectMessage(obj); 
7.             return objMessage; 
8.         } 
9.          
10.     });*/  
11.     //使用MessageConverter的情况  
12.     jmsTemplate.convertAndSend(destination, obj);  
13. }  

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

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

Java代码  

1. public interface MessageConverter {  
2.    
3.     Message toMessage(Object object, Session session) throws JMSException, MessageConversionException;  
4.    
5.     Object fromMessage(Message message) throws JMSException, MessageConversionException;  
6.    
7. }  

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

 

Java代码  

1. import javax.jms.JMSException;  
2. import javax.jms.Message;  
3. import javax.jms.ObjectMessage;  
4. import javax.jms.Session;  
5.    
6. import org.springframework.jms.support.converter.MessageConversionException;  
7. import org.springframework.jms.support.converter.MessageConverter;  
8.    
9. public class EmailMessageConverter implements MessageConverter {  
10.    
11.     public Message toMessage(Object object, Session session)  
12.             throws JMSException, MessageConversionException {  
13.         return session.createObjectMessage((Serializable) object);  
14.     }  
15.    
16.     public Object fromMessage(Message message) throws JMSException,  
17.             MessageConversionException {  
18.         ObjectMessage objMessage = (ObjectMessage) message;  
19.         return objMessage.getObject();  
20.     }  
21.    
22. }  

 

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

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

 

Xml代码  

1. <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->  
2. <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
3.     <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
4.     <property name="connectionFactory" ref="connectionFactory"/>  
5.     <!-- 消息转换器 -->  
6.     <property name="messageConverter" ref="emailMessageConverter"/>  
7. </bean>  
8. <!-- 类型转换器 -->  
9. <bean id="emailMessageConverter" class="com.tiantian.springintejms.converter.EmailMessageConverter"/>  

    

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

 

Java代码  

1. @Test  
2. public void testObjectMessage() {  
3.     Email email = new Email("[email protected]", "主题", "内容");  
4.     producerService.sendMessage(destination, email);  
5. }  

 

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

 

Java代码  

1. public class ConsumerMessageListener implements MessageListener {  
2.    
3.     public void onMessage(Message message) {  
4.           
5.         if (message instanceof ObjectMessage) {  
6.             ObjectMessage objMessage = (ObjectMessage) message;  
7.             try {  
8.                 Object obj = objMessage.getObject();  
9.                 Email email = (Email) obj;  
10.                 System.out.println("接收到一个ObjectMessage，包含Email对象。");  
11.                 System.out.println(email);  
12.             } catch (JMSException e) {  
13.                 e.printStackTrace();  
14.             }  
15.         }  
16.     }  
17.    
18. }  

 

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

 

Java代码  

1. public class ConsumerMessageListener implements MessageListener {  
2.    
3.     private MessageConverter messageConverter;  
4.       
5.     public void onMessage(Message message) {  
6.           
7.         if (message instanceof ObjectMessage) {  
8.             ObjectMessage objMessage = (ObjectMessage) message;  
9.             try {  
10.                 /*Object obj = objMessage.getObject(); 
11.                 Email email = (Email) obj;*/  
12.                 Email email = (Email) messageConverter.fromMessage(objMessage);  
13.                 System.out.println("接收到一个ObjectMessage，包含Email对象。");  
14.                 System.out.println(email);  
15.             } catch (JMSException e) {  
16.                 e.printStackTrace();  
17.             }  
18.               
19.         }  
20.     }  
21.    
22.     public MessageConverter getMessageConverter() {  
23.         return messageConverter;  
24.     }  
25.    
26.     public void setMessageConverter(MessageConverter messageConverter) {  
27.         this.messageConverter = messageConverter;  
28.     }  
29.    
30. }  

 

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

 

Xml代码  

1. <!-- 消息监听适配器 -->  
2. <bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
3.     <property name="delegate">  
4.         <bean class="com.tiantian.springintejms.listener.ConsumerListener"/>  
5.     </property>  
6.     <property name="defaultListenerMethod" value="receiveMessage"/>  
7.     <property name="messageConverter" ref="emailMessageConverter"/>  
8. </bean>  
9. <!-- 消息监听适配器对应的监听容器 -->  
10. <bean id="messageListenerAdapterContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
11.     <property name="connectionFactory" ref="connectionFactory"/>  
12.     <property name="destination" ref="adapterQueue"/>  
13.     <property name="messageListener" ref="messageListenerAdapter"/><!-- 使用MessageListenerAdapter来作为消息监听器 -->  
14. </bean>  

 

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

 

Java代码  

1. public class ConsumerListener {  
2.    
3.     public void receiveMessage(String message) {  
4.         System.out.println("ConsumerListener通过receiveMessage接收到一个纯文本消息，消息内容是：" + message);  
5.     }  
6.       
7.     public void receiveMessage(Email email) {  
8.         System.out.println("接收到一个包含Email的ObjectMessage。");  
9.         System.out.println(email);  
10.     }  
11.       
12. }  

 

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

 

Java代码  

1. @Test  
2. public void testObjectMessage() {  
3.     Email email = new Email("[email protected]", "主题", "内容");  
4.     producerService.sendMessage(adapterQueue, email);  
5. }  

 

       因为我们给MessageListenerAdapter指定了一个MessageConverter，而且是一个EmailMessageConverter，所以当MessageListenerAdapter接收到一个消息后，它会调用我们指定的MessageConverter的fromMessage方法把它转换成一个Java对象，根据定义这里会转换成一个Email对象，然后会把这个Email对象作为参数调用我们通过defaultListenerMethod属性指定的默认处理器方法，根据定义这里就是receiveMessage方法，但是我们可以看到在ConsumerListener中我们一共定义了两个receiveMessage方法，因为是通过转换后的Email对象作为参数进行方法调用的，所以这里调用的就应该是参数类型为Email的receiveMessage方法了。上述测试代码运行后会输出如下结果：