Spring整合RabbitMQ

最新推荐文章于 2022-09-19 13:29:25 发布

xxc1605629895

最新推荐文章于 2022-09-19 13:29:25 发布

阅读量985

点赞数 1

分类专栏： RabbitMQ 文章标签： Spring RabbitMQ

RabbitMQ 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Spring AMQP是对AMQP协议的抽象和封装，从官方网站上得知它是由两个项目组成的(spring-amqp和spring-rabbit)。在使用Spring整合RabbitMQ时我们主要关注三个核心接口(MessageListenerContainer、RabbitAdmin以及RabbitTemplate)

RabbitAdmin: 用于声明交换机 队列 绑定等
RabbitTemplate: 用于RabbitMQ消息的发送和接收
MessageListenerContainer: 监听容器 为消息入队提供异步处理

使用Spring整合RabbitMQ需要导入如下依赖

<dependency>
    <groupId>org.springframework.amqp</groupId>
    <artifactId>spring-rabbit</artifactId>
    <version>2.0.2.RELEASE</version>
</dependency>

本系列博客源码GIT地址:https://github.com/RobertoHuang/RGP-RABBITMQ.git

Spring AMQP手动声明

1.创建生产者配置类将RabbitAdmin、RabbitTemplate纳入Spring管理

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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringAMQPProducerConfig {

	@Bean
	public ConnectionFactory connectionFactory() {
		com.rabbitmq.client.ConnectionFactory connectionFactory = new com.rabbitmq.client.ConnectionFactory();
		
		// 配置连接信息
		connectionFactory.setHost("192.168.0.4");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        
        // 网络异常自动连接恢复
        connectionFactory.setAutomaticRecoveryEnabled(true);
        // 每10秒尝试重试连接一次
        connectionFactory.setNetworkRecoveryInterval(10000);
        
        // 设置 ConnectionFactory 属性
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put("principal", "RobertoHuang");
        properties.put("description", "RGP订单系统V2.0");
        properties.put("emailAddress", "RobertoHuang@foxmail.com");
        connectionFactory.setClientProperties(properties);
        
        return new CachingConnectionFactory(connectionFactory);
	}
	
	@Bean
	public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
		return new RabbitAdmin(connectionFactory);
	}
	
	@Bean
	public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
		return new RabbitTemplate(connectionFactory);
	}
	
}

2.创建生产者启动类

import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackages = "com.johnfnash.learn.spring.rabbitmq.manual.producer")
public class ProducerApplication {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProducerApplication.class);
		
		RabbitAdmin rabbitAdmin = context.getBean(RabbitAdmin.class);
		RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
		
		// 声明交换机
		rabbitAdmin.declareExchange(new DirectExchange("roberto.order", true, false,new HashMap<String, Object>()));
	
		// 声明消息（消息体，消息属性）
		MessageProperties messageProperties = new MessageProperties();
		messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
		messageProperties.setContentType("UTF-8");
		Message message = new Message("订单消息".getBytes(), messageProperties);
		
		// 发布消息
		// 发布消息还可以使用rabbitTemplate.convertAndSend(); 其支持消息后置处理
		rabbitTemplate.send("roberto.order", "add", message);
		
//		context.close();
	}

}

3.创建消费者配置类将RabbitAdmin纳入Spring管理，并在MessageListenerContainer类中定义了消息消费的逻辑

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;
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.listener.MessageListenerContainer;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.support.ConsumerTagStrategy;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringAMQPConsumerConfig {

	@Bean
	public ConnectionFactory connectionFactory() {
		com.rabbitmq.client.ConnectionFactory connectionFactory = new com.rabbitmq.client.ConnectionFactory();
		
		// 配置连接信息
		connectionFactory.setHost("192.168.0.4");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        
        // 网络异常自动连接恢复
        connectionFactory.setAutomaticRecoveryEnabled(true);
        // 每10秒尝试重试连接一次
        connectionFactory.setNetworkRecoveryInterval(10000);
        
        // 设置ConnectionFactory属性信息
        Map<String, Object> connectionFactoryPropertiesMap = new HashMap<String, Object>();
        connectionFactoryPropertiesMap.put("principal", "RobertoHuang");
        connectionFactoryPropertiesMap.put("description", "RGP订单系统V2.0");
        connectionFactoryPropertiesMap.put("emailAddress", "RobertoHuang@foxmail.com");
        connectionFactory.setClientProperties(connectionFactoryPropertiesMap);
        
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(connectionFactory);
        return cachingConnectionFactory;
	}

	@Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }
	
	@Bean
	public MessageListenerContainer messageListener(ConnectionFactory connectionFactory) {
		SimpleMessageListenerContainer messageListenerContainer = new SimpleMessageListenerContainer();
		messageListenerContainer.setConnectionFactory(connectionFactory);
		messageListenerContainer.setQueueNames("roberto.order.add");
		
		// 设置消费者线程数
		messageListenerContainer.setConcurrentConsumers(5);
		// 设置最大消费者线程数
		messageListenerContainer.setMaxConcurrentConsumers(10);
		
		// 设置消费者属性信息
		Map<String, Object> argumentMap = new HashMap<String, Object>();
		messageListenerContainer.setConsumerArguments(argumentMap);
		
		// 设置消费者标签
		messageListenerContainer.setConsumerTagStrategy(new ConsumerTagStrategy() {
			@Override
			public String createConsumerTag(String queue) {
				return "RGP订单系统ADD处理逻辑消费者";
			}
		});
		
		// 使用setAutoStartup方法可以手动设置消息消费时机
		messageListenerContainer.setAutoStartup(false);
		
		// 使用setAfterReceivePostProcessors方法可以增加消息后置处理器
		//messageListenerContainer.setAfterReceivePostProcessors();
		
		messageListenerContainer.setMessageListener(new MessageListener() {
			@Override
			public void onMessage(Message message) {
				try {
					System.out.println(new String(message.getBody(), "UTF-8"));
					System.out.println(message.getMessageProperties());
				} catch (UnsupportedEncodingException e) {
					e.printStackTrace();
				}
			}
		});

		return messageListenerContainer;
	}
	
}

