就像上一个帖子将的消息监听器一样，MessageListenerAdapter是一个自定义的消息监听器，也就是说我们可以在自己的监听器中写一些自定义的逻辑

消息监听适配器

我们把之前的给注释掉，然后来使用MessageListenerAdapter，其中MessageDelegate这个类就是我们自己新写的类

public class MessageDelegate {

    public void handleMessage(String messageBody) {
        System.err.println("handleMessage默认方法，消息内容 String：" + messageBody);
    }
}

类名可以不一样，但是方法名一定要一样，因为在MessageListenerAdapter中，是默认以handleMessage方法名来反射的，我们来看一下MessageListenerAdapter的源码：

这么写完之后，我们就可以发送一条消息来看看，消息监听器是否走了这个方法：

消息内容转换

先贴上两端代码：
之前我们发送消息都是发送一个字符串
类似于：

rabbitTemplate.convertAndSend("exchange002","spring.adb","消息内容");

当消息是Message对象的时候，消息内容其实就是一个byte数组，这个时候我们就需要在消息监听器的基础上加一个消息内容转换器来转换消息内容。

@Test
    public void testSendMessage(){
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.getHeaders().put("desc","信息描述..");
        messageProperties.getHeaders().put("type","自定义消息类型..");
        messageProperties.setContentType("text/plain");
        Message message = new Message("Hello RabbitMQ----测试适配器".getBytes(),messageProperties);
        //
        // rabbitTemplate.convertSendAndReceive("exchange002", "spring.adb",
        //      message
        //      , new MessagePostProcessor() {
        //  @Override
        //  public Message postProcessMessage(Message message) throws AmqpException {
        //      System.out.println("----发送消息内容为：-----"+message);
        //      return message;
        //  } }
        // );
        rabbitTemplate.convertAndSend("exchange002","spring.adb",message);
    }

    //1.适配器方式：默认是有自己的方法的名字的：handleMessage
        MessageListenerAdapter adapter = new MessageListenerAdapter(new MessageDelegate());
        // adapter.setDefaultListenerMethod("自定义的方法");
        adapter.setMessageConverter(new TextMsgConvert());
        container.setMessageListener(adapter);
        return container;

public class TextMsgConvert implements MessageConverter {

    @Override
    public Message toMessage(Object o, MessageProperties messageProperties) throws MessageConversionException {
        return null;
    }

    @Override
    public Object fromMessage(Message message) throws MessageConversionException {
        String contentType = message.getMessageProperties().getContentType();

        if(contentType!=null && contentType.contains("text")){
            return new String(message.getBody());
        }
        return message.getBody();
    }
}

不同队列进入不同的处理方法

public class MessageDelegate {

    public void handleMessage(String messageBody) {
        System.err.println("handleMessage默认方法，消息内容 String：" + messageBody);
    }

    public void method1(String messageBody) {
        System.err.println("方法method1，消息内容 String：" + messageBody);
    }

    public void method2(String messageBody) {
        System.err.println("方法method2，消息内容 String：" + messageBody);
    }
}

@Test
    public void testSendMessage(){
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.getHeaders().put("desc","信息描述..");
        messageProperties.getHeaders().put("type","自定义消息类型..");
        messageProperties.setContentType("text/plain");
        Message message = new Message("Hello RabbitMQ----测试适配器".getBytes(),messageProperties);
        //
        // rabbitTemplate.convertSendAndReceive("exchange002", "spring.adb",
        //      message
        //      , new MessagePostProcessor() {
        //  @Override
        //  public Message postProcessMessage(Message message) throws AmqpException {
        //      System.out.println("----发送消息内容为：-----"+message);
        //      return message;
        //  } }
        // );
        rabbitTemplate.convertAndSend("exchange001","rabbitmq",message);
        rabbitTemplate.convertAndSend("exchange002","spring.adb",message);
    }

@Bean
    public SimpleMessageListenerContainer messageListenerContainer(ConnectionFactory connectionFactory){
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        container.setQueues(queue001(),queue002());
        container.setConcurrentConsumers(1);
        container.setMaxConcurrentConsumers(5);
        container.setDefaultRequeueRejected(false);
        container.setAcknowledgeMode(AcknowledgeMode.AUTO);
        container.setConsumerTagStrategy(new ConsumerTagStrategy() {
            @Override
            public String createConsumerTag(String queue) {
                return queue+"_"+ UUID.randomUUID();
            }
        });
        // container.setMessageListener(new ChannelAwareMessageListener() {
        //  @Override
        //  public void onMessage(Message message, Channel channel) throws Exception {
        //      String msg = new String(message.getBody());
        //      System.out.println("-----消费者："+msg);
        //  }
        // });
        //1.适配器方式：默认是有自己的方法的名字的：handleMessage
        MessageListenerAdapter adapter = new MessageListenerAdapter(new MessageDelegate());

        Map<String,String> queueNameToMethodMap = new HashMap<>();
        queueNameToMethodMap.put("queue001","method1");
        queueNameToMethodMap.put("queue002","method2");
        adapter.setQueueOrTagToMethodName(queueNameToMethodMap);
        // adapter.setDefaultListenerMethod("自定义的方法");
        adapter.setMessageConverter(new TextMsgConvert());
        container.setMessageListener(adapter);
        return container;
    }