RabbitMQ与SpringMVC集成并实现发送消息和接收消息（持久化）方案二

   RabbitMQ的大约的介绍，上一篇已经有介绍了，这篇不介绍，直接描述RabbitMQ与SpringMVC集成并实现发送消息和接收消息（持久化）。

 使用了Spring-rabbit 发送消息和接收消息，我们使用的Maven来管理Jar包，在Maven的pom.xml文件中引入jar包

   

[java]  view plain  copy

1. <span style="font-size:18px;">  <dependency>  
2.         <groupId>org.springframework.amqp</groupId>  
3.         <artifactId>spring-rabbit</artifactId>  
4.          <version>1.3.6.RELEASE</version>  
5.     </dependency></span>  

  1.实现生产者

     第一步：是要设置调用安装RabbitMQ的IP、端口等

                配置一个global.properties文件

           

   第二步：通过SpringMVC把global.properties文件读进来

[java]  view plain  copy

1. <span style="font-size:18px;"><!-- 注入属性文件 -->    
2.     <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">    
3.         <property name="locations">    
4.             <list>    
5.                 <value>classpath:global.properties</value>    
6.             </list>    
7.         </property>    
8.     </bean>  </span>  

  

第三步：配置 RabbitMQ服务器连接、创建rabbitTemplate 消息模板类等，在SpringMVC的配置文件加入下面这些

<bean id="rmqProducer2" class="cn.test.spring.rabbitmq.RmqProducer"></bean>

[java]  view plain  copy

1. <span style="font-size:18px;"> <!-- 创建连接类 -->    
2.      <bean id="connectionFactory"  class="org.springframework.amqp.rabbit.connection.CachingConnectionFactory">    
3.         <constructor-arg value="localhost" />    
4.         <property name="username" value="${rmq.manager.user}" />    
5.         <property name="password" value="${rmq.manager.password}" />   
6.         <property name="host" value="${rmq.ip}" />   
7.         <property name="port" value="${rmq.port}" />   
8.     </bean>    
9.        
10.     <bean id="rabbitAdmin"  class="org.springframework.amqp.rabbit.core.RabbitAdmin">    
11.         <constructor-arg ref="connectionFactory" />    
12.     </bean>    
13.      <!-- 创建rabbitTemplate 消息模板类 -->    
14.     <bean id="rabbitTemplate"  class="org.springframework.amqp.rabbit.core.RabbitTemplate">    
15.         <constructor-arg ref="connectionFactory"></constructor-arg>    
16.     </bean>  </span>  

第四步：实现消息类实体和发送消息

   类实体

[java]  view plain  copy

1. <span style="font-size:18px;">/** 
2.  * 消息 
3.  * 
4.  */  
5. public class RabbitMessage implements Serializable  
6. {  
7.     private static final long serialVersionUID = -6487839157908352120L;  
8.       
9.     private Class<?>[] paramTypes;//参数类型  
10.     private String exchange;//交换器  
11.       
12.     private Object[] params;  
13.       
14.     private String routeKey;//路由key  
15.       
16.     public RabbitMessage(){}  
17.   
18.     public RabbitMessage(String exchange,String routeKey,Object...params)  
19.     {  
20.         this.params=params;       
21.         this.exchange=exchange;  
22.         this.routeKey=routeKey;  
23.     }  
24.       
25.     @SuppressWarnings("rawtypes")  
26.     public RabbitMessage(String exchange,String routeKey,String methodName,Object...params)  
27.     {  
28.         this.params=params;       
29.         this.exchange=exchange;  
30.         this.routeKey=routeKey;  
31.         int len=params.length;  
32.         Class[] clazzArray=new Class[len];  
33.         for(int i=0;i<len;i++)  
34.             clazzArray[i]=params[i].getClass();  
35.         this.paramTypes=clazzArray;  
36.     }  
37.       
38.     public byte[] getSerialBytes()  
39.     {  
40.         byte[] res=new byte[0];  
41.         ByteArrayOutputStream baos=new ByteArrayOutputStream();  
42.         ObjectOutputStream oos;  
43.         try {  
44.             oos = new ObjectOutputStream(baos);  
45.             oos.writeObject(this);  
46.             oos.close();  
47.             res=baos.toByteArray();  
48.         } catch (IOException e) {  
49.             e.printStackTrace();  
50.         }         
51.         return res;  
52.     }  
53.   
54.       
55.       
56.       
57.     public String getRouteKey() {  
58.         return routeKey;  
59.     }  
60.   
61.   
62.   
63.     public String getExchange() {  
64.         return exchange;  
65.     }  
66.   
67.     public void setExchange(String exchange) {  
68.         this.exchange = exchange;  
69.     }  
70.   
71.     public void setRouteKey(String routeKey) {  
72.         this.routeKey = routeKey;  
73.     }  
74.   
75.   
76.   
77.     public Class<?>[] getParamTypes() {  
78.         return paramTypes;  
79.     }  
80.   
81.     public Object[] getParams() {  
82.         return params;  
83.     }  
84.   
85.       
86.       
87.       
88. }  
89. </span>  

   发送消息

   