4.创建消费者启动类

import java.util.HashMap;

import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.listener.MessageListenerContainer;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackages = "com.johnfnash.learn.spring.rabbitmq.manual.consumer")
public class ConsumerApplication {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConsumerApplication.class);
		
		RabbitAdmin rabbitAdmin = context.getBean(RabbitAdmin.class);
		MessageListenerContainer messageListenerContainer = context.getBean(MessageListenerContainer.class);
		
		// 声明队列 (队列名", 是否持久化, 是否排他, 是否自动删除, 队列属性);
		rabbitAdmin.declareQueue(new Queue("roberto.order.add", true, false, false, new HashMap<>()));
		
		// 声明Direct Exchange (交换机名, 是否持久化, 是否自动删除, 交换机属性);
        rabbitAdmin.declareExchange(new DirectExchange("roberto.order", true, false, new HashMap<>()));

        // 将队列绑定到交换机上， Routing Key 为 add
        rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue("roberto.order.add")).to(new DirectExchange("roberto.order")).with("add"));
        
        // 开始监听队列
        messageListenerContainer.start();
       
//       context.close();
	}

}

5.依次启动消息消费者和生产者控制台输出如下

订单信息
MessageProperties [headers={}, contentType=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=roberto.order, receivedRoutingKey=add, deliveryTag=1, consumerTag=RGP订单系统ADD处理逻辑消费者, consumerQueue=roberto.order.add]

上诉代码使用Spring整合RabbitMQ，最终实现效果和上一篇博客介绍RabbitMQ Java Client一致

Spring AMQP自动声明

在上诉的Demo中我们是手动使用RabbitAdmin对交换机、队列和绑定进行声明的，Spring AMQP还提供了自动声明方式交换机、队列和绑定。我们可以直接把要自动声明的组件纳入Spring容器中管理即可，自动声明发生在RabbitMQ第一次连接创建的时候，自动声明支持单个和批量自动声明。使用自动声明需要符合如下条件:

需要有连接产生
RabbitAdmin必须交由Spring管理，且autoStartup必须为true(默认)
如果ConnectionFactory使用的是CachingConnectionFactory，则cacheMode必须要为CacheMode.CHANNEL
所有要声明的组件的shouldDeclare必须为true
要声明的Queue名称不能以amq.开头

上诉规则定义在RabbitAdmin的afterPropertiesSet方法中，有兴趣的同学可以自行阅读RabbitAdmin源码

1.创建生产者配置类将RabbitAdmin、RabbitTemplate纳入Spring管理

@Configuration
public class SpringAMQPProducerConfig {

	@Bean
	public ConnectionFactory connectionFactory() {
		com.rabbitmq.client.ConnectionFactory connectionFactory = new com.rabbitmq.client.ConnectionFactory();
		
		// 配置连接信息
		connectionFactory.setHost("192.168.0.4");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        
        // 网络异常自动连接恢复
        connectionFactory.setAutomaticRecoveryEnabled(true);
        // 每10秒尝试重试连接一次
        connectionFactory.setNetworkRecoveryInterval(10000);
        
        // 设置 ConnectionFactory 属性
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put("principal", "RobertoHuang");
        properties.put("description", "RGP订单系统V2.0");
        properties.put("emailAddress", "RobertoHuang@foxmail.com");
        connectionFactory.setClientProperties(properties);
        
        return new CachingConnectionFactory(connectionFactory);
	}
	
