[TOC] # MessageConverter詳解 ~~~ org.springframework.amqp.support.converter.MessageConverter ~~~ ~~~ Message toMessage(Object object, MessageProperties messageProperties); 將java對象和屬性對象轉換成Message對象。 Object fromMessage(Message message) throws MessageConversionException; 將消息對象轉換成java對象。 ~~~ ## Demo **定義Config類** ~~~java import org.springframework.amqp.rabbit.connection.CachingConnectionFactory; import org.springframework.amqp.rabbit.connection.ConnectionFactory; import org.springframework.amqp.rabbit.core.RabbitAdmin; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer; import org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class MQConfig { @Bean public ConnectionFactory connectionFactory(){ CachingConnectionFactory factory = new CachingConnectionFactory(); factory.setUri("amqp://zhihao.miao:123456@192.168.1.131:5672"); return factory; } @Bean public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory){ RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory); return rabbitAdmin; } @Bean public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){ RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory); return rabbitTemplate; } @Bean public SimpleMessageListenerContainer messageListenerContainer(ConnectionFactory connectionFactory){ SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(); container.setConnectionFactory(connectionFactory); container.setQueueNames("zhihao.miao.order"); MessageListenerAdapter adapter = new MessageListenerAdapter(new MessageHandler()); //指定消息轉換器 adapter.setMessageConverter(new TestMessageConverter()); //設置處理器的消費消息的默認方法 adapter.setDefaultListenerMethod("onMessage"); container.setMessageListener(adapter); return container; } } ~~~ MessageListenerAdapter中定義的消息轉換器，消費端接收的消息就從Message類型轉換成了String類型 ~~~java import org.springframework.amqp.core.Message; import org.springframework.amqp.core.MessageProperties; import org.springframework.amqp.support.converter.MessageConversionException; import org.springframework.amqp.support.converter.MessageConverter; public class TestMessageConverter implements MessageConverter { @Override public Message toMessage(Object object, MessageProperties messageProperties) throws MessageConversionException { System.out.println("=======toMessage========="); return new Message(object.toString().getBytes(),messageProperties); } //消息類型轉換器中fromMessage方法返回的類型就是消費端處理器接收的類型 @Override public Object fromMessage(Message message) throws MessageConversionException { System.out.println("=======fromMessage========="); return new String(message.getBody()); } } ~~~ **消費者處理消息的Handler** ~~~csharp public class MessageHandler { public void onMessage(String message){ System.out.println("---------onMessage-------------"); System.out.println(message); } } ~~~ **啟動類** ~~~java import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.ComponentScan; import java.util.concurrent.TimeUnit; /** * MessageConverter可以把java對象轉換成Message對象，也可以把Message對象轉換成java對象 * * MessageListenerAdapter內部通過MessageConverter把Message轉換成java對象，然后找到相應的處理方法，參數為轉換成的java對象 */ @ComponentScan public class Application { public static void main(String[] args) throws Exception{ AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class); System.out.println("===start up======"); TimeUnit.SECONDS.sleep(30); context.close(); } } ~~~ 啟動應用類，發送消息到`zhihao.miao.order`隊列,控制臺打印： ~~~ ===start up====== =======fromMessage========= ---------onMessage------------- String類型的消息 ~~~ 從控制臺打印我們知道了在消費者處理消息之前會進行消息類型轉換，調用`TestMessageConverter`的`fromMessage`方法，然后執行消息處理器的`onMessage`方法，方法參數就是`String`類型。 ### 擴展 自定義一個MyBody類型，將消息從Message轉換成MyBody類型 ~~~java public class MyBody { private byte[] bodys; public MyBody(byte[] bodys){ this.bodys = bodys; } @Override public String toString() { return new String(bodys); } } ~~~ 然后修改`TestMessageConverter`的`fromMessage`方法，返回了`MyBody`類型，那么消息處理器的消費方法也是MyBody參數的消費方法 ~~~java import org.springframework.amqp.core.Message; import org.springframework.amqp.core.MessageProperties; import org.springframework.amqp.support.converter.MessageConversionException; import org.springframework.amqp.support.converter.MessageConverter; public class TestMessageConverter implements MessageConverter { @Override public Message toMessage(Object object, MessageProperties messageProperties) throws MessageConversionException { System.out.println("=======toMessage========="); return new Message(object.toString().getBytes(),messageProperties); } //消息類型轉換器中fromMessage方法返回的類型就是消費端處理器接收的類型 @Override public Object fromMessage(Message message) throws MessageConversionException { System.out.println("=======fromMessage========="); return new MyBody(message.getBody()); } } ~~~ 此時的消息處理器，處理器中的方法的入參就是MyBody類型了， ~~~ public class MessageHandler { public void onMessage(MyBody message){ System.out.println("---------onMessage---MyBody-------------"); System.out.println(message); } } ~~~ 此時控制臺打印： ~~~ ===start up====== =======fromMessage========= ---------onMessage---MyBody------------- Mybody類型的消息 ~~~ ## 小結 我們還測試如下如果不使用自定義的`Converter`，那么當消息的屬性中含有屬性content\_type的值為text，那么默認的轉換成的java類型就是String類型，如果不指定那么默認的轉換類型就是byte\[\] ## 源碼分析 我們跟進去`MessageListenerAdapte`r的`setMessageConverter`方法， ~~~ /** * Set the converter that will convert incoming Rabbit messages to listener method arguments, and objects returned * from listener methods back to Rabbit messages. * <p> * The default converter is a {@link SimpleMessageConverter}, which is able to handle "text" content-types. * @param messageConverter The message converter. */ public void setMessageConverter(MessageConverter messageConverter) { this.messageConverter = messageConverter; } ~~~ ~~~ private MessageConverter messageConverter = new SimpleMessageConverter(); ~~~ 我們發現默認的`MessageConverter`是`SimpleMessageConverter`，我們進入`SimpleMessageConverter`類中看其默認的轉換邏輯 ~~~ @Override public Object fromMessage(Message message) throws MessageConversionException { Object content = null; MessageProperties properties = message.getMessageProperties(); if (properties != null) { String contentType = properties.getContentType(); //contentType屬性值是以text開頭，那么就將Message類型轉換成String類型 if (contentType != null && contentType.startsWith("text")) { String encoding = properties.getContentEncoding(); if (encoding == null) { encoding = this.defaultCharset; } try { content = new String(message.getBody(), encoding); } catch (UnsupportedEncodingException e) { throw new MessageConversionException( "failed to convert text-based Message content", e); } } //如果content_type的值是application/x-java-serialized-object則把消息序列化為java對象 else if (contentType != null && contentType.equals(MessageProperties.CONTENT_TYPE_SERIALIZED_OBJECT)) { try { content = SerializationUtils.deserialize( createObjectInputStream(new ByteArrayInputStream(message.getBody()), this.codebaseUrl)); } catch (IOException e) { throw new MessageConversionException( "failed to convert serialized Message content", e); } catch (IllegalArgumentException e) { throw new MessageConversionException( "failed to convert serialized Message content", e); } catch (IllegalStateException e) { throw new MessageConversionException( "failed to convert serialized Message content", e); } } } if (content == null) { //都沒有符合，則轉換成字節數組 content = message.getBody(); } return content; } ~~~ 源碼分析總結： 1.`MessageConverter`可以把`java`對象轉換成`Message`對象，也可以把`Message`對象轉換成`java`對象 2.`MessageListenerAdapter`內部通過`MessageConverter`把`Message`轉換成java對象，然后找到相應的處理方法，參數為轉換成的java對象。 3.`SimpleMessageConverter`處理邏輯： 如果`content_type`是以text開頭，則把消息轉換成`String`類型 如果`content_type的`值是`application/x-java-serialized-object`則把消息序列化為java對象，否則，把消息轉換成字節數組