[java]  view plain  copy

1. <span style="font-size:18px;">/** 
2.  * 生产着 
3.  * 
4.  */  
5.   
6. public class RmqProducer  
7. {  
8.       
9.     @Resource  
10.     private RabbitTemplate rabbitTemplate;  
11.       
12.     /** 
13.      * 发送信息 
14.      * @param msg 
15.      */  
16.     public void sendMessage(RabbitMessage  msg)  
17.     {  
18.         try {  
19.             System.out.println(rabbitTemplate.getConnectionFactory().getHost());  
20.             System.out.println(rabbitTemplate.getConnectionFactory().getPort());  
21.             //发送信息  
22.             rabbitTemplate.convertAndSend(msg.getExchange(), msg.getRouteKey(), msg);  
23.            
24.         } catch (Exception e) {  
25.         }  
26.           
27.           
28.     }  
29.       
30. }</span>  

 说明：

   1. rabbitTemplate.convertAndSend(msg.getExchange(), msg.getRouteKey(), msg);

      源代码中的send调用的方法，一些发送消息帮我们实现好了。

         
    2.上面的代码实现没申明交换器和队列，RabbitMQ不知交换器和队列他们的绑定关系，如果RabbitMQ管理器上没有对应的交换器和队列是不会新建的和关联的，需要手动关联。

          
     我们也可以用代码申明：

            rabbitAdmin要申明：eclareExchange方法  参数是交换器                                                       

                                BindingBuilder.bind(queue).to(directExchange).with(queueName);//将queue绑定到exchange 

                                rabbitAdmin.declareBinding(binding);//声明绑定关系

                  源代码有这些方法：

                     

                         

          这样就可以实现交换器和队列的绑定关系

           交换器我们可以申明为持久化，还有使用完不会自动删除

             TopicExchange 参数的说明：name是交换器名称，durable:true 是持久化  autoDelete：false使用完不删除

               源代码：

                   

              

           队列也可以申明为持久化

            

            

  第五步：实现测试类

      

[java]  view plain  copy

1. <span style="font-size:18px;">@Resource  
2.     private RmqProducer rmqProducer2;  
3.       
4.     @Test  
5.     public void test() throws IOException  
6.     {  
7.   
8.   
9.             String exchange="testExchange";交换器  
10.             String routeKey="testQueue";//队列  
11.             String methodName="test";//调用的方法  
12.             //参数  
13.             Map<String,Object> param=new HashMap<String, Object>();  
14.             param.put("data","hello");  
15.               
16.             RabbitMessage  msg=new RabbitMessage(exchange,routeKey, methodName, param);  
17.             //发送消息  
18.             rmqProducer2.sendMessage(msg);  
19.               
20.     }</span>  

   结果：RabbitMQ有一条消息

          

    

  2.消费者

    第一步：RabbitMQ服务器连接这些在生产者那边已经介绍了，这边就不介绍了，我们要配置 RabbitMQ服务器连接、创建rabbitTemplate 消息模板类、消息转换器、消息转换器监听器等，在SpringMVC的配置文件加入下面这些

   

[java]  view plain  copy

