zoukankan html css js c++ java

基于spring集成rabbit项目搭建。需要进行xml配置

1. 生产者工程

pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.atguigu</groupId>
	<artifactId>spring-rabbitmq-producer</artifactId>
	<version>1.0-SNAPSHOT</version>

	<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>
	 <build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.8.0</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

rabbitmq的配置文件参数 resourcesproperties abbitmq.properties

rabbitmq.host=192.168.137.130
rabbitmq.port=5672
rabbitmq.username=admin
rabbitmq.password=123456
rabbitmq.virtual-host=/

spring整合rabbitmq的配置文件 resourcesspringspring-rabbitmq.xml

<?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,名字为："",路由键为队列的名称
	-->
	<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_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"/>

	<rabbit:topic-exchange id="spring_topic_exchange" name="spring_topic_exchange" auto-declare="true">
		<rabbit:bindings>
			<rabbit:binding pattern="atguigu.*" queue="spring_topic_queue_star"/>
			<rabbit:binding pattern="atguigu.#" queue="spring_topic_queue_well"/>
			<rabbit:binding pattern="guigu.#" queue="spring_topic_queue_well2"/>
		</rabbit:bindings>
	</rabbit:topic-exchange>

	<!--定义rabbitTemplate对象操作可以在代码中方便发送消息-->
	<rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>
</beans>

生产者代码

@RunWith(SpringRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq.xml")
public class ProducerTest {

	@Autowired
	private RabbitTemplate rabbitTemplate;

	/**
	 * 只发队列消息
	 * 默认交换机类型为 direct
	 * 交换机的名称为空,路由键为队列的名称
	 */
	@Test
	public void queueTest(){
		//路由键与队列同名
		rabbitTemplate.convertAndSend("spring_queue", "只发队列spring_queue的消息。");
	}

	/**
	 * 发送广播
	 * 交换机类型为 fanout
	 * 绑定到该交换机的所有队列都能够收到消息
	 */
	@Test
	public void fanoutTest(){
		/**
		 * 参数1：交换机名称
		 * 参数2：路由键名（广播设置为空）
		 * 参数3：发送的消息内容
		 */
		rabbitTemplate.convertAndSend("spring_fanout_exchange", "", "发送到spring_fanout_exchange交换机的广播消息");
	}

	/**
	 * 通配符
	 * 交换机类型为 topic
	 * 匹配路由键的通配符,*表示一个单词,#表示多个单词
	 * 绑定到该交换机的匹配队列能够收到对应消息
	 */
	@Test
	public void topicTest(){
		/**
		 * 参数1：交换机名称
		 * 参数2：路由键名
		 * 参数3：发送的消息内容
		 */
		rabbitTemplate.convertAndSend("spring_topic_exchange", "atguigu.bj", "发送到spring_topic_exchange交换机atguigu.bj的消息");
		rabbitTemplate.convertAndSend("spring_topic_exchange", "atguigu.bj.1", "发送到spring_topic_exchange交换机atguigu.bj.1的消息");
		rabbitTemplate.convertAndSend("spring_topic_exchange", "atguigu.bj.2", "发送到spring_topic_exchange交换机atguigu.bj.2的消息");
		rabbitTemplate.convertAndSend("spring_topic_exchange", "guigu.cn", "发送到spring_topic_exchange交换机guigu.cn的消息");
	}
}

2. 消费者工程

pom依赖除了项目名称与生产者不同。依赖全部一样。
配置文件也相同。

spring整合rabbitmq配置文件 resourcesspringspring-rabbitmq.xml

<?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}"/>
	<!-- 消费者，就是一个监听器程序-->
	<bean id="springQueueListener" class="com.atguigu.rabbitmq.listener.SpringQueueListener"/>
	<bean id="fanoutListener1" class="com.atguigu.rabbitmq.listener.FanoutListener1"/>
	<bean id="fanoutListener2" class="com.atguigu.rabbitmq.listener.FanoutListener2"/>
	<bean id="topicListenerStar" class="com.atguigu.rabbitmq.listener.TopicListenerStar"/>
	<bean id="topicListenerWell" class="com.atguigu.rabbitmq.listener.TopicListenerWell"/>
	<bean id="topicListenerWell2" class="com.atguigu.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>

