Spring整合RabbitMQ详细教程
spring-amqp是对AMQP的一些概念的一些抽象,spring-rabbit是对RabbitMQ操作的封装实现。主要有几个核心类RabbitAdmin、RabbitTemplate、SimpleMessageListenerContainer等RabbitAdmin类完成对Exchange,Queue,Binding的操作,在容器中管理了RabbitAdmin类的时候,可以对Exchange,Queue,Binding进行自动声明。RabbitTemplate类是发送和接收消息的工具类。SimpleMessageListenerContainer是消费消息的容器。
基于配置文件的整合
1、创建Maven项目
- 消费者
- 生产者
2、配置pom.xml 引入依赖
生产者和消费者引入同一依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>2.1.8.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.7.RELEASE</version>
</dependency>
</dependencies>
复制代码
3、配置Spring-rabbit.xml
- rabbitmq.properties
rabbitmq.host=127.0.0.1
rabbitmq.port=5672
rabbitmq.username=admin
rabbitmq.password=admin
rabbitmq.virtual-host=my_vhost
复制代码
- 生产者
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:rabbit="http://www.springframework.org/schema/rabbit"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/rabbit
http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
<!--加载配置文件-->
<context:property-placeholder location="classpath:rabbitmq.properties"/>
<!-- 定义rabbitmq connectionFactory -->
<rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
port="${rabbitmq.port}"
username="${rabbitmq.username}"
password="${rabbitmq.password}"
virtual-host="${rabbitmq.virtual-host}"/>
<!--定义管理交换机、队列-->
<rabbit:admin connection-factory="connectionFactory"/>
<!--定义持久化队列,不存在则自动创建;不绑定到交换机则绑定到默认交换机
默认交换机类型为direct,名字为:"",路由键为队列的名称
-->
<!--
id:bean的名称
name:queue的名称
auto-declare:自动创建
auto-delete:自动删除。 最后一个消费者和该队列断开连接后,自动删除队列
durable:是否持久化
-->
<rabbit:queue id="spring_queue" name="spring_queue" auto-declare="true" />
<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~广播;所有队列都能收到消息~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
<!--定义广播交换机中的持久化队列,不存在则自动创建-->
<rabbit:queue id="spring_fanout_queue_1" name="spring_fanout_queue_1" auto-declare="true"/>
<!--定义广播交换机中的持久化队列,不存在则自动创建-->
<rabbit:queue id="spring_fanout_queue_2" name="spring_fanout_queue_2" auto-declare="true"/>
<!--定义广播类型交换机;并绑定上述两个队列-->
<rabbit:fanout-exchange id="spring_fanout_exchange" name="spring_fanout_exchange" auto-declare="true">
<rabbit:bindings>
<rabbit:binding queue="spring_fanout_queue_1"/>
<rabbit:binding queue="spring_fanout_queue_2"/>
</rabbit:bindings>
</rabbit:fanout-exchange>
<!-- 定义队列-->
<rabbit:queue id="spring_direct_queue" name="spring_direct_queue" auto-declare="true"/>
<!--
定义 Routing 路由模式 交互机
-->
<rabbit:direct-exchange name="spring_direct_exchange">
<rabbit:bindings>
<!--direct 类型的交换机绑定队列 key :路由key queue:队列名称-->
<rabbit:binding queue="spring_direct_queue" key="info"></rabbit:binding>
</rabbit:bindings>
</rabbit:direct-exchange>
<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~通配符;*匹配一个单词,#匹配多个单词 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
<!--定义广播交换机中的持久化队列,不存在则自动创建-->
<rabbit:queue id="spring_topic_queue_star" name="spring_topic_queue_star" auto-declare="true"/>
<!--定义广播交换机中的持久化队列,不存在则自动创建-->
<rabbit:queue id="spring_topic_queue_well" name="spring_topic_queue_well" auto-declare="true"/>
<!--定义广播交换机中的持久化队列,不存在则自动创建-->
<rabbit:queue id="spring_topic_queue_well2" name="spring_topic_queue_well2" auto-declare="true"/>
<!--
声明 topic 类型的交换机
-->
<rabbit:topic-exchange id="spring_topic_exchange" name="spring_topic_exchange" auto-declare="true">
<rabbit:bindings>
<rabbit:binding pattern="yjl.*" queue="spring_topic_queue_star"/>
<rabbit:binding pattern="yjl.#" queue="spring_topic_queue_well"/>
<rabbit:binding pattern="itcast.#" queue="spring_topic_queue_well2"/>
</rabbit:bindings>
</rabbit:topic-exchange>
<!--定义rabbitTemplate对象操作可以在代码中方便发送消息-->
<rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>
</beans>
复制代码
- 消费者
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:rabbit="http://www.springframework.org/schema/rabbit"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/rabbit
http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
<!--加载rabbitmq配置文件-->
<context:property-placeholder location="classpath:rabbitmq.properties"/>
<!-- 定义rabbitmq connectionFactory 连接-->
<rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
port="${rabbitmq.port}"
username="${rabbitmq.username}"
password="${rabbitmq.password}"
virtual-host="${rabbitmq.virtual-host}"/>
<!-- 定义消费者的队列监听器-->
<bean id="springQueueListener" class="com.yjl.rabbitmq.listener.SpringQueueListener"/>
<!-- 定义消费者的交换机监听器-->
<bean id="fanoutListener1" class="com.yjl.rabbitmq.listener.FanoutListener"/>
<!-- <bean id="fanoutListener2" class="com.yjl.rabbitmq.listener.FanoutListener2"/>
<bean id="topicListenerStar" class="com.yjl.rabbitmq.listener.TopicListenerStar"/>
<bean id="topicListenerWell" class="com.yjl.rabbitmq.listener.TopicListenerWell"/>
<bean id="topicListenerWell2" class="com.yjl.rabbitmq.listener.TopicListenerWell2"/>
-->
<rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
<rabbit:listener ref="springQueueListener" queue-names="spring_queue"/>
<rabbit:listener ref="fanoutListener1" queue-names="spring_fanout_queue_1"/>
<!--<rabbit:listener ref="fanoutListener2" queue-names="spring_fanout_queue_2"/>
<rabbit:listener ref="topicListenerStar" queue-names="spring_topic_queue_star"/>
<rabbit:listener ref="topicListenerWell" queue-names="spring_topic_queue_well"/>
<rabbit:listener ref="topicListenerWell2" queue-names="spring_topic_queue_well2"/>-->
</rabbit:listener-container>
</beans>
复制代码
4、代码编写
- 生产者测试发送消息
package com.yjl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
public class ProducerTest {
//1.注入 RabbitTemplate
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void testHelloWorld(){
//2.发送消息
rabbitTemplate.convertAndSend("spring_queue","hello world spring....");
}
/**
* 发送fanout消息
*/
@Test
public void testFanout(){
//2.发送消息
rabbitTemplate.convertAndSend("spring_fanout_exchange","","spring fanout....");
}
@Test
public void testDirect(){
//2.发送消息
rabbitTemplate.convertAndSend("spring_direct_exchange","info","spring Direct....");
}
/**
* 发送topic消息
*/
@Test
public void testTopics(){
//2.发送消息
rabbitTemplate.convertAndSend("spring_topic_exchange","yjl.hehe.haha","spring topic....");
}
}
复制代码
-
消费者监听消息
-
监听fanout交换机
public class FanoutListener implements MessageListener { @Override public void onMessage(Message message) { //打印消息 System.out.println(new String(message.getBody())); } } 复制代码
- 监听指定队列
public class SpringQueueListener implements MessageListener { @Override public void onMessage(Message message) { //打印消息 System.out.println(new String(message.getBody())); } } 复制代码
基于注解的整合
1、第一步与配置文件相同
2、配置pom.xml,添加rabbit的spring依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>2.1.8.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.7.RELEASE</version>
</dependency>
</dependencies>
复制代码
3、添加生产者和消费者相关配置
- 生产者
@Configuration
public class RabbitConfig {
// 连接工厂
@Bean
public ConnectionFactory connectionFactory() {
ConnectionFactory factory
= new CachingConnectionFactory(URI.create("amqp://root:123456@node1:5672/%2f"));
return factory;
}
// RabbitTemplate
@Bean
@Autowired
public RabbitTemplate rabbitTemplate(ConnectionFactory factory) {
RabbitTemplate rabbitTemplate = new RabbitTemplate(factory);
return rabbitTemplate;
}
// RabbitAdmin
@Bean
@Autowired
public RabbitAdmin rabbitAdmin(ConnectionFactory factory) {
RabbitAdmin rabbitAdmin = new RabbitAdmin(factory);
return rabbitAdmin;
}
// Queue
@Bean
public Queue queue() {
final Queue queue = QueueBuilder.nonDurable("queue.anno").build();
return queue;
}
// Exchange
@Bean
public Exchange exchange() {
final FanoutExchange fanoutExchange = new FanoutExchange("ex.anno.fanout", false, false, null);
return fanoutExchange;
}
// Binding
@Bean
@Autowired
public Binding binding(Queue queue, Exchange exchange) {
// 创建一个绑定,不指定绑定的参数
final Binding binding = BindingBuilder.bind(queue).to(exchange).with("key.anno").noargs();
return binding;
}
}
复制代码
- 消费者配置
@Configuration
public class RabbitConfig {
@Bean
public ConnectionFactory connectionFactory() {
return new CachingConnectionFactory(URI.create("amqp://root:123456@node1:5672/%2f"));
}
@Bean
@Autowired
public RabbitTemplate rabbitTemplate(ConnectionFactory factory) {
return new RabbitTemplate(factory);
}
@Bean
@Autowired
public RabbitAdmin rabbitAdmin(ConnectionFactory factory) {
return new RabbitAdmin(factory);
}
@Bean
public Queue queue() {
return QueueBuilder.nonDurable("queue.anno").build();
}
}
复制代码
- 消费者监听
@Component
public class MyMessageListener {
/**
* com.rabbitmq.client.Channel channel对象
* org.springframework.amqp.core.Message message对象 可以直接操作原生的AMQP消息
* org.springframework.messaging.Message to use the messaging abstraction counterpart
* @Payload 注解方法参数,改参数的值就是消息体
* @Header 注解方法参数,访问指定的消息头字段的值
* @Headers 该注解的方法参数获取该消息的消息头的所有字段,参数类型对应于map集合。
* MessageHeaders 参数类型,访问所有消息头字段
* MessageHeaderAccessor or AmqpMessageHeaderAccessor 访问所有消息头字段
*/
@RabbitListener(queues = "queue.anno")
public void whenMessageCome(Message message) throws UnsupportedEncodingException {
System.out.println(new String(message.getBody(), message.getMessageProperties().getContentEncoding()));
}
@RabbitListener(queues = "queue.anno")
public void whenMessageCome(@Payload String messageStr) {
System.out.println(messageStr);
}
}
复制代码
代码测试
- 生产者
public class ProducerApp {
public static void main(String[] args) throws UnsupportedEncodingException {
AbstractApplicationContext context = new AnnotationConfigApplicationContext(RabbitConfig.class);
final RabbitTemplate template = context.getBean(RabbitTemplate.class);
final MessageProperties messageProperties = MessagePropertiesBuilder
.newInstance()
.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN)
.setContentEncoding("gbk")
.setHeader("myKey", "myValue")
.build();
// final Message message = MessageBuilder
// .withBody("你好,世界".getBytes("gbk"))
// .andProperties(messageProperties)
// .build();
// template.send("ex.anno.fanout", "key.anno", message);
for (int i = 0; i < 1000; i++) {
final Message message = MessageBuilder
.withBody(("你好,世界" + i).getBytes("gbk"))
.andProperties(messageProperties)
.build();
template.send("ex.anno.fanout", "key.anno", message);
}
context.close();
}
}
复制代码
- 消费者
public class ConsumerApp {
public static void main(String[] args) throws UnsupportedEncodingException {
// 从指定类加载配置信息
AbstractApplicationContext context = new AnnotationConfigApplicationContext(RabbitConfig.class);
// 获取RabbitTemplate对象
final RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
// 接收消息
final Message message = rabbitTemplate.receive("queue.anno");
// 打印消息
System.out.println(new String(message.getBody(), message.getMessageProperties().getContentEncoding()));
// 关闭spring的上下文
context.close();
}
}
复制代码