1. <span style="font-size:18px;"> <!-- 创建连接类 -->    
2.      <bean id="connectionFactory"  class="org.springframework.amqp.rabbit.connection.CachingConnectionFactory">    
3.         <constructor-arg value="localhost" />    
4.         <property name="username" value="${rmq.manager.user}" />    
5.         <property name="password" value="${rmq.manager.password}" />   
6.         <property name="host" value="${rmq.ip}" />   
7.         <property name="port" value="${rmq.port}" />   
8.     </bean>    
9.        
10.     <bean id="rabbitAdmin"  class="org.springframework.amqp.rabbit.core.RabbitAdmin">    
11.         <constructor-arg ref="connectionFactory" />    
12.     </bean>    
13.      <!-- 创建rabbitTemplate 消息模板类 -->    
14.     <bean id="rabbitTemplate"  class="org.springframework.amqp.rabbit.core.RabbitTemplate">    
15.         <constructor-arg ref="connectionFactory"></constructor-arg>    
16.     </bean>    
17.       
18.       
19.      <!-- 创建消息转换器为SimpleMessageConverter -->    
20.     <bean id="serializerMessageConverter"  class="org.springframework.amqp.support.converter.SimpleMessageConverter"></bean>   
21.       
22.    
23.      <!-- 设置持久化的队列 -->    
24.     <bean id="queue"  class="org.springframework.amqp.core.Queue">   
25.         <constructor-arg index="0" value="testQueue"></constructor-arg>    
26.         <constructor-arg index="1" value="true"></constructor-arg>    
27.         <constructor-arg index="2" value="false"></constructor-arg>    
28.         <constructor-arg index="3" value="false"></constructor-arg>    
29.     </bean>   
30.       
31.      
32.      <!--创建交换器的类型 并持久化-->    
33.     <bean id="topicExchange"  class="org.springframework.amqp.core.TopicExchange">  
34.         <constructor-arg index="0" value="testExchange"></constructor-arg>    
35.         <constructor-arg index="1" value="true"></constructor-arg>    
36.         <constructor-arg index="2" value="false"></constructor-arg>   
37.     </bean>  
38.       
39.     <util:map id="arguments">           
40.     </util:map>  
41.       
42.     
43.     <!-- 绑定交换器、队列 -->    
44.     <bean id="binding"  class="org.springframework.amqp.core.Binding">    
45.         <constructor-arg index="0" value="testQueue"></constructor-arg>   
46.         <constructor-arg index="1" value="QUEUE"></constructor-arg>    
47.         <constructor-arg index="2" value="testExchange"></constructor-arg>  
48.         <constructor-arg index="3" value="testQueue"></constructor-arg>    
49.         <constructor-arg index="4" value="#{arguments}"></constructor-arg>     
50.     </bean>    
51.       
52.       
53.     <!-- 用于接收消息的处理类 -->    
54.     <bean id="rmqConsumer"   class="cn.test.spring.rabbitmq.RmqConsumer"></bean>    
55.       
56.     <bean id="messageListenerAdapter"  class="org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter">    
57.         <constructor-arg ref="rmqConsumer" />    
58.         <property name="defaultListenerMethod" value="rmqProducerMessage"></property>    
59.         <property name="messageConverter" ref="serializerMessageConverter"></property>    
60.     </bean>    
61.       
62.     <!-- 用于消息的监听的容器类SimpleMessageListenerContainer,监听队列  queues可以传多个-->    
63.     <bean id="listenerContainer"  class="org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer">    
64.         <property name="queues" ref="queue"></property>    
65.         <property name="connectionFactory" ref="connectionFactory"></property>    
66.         <property name="messageListener" ref="messageListenerAdapter"></property>    
67.     </bean>    
68.     </span>  

说明：

   1.org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer中的queues可以传入多个队列

     

   2.org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter

     有哪个消费者适配器来处理 ，参数defaultListenerMethod是默认调用方法来处理消息。

   3.交换器和队列的持久化在生产者有介绍过了。

   4.org.springframework.amqp.core.Binding这个类的绑定，在SpringMVC配置文件中配置时，

    DestinationType这个参数要注意点

    源代码：

      

  第二步：处理消息

    

[java]  view plain  copy

1. <span style="font-size:18px;">/** 
2.  * 消费者 
3.  * 
4.  */  
5. public class RmqConsumer    
6. {  
7.     public void rmqProducerMessage(Object object){  
8.           
9.         RabbitMessage rabbitMessage=(RabbitMessage) object;  
10.           
11.         System.out.println(rabbitMessage.getExchange());  
12.         System.out.println(rabbitMessage.getRouteKey());  
13.         System.out.println(rabbitMessage.getParams().toString());  
14.           
15.           
16.     }  
17.       
18.       
19.       
20.       
21.               
22.       
23. }</span>  

   在启动过程中会报这样的错误，可能是你的交换器和队列没配置好