	@Bean
	public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
		return new RabbitAdmin(connectionFactory);
	}
	
	@Bean
	public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
		return new RabbitTemplate(connectionFactory);
	}
	
}

2.创建生产者启动类

@ComponentScan(basePackages = "com.johnfnash.learn.spring.rabbitmq.auto.producer")
public class ProducerApplication {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProducerApplication.class);
		
		RabbitAdmin rabbitAdmin = context.getBean(RabbitAdmin.class);
		RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
		
		// 声明交换机
		rabbitAdmin.declareExchange(new DirectExchange("roberto.order", true, false,new HashMap<String, Object>()));
	
		// 声明消息（消息体，消息属性）
		MessageProperties messageProperties = new MessageProperties();
		messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
		messageProperties.setContentType("UTF-8");
		Message message = new Message("订单消息".getBytes(), messageProperties);
		
		// 发布消息
		// 发布消息还可以使用rabbitTemplate.convertAndSend(); 其支持消息后置处理
		rabbitTemplate.send("roberto.order", "add", message);
		
//		context.close();
	}

}

3.创建消费者配置类将RabbitAdmin纳入Spring管理，并在MessageListenerContainer类中定义了消息消费的逻辑，并且在该配置类中声明交换机，队列，绑定

@Configuration
public class SpringAMQPConsumerConfig {

	@Bean
	public ConnectionFactory connectionFactory() {
		com.rabbitmq.client.ConnectionFactory connectionFactory = new com.rabbitmq.client.ConnectionFactory();
		
		// 配置连接信息
		connectionFactory.setHost("192.168.0.4");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        
        // 网络异常自动连接恢复
        connectionFactory.setAutomaticRecoveryEnabled(true);
        // 每10秒尝试重试连接一次
        connectionFactory.setNetworkRecoveryInterval(10000);
        
        // 设置ConnectionFactory属性信息
        Map<String, Object> connectionFactoryPropertiesMap = new HashMap<String, Object>();
        connectionFactoryPropertiesMap.put("principal", "RobertoHuang");
        connectionFactoryPropertiesMap.put("description", "RGP订单系统V2.0");
        connectionFactoryPropertiesMap.put("emailAddress", "RobertoHuang@foxmail.com");
        connectionFactory.setClientProperties(connectionFactoryPropertiesMap);
        
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(connectionFactory);
        return cachingConnectionFactory;
	}

	@Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }
	
	// 自动声明交换机
    // 如果要一次性声明多个 使用public List<Exchange> listExchange()即可
	@Bean
	public Exchange exchange() {
		return new DirectExchange("roberto.order", true, false, new HashMap<>());
	}
	
	@Bean
    // 自动声明队列
    // 如果要一次性声明多个 使用public List<Queue> listQueue()即可
    public Queue queue() {
		return new Queue("roberto.order.add", true, false, false, new HashMap<>());
	}
	
	@Bean
	// 自动声明绑定
    // 如果要一次性声明多个 使用public List<Binding> listBinding()即可
	public Binding Binding() {
		return new Binding("roberto.order.add", Binding.DestinationType.QUEUE
				, "roberto.order", "add", new HashMap<>());
	}
	
	@Bean
	public MessageListenerContainer messageListener(ConnectionFactory connectionFactory) {
		SimpleMessageListenerContainer messageListenerContainer = new SimpleMessageListenerContainer();
		messageListenerContainer.setConnectionFactory(connectionFactory);
		messageListenerContainer.setQueueNames("roberto.order.add");
		
		// 设置消费者线程数
		messageListenerContainer.setConcurrentConsumers(5);
		// 设置最大消费者线程数
		messageListenerContainer.setMaxConcurrentConsumers(10);
		
		// 设置消费者属性信息
		Map<String, Object> argumentMap = new HashMap<String, Object>();
		messageListenerContainer.setConsumerArguments(argumentMap);
		
		// 设置消费者标签
		messageListenerContainer.setConsumerTagStrategy(new ConsumerTagStrategy() {
			@Override
			public String createConsumerTag(String queue) {
				return "RGP订单系统ADD处理逻辑消费者";
			}
		});
		
		// 使用setAutoStartup方法可以手动设置消息消费时机
		// 注意：Spring AMQP自动声明的情况下必须设置为 true
		messageListenerContainer.setAutoStartup(true);
		
		// 使用setAfterReceivePostProcessors方法可以增加消息后置处理器
		//messageListenerContainer.setAfterReceivePostProcessors();
		
		messageListenerContainer.setMessageListener(new MessageListener() {
			@Override
			public void onMessage(Message message) {
				try {
					System.out.println(new String(message.getBody(), "UTF-8"));
					System.out.println(message.getMessageProperties());
				} catch (UnsupportedEncodingException e) {
					e.printStackTrace();
				}
			}
		});

		return messageListenerContainer;
	}
	
}

