Spring整合RabbitMQ简单示例

首先导入工程必须的依赖,基本的spring的包就不用说了,除了这些还需要导入一下2个,用于整合

<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>1.7.0.RELEASE</version>
</dependency>
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>4.0.0</version>
</dependency>

导入完成之后,首先编写spring整合rabbitmq的xml文件

spring-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:rabbit="http://www.springframework.org/schema/rabbit"
       xmlns:context="http://www.springframework.org/schema/context"  
       xsi:schemaLocation="http://www.springframework.org/schema/beans    
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd 
                        http://www.springframework.org/schema/context    
                        http://www.springframework.org/schema/context/spring-context-4.0.xsd 
				        http://www.springframework.org/schema/rabbit  
				        http://www.springframework.org/schema/rabbit/spring-rabbit-1.4.xsd"> 
    
    <!-- 定义连接工厂,用于创建连接等 -->
    <rabbit:connection-factory id="connectionFactory" username="guest" password="guest" host="localhost" port="5672"/>
    
    <!-- 定义admin,producer中的exchange,queue会自动的利用该admin自动在spring中生成 -->
    <rabbit:admin id="connAdmin" connection-factory="connectionFactory"/>
    
    <!-- 定义rabbitmq模板,用于接收以及发送消息 -->
    <rabbit:template id="amqpTemplate" connection-factory="connectionFactory" exchange="hjexchange"/>
    <rabbit:template id="amqpTemplates" connection-factory="connectionFactory" exchange="directExchange"/>
    
    <!-- 利用admin来定义队列,spring会自动根据下面的定义创建队列 
    	队列名	是否持久化	是否是排他队列	不使用的时候是否删除	declared-by ....(暂时还不太清楚,望大神指点)-->
    <rabbit:queue name="test1" auto-delete="false" declared-by="connAdmin" durable="true" exclusive="false" auto-declare="true"/>
    <rabbit:queue name="test2" auto-delete="false" declared-by="connAdmin" durable="true" exclusive="false" auto-declare="true"/>
    <rabbit:queue name="test3" auto-delete="false" declared-by="connAdmin" durable="true" exclusive="false" auto-declare="true"/>
	
	<!-- 定义Exchange,并且将队列与Exchange绑定,设定Routing Key -->
	<!-- name为Echange的name -->
	<rabbit:topic-exchange name="hjexchange" durable="true" declared-by="connAdmin" auto-delete="false">
		<rabbit:bindings>
			<!-- pattern 为Routing Key, queue为绑定的queue -->
			<rabbit:binding pattern="topicKey.#" queue="test1"></rabbit:binding>
			<rabbit:binding pattern="topicKeys.#" queue="test3"></rabbit:binding>
		</rabbit:bindings>
	</rabbit:topic-exchange>
	
	<!-- 同上 -->
	<rabbit:direct-exchange name="directExchange" durable="true" declared-by="connAdmin" auto-delete="false">
		<rabbit:bindings>
			<rabbit:binding key="directKeys" queue="test2"></rabbit:binding>
		</rabbit:bindings>
	</rabbit:direct-exchange>
	
	<!-- 定义消费者,消费消息 -->
	<bean id="directConsumer" class="com.demo.rabbitmq.consumer.DirectConsumer"></bean>
	<bean id="topicConsumer" class="com.demo.rabbitmq.consumer.TopicConsumer"></bean>
	<bean id="topicsConsumer" class="com.demo.rabbitmq.consumer.TopicsConsumer"></bean>
	
	<!--开启监听,也可以理解为: 
		将消费者与队列进行绑定,这样就会在,当队列有消息的时候,会由绑定的消费者来进行消费,
		也可以算是指定消费者来监听指定的队列.当有消息到达的时候,通知消费者进行消费 -->
	<rabbit:listener-container connection-factory="connectionFactory">
		<!-- 注入bean,指定队列 -->
		<rabbit:listener ref="topicConsumer" queues="test1"/>
		<rabbit:listener ref="directConsumer" queues="test2"/>
		<rabbit:listener ref="topicsConsumer" queues="test3"/>
	</rabbit:listener-container>
		
		
</beans>

该文件需要注意个地方,