消费者代码：实现MessageListener接口，重写OnMessage方法

public class SpringQueueListener implements MessageListener {
	public void onMessage(Message message) {
		try {
			String msg = new String(message.getBody(), "utf-8");

			System.out.printf("接收路由名称为：%s,路由键为：%s,队列名为：%s的消息：%s 
",
					message.getMessageProperties().getReceivedExchange(),
					message.getMessageProperties().getReceivedRoutingKey(),
					message.getMessageProperties().getConsumerQueue(),
					msg);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
//测试用例，开启tomcat，将配置文件中的bean初始化到ioc容器中。
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq.xml")
public class ConsumerTest {

	@Test
	public void test1(){
		boolean flag = true;
		while (flag){

		}
	}
}

//广播监听器1
public class FanoutListener1 implements MessageListener {
	public void onMessage(Message message) {
		try {
			String msg = new String(message.getBody(), "utf-8");

			System.out.printf("广播监听器1：接收路由名称为：%s,路由键为：%s,队列名为：%s的消息：%s 
",
					message.getMessageProperties().getReceivedExchange(),
					message.getMessageProperties().getReceivedRoutingKey(),
					message.getMessageProperties().getConsumerQueue(),
					msg);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

//广播监听器2
public class FanoutListener2 implements MessageListener {
	public void onMessage(Message message) {
		try {
			String msg = new String(message.getBody(), "utf-8");

			System.out.printf("广播监听器2：接收路由名称为：%s,路由键为：%s,队列名为：%s的消息：%s 
",
					message.getMessageProperties().getReceivedExchange(),
					message.getMessageProperties().getReceivedRoutingKey(),
					message.getMessageProperties().getConsumerQueue(),
					msg);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

//星号通配符监听器
public class TopicListenerStar implements MessageListener {
	public void onMessage(Message message) {
		try {
			String msg = new String(message.getBody(), "utf-8");

			System.out.printf("通配符*监听器：接收路由名称为：%s,路由键为：%s,队列名为：%s的消息：%s 
",
					message.getMessageProperties().getReceivedExchange(),
					message.getMessageProperties().getReceivedRoutingKey(),
					message.getMessageProperties().getConsumerQueue(),
					msg);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

//井号通配符监听器1
public class TopicListenerWell implements MessageListener {
	public void onMessage(Message message) {
		try {
			String msg = new String(message.getBody(), "utf-8");

			System.out.printf("通配符#监听器：接收路由名称为：%s,路由键为：%s,队列名为：%s的消息：%s 
",
					message.getMessageProperties().getReceivedExchange(),
					message.getMessageProperties().getReceivedRoutingKey(),
					message.getMessageProperties().getConsumerQueue(),
					msg);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

//井号通配符监听器2
public class TopicListenerWell2 implements MessageListener {
	public void onMessage(Message message) {
		try {
			String msg = new String(message.getBody(), "utf-8");

			System.out.printf("通配符#监听器2：接收路由名称为：%s,路由键为：%s,队列名为：%s的消息：%s 
",
					message.getMessageProperties().getReceivedExchange(),
					message.getMessageProperties().getReceivedRoutingKey(),
					message.getMessageProperties().getConsumerQueue(),
					msg);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

查看全文

相关阅读:
57-java 开发环境配置，mysql解压版安装
 56-MyBatis关联映射之一对多映射
 55-mybatis dao 和映射xml
54-jquery发送请求 json 转化等
 58-wxPython 嵌入html页面
 57-2015-第六届蓝桥杯国赛 java B组真题与解析
 【读书笔记】Effective Modern Cpp(二)
【读书笔记】Effective Modern Cpp(一)
【剑指offer】汇总
 【剑指offer】序列化二叉树

原文地址：https://www.cnblogs.com/rbwbear/p/15557823.html