4.创建消费者启动类

@ComponentScan(basePackages = "com.johnfnash.learn.spring.rabbitmq.auto.consumer")
public class ConsumerApplication {

	@SuppressWarnings({ "unused", "resource" })
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConsumerApplication.class);
		
//       context.close();
	}

}

5.依次启动消息消费者和生产者控制台输出如下

订单信息
MessageProperties [headers={}, contentType=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, redelivered=false, receivedExchange=roberto.order, receivedRoutingKey=add, deliveryTag=1, consumerTag=RGP订单系统ADD处理逻辑消费者, consumerQueue=roberto.order.add]

该代码与上诉代码实现的效果一致，只是将交换机，队列，绑定进行了自动声明

MessageListenerAdapte

以上两个Demo在消费消息处理逻辑时往MessageListenerContainer中传递了MessageListener，但是我们有时候已经写好了消费逻辑对应的类，我们不希望它去扩展MessageListener/ChannelAwareMessageListener，因为这么做的话意味着我们需要改变现有代码。Spring AMQP提供了消息处理器适配器的功能，它可以把一个纯POJO类适配成一个可以处理消息的处理器，默认处理消息的方法为handleMessage，可以通过setDefaultListenerMethod方法进行修改

1.创建生产者配置类

@Configuration
public class SpringAMQPProducerConfig {

	@Bean
	public ConnectionFactory connectionFactory() {
		com.rabbitmq.client.ConnectionFactory connectionFactory = new com.rabbitmq.client.ConnectionFactory();
		
		// 配置连接信息
		connectionFactory.setHost("192.168.0.4");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        
        // 网络异常自动连接恢复
        connectionFactory.setAutomaticRecoveryEnabled(true);
        // 每10秒尝试重试连接一次
        connectionFactory.setNetworkRecoveryInterval(10000);
        
        // 设置 ConnectionFactory 属性
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put("principal", "RobertoHuang");
        properties.put("description", "RGP订单系统V2.0");
        properties.put("emailAddress", "RobertoHuang@foxmail.com");
        connectionFactory.setClientProperties(properties);
        
        return new CachingConnectionFactory(connectionFactory);
	}
	
	@Bean
	public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
		return new RabbitAdmin(connectionFactory);
	}
	
	@Bean
	public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
		return new RabbitTemplate(connectionFactory);
	}
	
}

2.创建生产者启动类

@ComponentScan(basePackages = "com.johnfnash.learn.spring.rabbitmq.adapter.producer")
public class ProducerApplication {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProducerApplication.class);
		
		RabbitAdmin rabbitAdmin = context.getBean(RabbitAdmin.class);
		RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
		
		// 声明交换机
		rabbitAdmin.declareExchange(new DirectExchange("roberto.order", true, false,new HashMap<String, Object>()));
	
		// 声明消息（消息体，消息属性）
		MessageProperties messageProperties = new MessageProperties();
		messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
		messageProperties.setContentType("UTF-8");
		Message message = new Message("订单消息".getBytes(), messageProperties);
		
		// 发布消息
		// 发布消息还可以使用rabbitTemplate.convertAndSend(); 其支持消息后置处理
		rabbitTemplate.send("roberto.order", "add", message);
		
//		context.close();
	}

}

3.创建消费者消息处理器类，它可是是纯POJO类

public class MessageHandle {

	public void add(byte[] message) {
		try {
			System.out.println(new String(message,"UTF-8"));
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
	}
	
}

4.创建消费者配置类配置自定义消息处理器(将roberto.order.add队列使用自定义消息处理类的add方法进行处理)

@Configuration
public class SpringAMQPConsumerConfig {

	@Bean
	public ConnectionFactory connectionFactory() {
		com.rabbitmq.client.ConnectionFactory connectionFactory = new com.rabbitmq.client.ConnectionFactory();
		
		// 配置连接信息
		connectionFactory.setHost("192.168.0.4");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        
        // 网络异常自动连接恢复
        connectionFactory.setAutomaticRecoveryEnabled(true);
        // 每10秒尝试重试连接一次
        connectionFactory.setNetworkRecoveryInterval(10000);
        
        // 设置ConnectionFactory属性信息
        Map<String, Object> connectionFactoryPropertiesMap = new HashMap<String, Object>();
        connectionFactoryPropertiesMap.put("principal", "RobertoHuang");
        connectionFactoryPropertiesMap.put("description", "RGP订单系统V2.0");
        connectionFactoryPropertiesMap.put("emailAddress", "RobertoHuang@foxmail.com");
        connectionFactory.setClientProperties(connectionFactoryPropertiesMap);
        
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(connectionFactory);
        return cachingConnectionFactory;
	}