xml头部声明当中,需要加入命名空间以及路径: http://www.springframework.org/schema/rabbit  

				http://www.springframework.org/schema/rabbit/spring-rabbit-1.4.xsd"> 

				xmlns:rabbit="http://www.springframework.org/schema/rabbit"

声明的用于发送消息以及接收数据的rabbitmq模板,在将exchange与queue绑定的时候,可以绑定多个同类型的exchange,但是不能将一个模板绑定不通类型的exchange.如果要绑定不通类型的exchange,需要不通的rabbitmq模板.

接着是spring-mvc.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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd 
    http://www.springframework.org/schema/mvc 
    http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd 
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-4.0.xsd 
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-4.0.xsd 
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-4.0.xsd ">
  
  
  <import resource="classpath:spring-rabbitmq.xml" />
  <!-- 注解映射,配置一些messageconverter -->
    <mvc:annotation-driven>
	  <mvc:message-converters register-defaults="true">
	    <bean class="org.springframework.http.converter.StringHttpMessageConverter">
	      <constructor-arg value="UTF-8" />
	    </bean>
	  </mvc:message-converters>
	</mvc:annotation-driven> 
	
	    <!-- 注解自动扫描 -->  
	<context:component-scan base-package="com.demo.rabbitmq.consumer" />
	
	 
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
        <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->  
        <property name="prefix" value="/WEB-INF/jsp/" />  
        <property name="suffix" value=".jsp" />
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
    </bean> 
    
</beans>

然后创建一个消息生产者

MessageProducer

package com.demo.rabbitmq.consumer;

import javax.annotation.Resource;

import org.apache.log4j.Logger;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.stereotype.Service;

@Service
public class MessageProducer {
	
	private Logger log = Logger.getLogger(MessageProducer.class);
	
	@Resource(name="amqpTemplate")
	private AmqpTemplate amqpTemplate;
	
	@Resource(name="amqpTemplates")
	private AmqpTemplate amqpTemplates;
	
	public void send(Object message) {
		log.info("发送消息为 : " + message);
		amqpTemplate.convertAndSend("topicKey.name", message);
		amqpTemplate.convertAndSend("topicKeys.name", message);
		amqpTemplates.convertAndSend("directKeys", message);
	}

}

定义消费者

topic类型的消费者2个,direct类型的一个

1,TopicConsumer

package com.demo.rabbitmq.consumer;

import org.apache.log4j.Logger;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;

public class TopicConsumer implements MessageListener{
	
	private Logger log = Logger.getLogger(TopicConsumer.class);
	
	@Override
	public void onMessage(Message message) {
		log.info("------> TopicConsumer 接收到的消息为 : " + message);
	}

}

2,TopicsConsumer

package com.demo.rabbitmq.consumer;

import org.apache.log4j.Logger;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;

public class TopicsConsumer implements MessageListener{
	
	private Logger log = Logger.getLogger(TopicsConsumer.class);
	
	@Override
	public void onMessage(Message message) {
		log.info("------> TopicsConsumer 接收到的消息为: " + message);
	}

}

3,DirectConsumer

package com.demo.rabbitmq.consumer;

import org.apache.log4j.Logger;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;

public class DirectConsumer implements MessageListener{
	
	private Logger log = Logger.getLogger(DirectConsumer.class);
	
	@Override
	public void onMessage(Message message) {
		log.info("------> DirectConsumer 接收到的消息为 : " + message);
	}

}

消费者必须实现MessageListener接口,重写onMessage方法,因为我们在spring-rabbitmq.xml文件当中配置了监听,所以当类所监听的队列当中有消息存在的时候,该方法会被调用.然后可以进行进一步的操作.

然后编写一个测试类

package springtest;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.demo.rabbitmq.consumer.MessageProducer;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:spring-mvc.xml"})
public class CastSpringRabbitmq {
	
	@Autowired
	private MessageProducer messageProducer;
	
	@Test
	public void test() throws InterruptedException {
		String message = "my name is sun wu kong";
		int a = 100;
		while(a-- > 0) {
			messageProducer.send(message);
			Thread.sleep(1000);
		}
		
	}
}

运行该项目,控制台输出如下:

以上就是spring整合rabbitmq简单示例.如果错误之处,请留言指出来,非常感谢.