	@Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }
	
	// 自动声明交换机
    // 如果要一次性声明多个 使用public List<Exchange> listExchange()即可
	@Bean
	public Exchange exchange() {
		return new DirectExchange("roberto.order", true, false, new HashMap<>());
	}
	
	@Bean
    // 自动声明队列
    // 如果要一次性声明多个 使用public List<Queue> listQueue()即可
    public Queue queue() {
		return new Queue("roberto.order.add", true, false, false, new HashMap<>());
	}
	
	@Bean
	// 自动声明绑定
    // 如果要一次性声明多个 使用public List<Binding> listBinding()即可
	public Binding Binding() {
		return new Binding("roberto.order.add", Binding.DestinationType.QUEUE
				, "roberto.order", "add", new HashMap<>());
	}
	
	@Bean
	public MessageListenerContainer messageListener(ConnectionFactory connectionFactory) {
		SimpleMessageListenerContainer messageListenerContainer = new SimpleMessageListenerContainer();
		messageListenerContainer.setConnectionFactory(connectionFactory);
		messageListenerContainer.setQueueNames("roberto.order.add");
		
		// 设置消费者线程数
		messageListenerContainer.setConcurrentConsumers(5);
		// 设置最大消费者线程数
		messageListenerContainer.setMaxConcurrentConsumers(10);
		
		// 设置消费者属性信息
		Map<String, Object> argumentMap = new HashMap<String, Object>();
		messageListenerContainer.setConsumerArguments(argumentMap);
		
		// 设置消费者标签
		messageListenerContainer.setConsumerTagStrategy(new ConsumerTagStrategy() {
			@Override
			public String createConsumerTag(String queue) {
				return "RGP订单系统ADD处理逻辑消费者";
			}
		});
		
		// 使用setAutoStartup方法可以手动设置消息消费时机
		// 注意：Spring AMQP自动声明的情况下必须设置为 true
		messageListenerContainer.setAutoStartup(true);
		
		// 使用setAfterReceivePostProcessors方法可以增加消息后置处理器
		//messageListenerContainer.setAfterReceivePostProcessors();
		
		// 新建消息处理器适配器
		MessageListenerAdapter adapter = new MessageListenerAdapter(new MessageHandle());
		// 设置默认处理消息方法
		adapter.setDefaultListenerMethod("handleMessage");
		// 将roberto.order.add队列的消息 使用add方法进行处理
		Map<String, String> queueOrTagToMethodName = new HashMap<>();
		queueOrTagToMethodName.put("roberto.order.add", "add");
		adapter.setQueueOrTagToMethodName(queueOrTagToMethodName);
		messageListenerContainer.setMessageListener(adapter);
		
		return messageListenerContainer;
	}
	
}

5.创建消费者启动类

public class ConsumerApplication {

	@SuppressWarnings({ "unused", "resource" })
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConsumerApplication.class);
		
//       context.close();
	}

}

6.依次启动消息消费者和生产者控制台输出如下

订单信息

如上Demo说明我们可以将一个纯POJO类定义为消息处理器，并且不用去扩展MessageListener/ChannelAwareMessageListener接口，关于自定义处理器方法的参数默认情况下为byte[]类型，这是由Spring AMQP默认消息转换器(SimpleMessageConverter)决定的，接下来我们将介绍Spring AMQP的消息转换器功能

Spring AMQP消息转换器

在上诉例子中我们定义的add(byte[] message)方法的参数是一个字节数组，但是有时候我们往RabbitMQ中发送的是一个JSON对象，我们希望在处理消息的时候它已经自动帮我们转为JAVA对象；又或者我们往RabbitMQ中发送的是一张图片或其他格式的文件，我们希望在处理消息的时候它已经自动帮我们转成文件格式，我们可以手动设置MessageConverter来实现如上需求，如果未设置MessageConverter则使用Spring AMQP默认提供的SimpleMessageConverter

以下例子使用MessageConverter实现了当生产者往RabbitMQ发送不同类型的数据的时候，使用MessageHandle不同的方法进行处理，需要注意的是当生产者在发送JSON数据的时候，需要制定这个JSON是哪个对象，用于Spring AMQP转换，规则如下

当发送普通对象的JSON数据时，需要在消息的header中增加一个__TypeId__的属性告知消费者是哪个对象

当发送List集合对象的JSON数据时，需要在消息的header中将__TypeId__指定为java.util.List，并且需要额外指定属性__ContentTypeId__用户告知消费者List集合中的对象类型

当发送Map集合对象的JSON数据时，需要在消息的header中将__TypeId__指定为java.util.Map，并且需要额外指定属性__KeyTypeId__用于告知客户端Map中key的类型，__ContentTypeId__用于告知客户端Map中Value的类型

1.创建订单实体类

public class Order {

	 /**
     * 订单编号
     **/
    private String orderId;

    /**
     * 订单金额
     **/
    private BigDecimal orderAmount;

    public Order() {

    }

    public Order(String orderId, BigDecimal orderAmount) {
        this.orderId = orderId;
        this.orderAmount = orderAmount;
    }

	// setter, getter

}

2.自定义文件消息转换器

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;
import org.springframework.util.FileCopyUtils;

// 自定义文件消息转换器
public class FileMessageConverter implements MessageConverter {

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

	@Override
	public Object fromMessage(Message message) throws MessageConversionException {
		String extName = (String) message.getMessageProperties().getHeaders().get("_extName");
		byte[] bytes = message.getBody();
        String fileName = UUID.randomUUID().toString();
        String filePath = System.getProperty("java.io.tmpdir") + fileName + "." + extName;
        File tempFile = new File(filePath);
        try {
			FileCopyUtils.copy(bytes, tempFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
        
		return tempFile;
	}

}

3.自定义字符串消息转换器

// 自定义字符串消息转换器
public class StringMessageConverter implements MessageConverter {

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

	@Override
	public Object fromMessage(Message message) throws MessageConversionException {
		try {
            return new String(message.getBody(), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new MessageConversionException("StringMessageConverter转换失败", e);
        }
	}

}

4.自定义消息处理器类

// 自定义消息处理器类
public class MessageHandle {

	public void add(byte[] body) {
		System.out.println("----------byte[]方法进行处理----------");
		System.out.println("body");
	}

	public void add(String message) {
		System.out.println("----------String方法进行处理----------");
		System.out.println(message);
	}

	public void add(File file) {
		System.out.println("----------File方法进行处理----------");
		System.out.println(file.length());
		System.out.println(file.getName());
		System.out.println(file.getAbsolutePath());
	}

	public void add(Order order) {
		System.out.println("----------Order方法进行处理----------");
		System.out.println(order.getOrderId() + "---" + order.getOrderAmount());
	}

	public void add(List<Order> orderList) {
		System.out.println("----------List<Order>方法进行处理----------");
		System.out.println(orderList.size());
		for (Order order : orderList) {
			System.out.println(order.getOrderId() + "---" + order.getOrderAmount());
		}
	}

	public void add(Map<String, Order> orderMap) {
		System.out.println("----------Map<String, Order>方法进行处理----------");
		for (Map.Entry<String, Order> entry : orderMap.entrySet()) {
			System.out.println(entry.getKey());
			System.out.println(entry.getValue().getOrderId() + "---" + entry.getValue().getOrderAmount());
		}
	}

}

5.创建生产者配置类

@Configuration
public class SpringAMQPProducerConfig {

	@Bean
	public ConnectionFactory connectionFactory() {
		com.rabbitmq.client.ConnectionFactory connectionFactory = new com.rabbitmq.client.ConnectionFactory();
		
		// 配置连接信息
		connectionFactory.setHost("192.168.0.4");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        
        // 网络异常自动连接恢复
        connectionFactory.setAutomaticRecoveryEnabled(true);
        // 每10秒尝试重试连接一次
        connectionFactory.setNetworkRecoveryInterval(10000);
        
        // 设置 ConnectionFactory 属性
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put("principal", "RobertoHuang");
        properties.put("description", "RGP订单系统V2.0");
        properties.put("emailAddress", "RobertoHuang@foxmail.com");
        connectionFactory.setClientProperties(properties);
        
        return new CachingConnectionFactory(connectionFactory);
	}
	
	@Bean
	public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
		return new RabbitAdmin(connectionFactory);
	}
	
	@Bean
	public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
		return new RabbitTemplate(connectionFactory);
	}
	
}

6.创建生产者启动类发送多条不同消息类型消息

@ComponentScan(basePackages = "com.johnfnash.learn.spring.rabbitmq.message.converter.producer")
public class ProducerApplication {

	private static final String APPLICATION_JSON = "application/json";
	private static final String CONTENT_TYPE_ID = "__ContentTypeId__";
	private static final String TYPE_ID = "__TypeId__";
	private static final String ROUTING_KEY = "add";
	private static final String EXCHANGE_NAME = "roberto.order";

	@SuppressWarnings("resource")
	public static void main(String[] args) throws Exception {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProducerApplication.class);

		RabbitAdmin rabbitAdmin = context.getBean(RabbitAdmin.class);
		RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);

		// 声明交换机
		rabbitAdmin.declareExchange(new DirectExchange(EXCHANGE_NAME, true, false, new HashMap<String, Object>()));

		// 发布消息
		sendString(rabbitTemplate);
		sendSingle(rabbitTemplate);
		sendList(rabbitTemplate);
		sendMap(rabbitTemplate);
		
		// context.close();
	}

	public static void sendString(RabbitTemplate rabbitTemplate) {
		// 声明消息 (消息体, 消息属性)
		MessageProperties messageProperties = new MessageProperties();
		messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
		messageProperties.setContentType("text/plain");
		Message message = new Message("订单消息".getBytes(), messageProperties);

		rabbitTemplate.send(EXCHANGE_NAME, ROUTING_KEY, message);
	}

	public static void sendSingle(RabbitTemplate rabbitTemplate) throws Exception {
		Order order = new Order("OD0000001", new BigDecimal(888888.888888));
		ObjectMapper mapper = new ObjectMapper();

		// 声明消息 (消息体, 消息属性)
		MessageProperties properties = new MessageProperties();
		properties.getHeaders().put(TYPE_ID, "order");
		properties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
		properties.setContentType(APPLICATION_JSON);
		Message message = new Message(mapper.writeValueAsString(order).getBytes(), properties);

		rabbitTemplate.send(EXCHANGE_NAME, ROUTING_KEY, message);
	}

	public static void sendList(RabbitTemplate rabbitTemplate) throws Exception {
		Order order = new Order("OD0000001", new BigDecimal(888888.888888));
		Order order2 = new Order("OD0000002", new BigDecimal(888888.888888));
		List<Order> orderList = Arrays.asList(order, order2);

		ObjectMapper mapper = new ObjectMapper();
		// 声明消息 (消息体, 消息属性)
		MessageProperties properties = new MessageProperties();
		properties.getHeaders().put(TYPE_ID, "java.util.List");
		properties.getHeaders().put(CONTENT_TYPE_ID, "order");
		properties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
		properties.setContentType(APPLICATION_JSON);
		Message message = new Message(mapper.writeValueAsString(orderList).getBytes(), properties);

		rabbitTemplate.send(EXCHANGE_NAME, ROUTING_KEY, message);
	}

	public static void sendMap(RabbitTemplate rabbitTemplate) throws Exception {
		Order order = new Order("OD0000001", new BigDecimal(888888.888888));
		Order order2 = new Order("OD0000002", new BigDecimal(888888.888888));
		Map<String, Order> orderMap = new HashMap<>();
		orderMap.put(order.getOrderId(), order);
		orderMap.put(order2.getOrderId(), order2);

		ObjectMapper objectMapper = new ObjectMapper();
		// 声明消息 (消息体, 消息属性)
		MessageProperties properties = new MessageProperties();
		properties.getHeaders().put(TYPE_ID, "java.util.Map");
		properties.getHeaders().put("__KeyTypeId__", "java.lang.String");
		properties.getHeaders().put(CONTENT_TYPE_ID, "order");
		properties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
		properties.setContentType(APPLICATION_JSON);
		Message message = new Message(objectMapper.writeValueAsString(orderMap).getBytes(), properties);

		rabbitTemplate.send(EXCHANGE_NAME, ROUTING_KEY, message);
	}

}

7.创建消费者配置类为不同ContentType消息设置消息转换器

@Configuration
public class SpringAMQPConsumerConfig {

	@Bean
	public ConnectionFactory connectionFactory() {
		com.rabbitmq.client.ConnectionFactory connectionFactory = new com.rabbitmq.client.ConnectionFactory();
		
		// 配置连接信息
		connectionFactory.setHost("192.168.0.4");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        
        // 网络异常自动连接恢复
        connectionFactory.setAutomaticRecoveryEnabled(true);
        // 每10秒尝试重试连接一次
        connectionFactory.setNetworkRecoveryInterval(10000);
        
        // 设置ConnectionFactory属性信息
        Map<String, Object> connectionFactoryPropertiesMap = new HashMap<String, Object>();
        connectionFactoryPropertiesMap.put("principal", "RobertoHuang");
        connectionFactoryPropertiesMap.put("description", "RGP订单系统V2.0");
        connectionFactoryPropertiesMap.put("emailAddress", "RobertoHuang@foxmail.com");
        connectionFactory.setClientProperties(connectionFactoryPropertiesMap);
        
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(connectionFactory);
        return cachingConnectionFactory;
	}

	@Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }
	
	// 自动声明交换机
    // 如果要一次性声明多个 使用public List<Exchange> listExchange()即可
	@Bean
	public Exchange exchange() {
		return new DirectExchange("roberto.order", true, false, new HashMap<>());
	}
	
	@Bean
    // 自动声明队列
    // 如果要一次性声明多个 使用public List<Queue> listQueue()即可
    public Queue queue() {
		return new Queue("roberto.order.add", true, false, false, new HashMap<>());
	}
	
	@Bean
	// 自动声明绑定
    // 如果要一次性声明多个 使用public List<Binding> listBinding()即可
	public Binding Binding() {
		return new Binding("roberto.order.add", Binding.DestinationType.QUEUE
				, "roberto.order", "add", new HashMap<>());
	}
	
	@Bean
	public MessageListenerContainer messageListener(ConnectionFactory connectionFactory) {
		SimpleMessageListenerContainer messageListenerContainer = new SimpleMessageListenerContainer();
		messageListenerContainer.setConnectionFactory(connectionFactory);
		messageListenerContainer.setQueueNames("roberto.order.add");
		
		// 设置消费者线程数
		messageListenerContainer.setConcurrentConsumers(5);
		// 设置最大消费者线程数
		messageListenerContainer.setMaxConcurrentConsumers(10);
		
		// 设置消费者属性信息
		Map<String, Object> argumentMap = new HashMap<String, Object>();
		messageListenerContainer.setConsumerArguments(argumentMap);
		
		// 设置消费者标签
		messageListenerContainer.setConsumerTagStrategy(new ConsumerTagStrategy() {
			@Override
			public String createConsumerTag(String queue) {
				return "RGP订单系统ADD处理逻辑消费者";
			}
		});
		
		// 使用setAutoStartup方法可以手动设置消息消费时机
		// 注意：Spring AMQP自动声明的情况下必须设置为 true
		messageListenerContainer.setAutoStartup(true);
		
		// 使用setAfterReceivePostProcessors方法可以增加消息后置处理器
		//messageListenerContainer.setAfterReceivePostProcessors();
		
		// 新建消息处理器适配器
		MessageListenerAdapter adapter = new MessageListenerAdapter(new MessageHandle());
		// 设置默认处理消息方法
		adapter.setDefaultListenerMethod("handleMessage");
		// 将roberto.order.add队列的消息 使用add方法进行处理
		Map<String, String> queueOrTagToMethodName = new HashMap<>();
		queueOrTagToMethodName.put("roberto.order.add", "add");
		adapter.setQueueOrTagToMethodName(queueOrTagToMethodName);
		messageListenerContainer.setMessageListener(adapter);
		
		// 设置消息转换器
		ContentTypeDelegatingMessageConverter converter = 
				new ContentTypeDelegatingMessageConverter();
		StringMessageConverter stringMessageConverter = new StringMessageConverter();
		FileMessageConverter fileMessageConverter = new FileMessageConverter();
		Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
		Map<String, Class<?>> idClassMapping = new HashMap<>();
        idClassMapping.put("order", Order.class);
        DefaultJackson2JavaTypeMapper javaTypeMapper = new DefaultJackson2JavaTypeMapper();
        javaTypeMapper.setIdClassMapping(idClassMapping);
        jackson2JsonMessageConverter.setJavaTypeMapper(javaTypeMapper);
		
        // 设置text/html text/plain 使用StringMessageConverter
        converter.addDelegate("text/html", stringMessageConverter);
        converter.addDelegate("text/plain", stringMessageConverter);
        // 设置application/json 使用Jackson2JsonMessageConverter
        converter.addDelegate("application/json", jackson2JsonMessageConverter);
        // 设置image/jpg image/png 使用FileMessageConverter
        converter.addDelegate("image/jpg", fileMessageConverter);
        converter.addDelegate("image/png", fileMessageConverter);
        adapter.setMessageConverter(converter);
        
		return messageListenerContainer;
	}
	
}

8.创建消费者启动类

@ComponentScan(basePackages = "com.johnfnash.learn.spring.rabbitmq.message.converter.consumer")
public class ConsumerApplication {

	@SuppressWarnings({ "unused", "resource" })
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConsumerApplication.class);
		
//       context.close();
	}

}

9.依次启动消息消费者和生产者控制台输出如下

----------String方法进行处理----------
订单消息

----------File方法进行处理----------
18758
403e735f-88ff-4bbe-b7d3-a07766de7df9.jpg
C:\Users\ADMINI~1\AppData\Local\Temp\403e735f-88ff-4bbe-b7d3-a07766de7df9.jpg

----------Order方法进行处理----------
OD0000001---888888.888888

----------List<Order>方法进行处理----------
2
OD0000001---888888.888888
OD0000002---888888.888888

----------Map<String, Order>方法进行处理----------
OD0000001
OD0000001---888888.888888
OD0000002
OD0000002---888888.888888

在经过消息转化器后，Spring AMQP会根据最后转换结果的类型找到对应的消息处理方法，在本章中我们只介绍了消息转换器的fromMessage()方法，关于toMessage()将在后续博客中提及

本文转自：(三) RabbitMQ实战教程(面向Java开发人员)之Spring整合RabbitMQ