Bluemix结合RabbitMq实现消息发送与接收实例

非常感谢  http://blog.csdn.net/evankaka/article/details/50682197

什么是RabbitMq？

      MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消 息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。

什么是Bluemix？

        BlueMix 是 IBM 基于 Cloud Foundry 的开放云架构实现，使您能够快速创建、部署和管理云应用程序。

      本文实现了在Bluemix上绑定rabbitMq,然后在本地运行项目来进行消息的发送和接收。

     本文实例访问：http://javahelloworld2.mybluemix.net/

    本文工程下载：http://download.csdn.net/detail/evankaka/9427970

BluxMix账号注册：https://apps.admin.ibmcloud.com/manage/trial/bluemix.html?cm_mmc=CMDeveloperGCG-_-Bluemix-_-CSDN-_-onlineeventQ2

一、Bluemix项目创建 

1、新建一个Bluemix的web工程

如何创建工程可看基于IBM Bluemix部署Java Web项目实战演练

2、添加RabbitMQ服务

选择CloudMQP

记下以下数据，工程中会用到

进入工程，打开如下页面

此时如果该服务已绑定项目的话，就会弹出如下界面，这个界面说明了如何在客户端来配置RabbitMq的参数，使用客户端能将消息发布的Bluemix这个类似信息中心的地方。如果没有出现此页面，请回去绑定服务到工程！

二、本地运行发布和获取消息

本文是基于Maven工程的。所以，先建一个Maven项目工程。最后整个工程目录如下：

1、添加Jar包依赖

[html] view plain copy

 

1. <properties>  
2.         <!-- spring版本号 -->  
3.         <spring.version>3.2.8.RELEASE</spring.version>  
4.         <!-- log4j日志文件管理包版本 -->  
5.         <slf4j.version>1.6.6</slf4j.version>  
6.         <log4j.version>1.2.12</log4j.version>  
7.         <!-- junit版本号 -->  
8.         <junit.version>4.10</junit.version>  
9.     </properties>  
10.   
11.     <dependencies>  
12.         <!-- 添加Spring依赖 -->  
13.         <dependency>  
14.             <groupId>org.springframework</groupId>  
15.             <artifactId>spring-core</artifactId>  
16.             <version>${spring.version}</version>  
17.         </dependency>  
18.         <dependency>  
19.             <groupId>org.springframework</groupId>  
20.             <artifactId>spring-webmvc</artifactId>  
21.             <version>${spring.version}</version>  
22.         </dependency>  
23.         <dependency>  
24.             <groupId>org.springframework</groupId>  
25.             <artifactId>spring-context</artifactId>  
26.             <version>${spring.version}</version>  
27.         </dependency>  
28.         <dependency>  
29.             <groupId>org.springframework</groupId>  
30.             <artifactId>spring-context-support</artifactId>  
31.             <version>${spring.version}</version>  
32.         </dependency>  
33.         <dependency>  
34.             <groupId>org.springframework</groupId>  
35.             <artifactId>spring-aop</artifactId>  
36.             <version>${spring.version}</version>  
37.         </dependency>  
38.         <dependency>  
39.             <groupId>org.springframework</groupId>  
40.             <artifactId>spring-aspects</artifactId>  
41.             <version>${spring.version}</version>  
42.         </dependency>  
43.         <dependency>  
44.             <groupId>org.springframework</groupId>  
45.             <artifactId>spring-tx</artifactId>  
46.             <version>${spring.version}</version>  
47.         </dependency>  
48.         <dependency>  
49.             <groupId>org.springframework</groupId>  
50.             <artifactId>spring-jdbc</artifactId>  
51.             <version>${spring.version}</version>  
52.         </dependency>  
53.         <dependency>  
54.             <groupId>org.springframework</groupId>  
55.             <artifactId>spring-web</artifactId>  
56.             <version>${spring.version}</version>  
57.         </dependency>  
58.   
59.         <!--单元测试依赖 -->  
60.         <dependency>  
61.             <groupId>junit</groupId>  
62.             <artifactId>junit</artifactId>  
63.             <version>${junit.version}</version>  
64.             <scope>test</scope>  
65.         </dependency>  
66.   
67.         <!-- 日志文件管理包 -->  
68.         <!-- log start -->  
69.         <dependency>  
70.             <groupId>log4j</groupId>  
71.             <artifactId>log4j</artifactId>  
72.             <version>${log4j.version}</version>  
73.         </dependency>  
74.         <dependency>  
75.             <groupId>org.slf4j</groupId>  
76.             <artifactId>slf4j-api</artifactId>  
77.             <version>${slf4j.version}</version>  
78.         </dependency>  
79.         <dependency>  
80.             <groupId>org.slf4j</groupId>  
81.             <artifactId>slf4j-log4j12</artifactId>  
82.             <version>${slf4j.version}</version>  
83.         </dependency>  
84.         <!-- log end -->  
85.   
86.         <!--spring单元测试依赖 -->  
87.         <dependency>  
88.             <groupId>org.springframework</groupId>  
89.             <artifactId>spring-test</artifactId>  
90.             <version>${spring.version}</version>  
91.             <scope>test</scope>  
92.         </dependency>  
93.   
94.         <!--rabbitmq依赖 -->  
95.         <dependency>  
96.             <groupId>org.springframework.amqp</groupId>  
97.             <artifactId>spring-rabbit</artifactId>  
98.             <version>1.4.5.RELEASE</version>  
99.         </dependency>  
100. <!--         <dependency> -->  
101. <!--             <groupId>com.rabbitmq</groupId> -->  
102. <!--             <artifactId>amqp-client</artifactId> -->  
103. <!--             <version>3.3.4</version> -->  
104. <!--         </dependency> -->  
105.         <dependency>  
106.             <groupId>javax.validation</groupId>  
107.             <artifactId>validation-api</artifactId>  
108.             <version>1.1.0.Final</version>  
109.         </dependency>  

2、消息发送者

MessageProducer.Java内容如下：

[java] view plain copy

 

1. package com.lin.producer;  
2.   
3. import javax.annotation.Resource;  
4.   
5. import org.slf4j.Logger;  
6. import org.slf4j.LoggerFactory;  
7. import org.springframework.amqp.core.AmqpTemplate;  
8. import org.springframework.stereotype.Service;  
9.   
10. /** 
11.  * 功能概要：消息产生,提交到队列中去 
12.  *  
13.  * @author linbingwen 
14.  * @since  2016年1月15日  
15.  */  
16. @Service  
17. public class MessageProducer {  
18.       
19.     private Logger logger = LoggerFactory.getLogger(MessageProducer.class);  
20.   
21.     @Resource  
22.     private AmqpTemplate amqpTemplate;  
23.   
24.     public void sendMessage(Object message){  
25.       logger.info("to send message:{}",message);  
26.       amqpTemplate.convertAndSend("queueTestKey",message);  
27.     }  
28. }  

3、消息接收者

MessageConsumer.java内容如下：

[java] view plain copy

 

1. package com.lin.consumer;  
2.   
3. import org.slf4j.Logger;  
4. import org.slf4j.LoggerFactory;  
5. import org.springframework.amqp.core.Message;  
6. import org.springframework.amqp.core.MessageListener;  
7.   
8. /** 
9.  * 功能概要：消费接收 
10.  *  
11.  * @author linbingwen 
12.  * @since  2016年1月15日  
13.  */  
14. public class MessageConsumer implements MessageListener {  
15.       
16.     private Logger logger = LoggerFactory.getLogger(MessageConsumer.class);  
17.   
18.     @Override  
19.     public void onMessage(Message message) {  
20.         logger.info("receive message:{}",message.toString());  
21.     }  
22.   
23. }  

4、定义消息服务中心

这里笔者在rabbitmq.xml将消息生产和消息者都写在一个文件当中，您也可以分开写。配置基本一样。

[html] view plain copy

 

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"  
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
5.      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
6.      http://www.springframework.org/schema/beans  
7.      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
8.      http://www.springframework.org/schema/rabbit  
9.      http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd">  
10.     <!--配置connection-factory，指定连接rabbit server参数 -->  
11.     <rabbit:connection-factory id="connectionFactory"  
12.         username="zqwocdmu" password="DRR6tF7DCuEq7ugHwlBP8A9zTwu6jI8D" host = "white-swan.rmq.cloudamqp.com" virtual-host="zqwocdmu" />  
13.           
14.     <!--定义rabbit template用于数据的接收和发送 -->  
15.     <rabbit:template id="amqpTemplate"  connection-factory="connectionFactory"   
16.         exchange="exchangeTest" />  
17.           
18.     <!--通过指定下面的admin信息，当前producer中的exchange和queue会在rabbitmq服务器上自动生成 -->  
19.     <rabbit:admin connection-factory="connectionFactory" />  
20.   
21.     <!--定义queue -->  
22.     <rabbit:queue name="queueTest" durable="true" auto-delete="false" exclusive="false" />  
23.   
24.     <!-- 定义direct exchange，绑定queueTest -->  
25.     <rabbit:direct-exchange name="exchangeTest" durable="true" auto-delete="false">  
26.         <rabbit:bindings>  
27.             <rabbit:binding queue="queueTest" key="queueTestKey"></rabbit:binding>  
28.         </rabbit:bindings>  
29.     </rabbit:direct-exchange>  
30.       
31.     <!-- 消息接收者 -->  
32.     <bean id="messageReceiver" class="com.lin.consumer.MessageConsumer"></bean>  
33.       
34.     <!-- queue litener  观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象-->  
35.     <rabbit:listener-container connection-factory="connectionFactory">  
36.              <rabbit:listener queues="queueTest" ref="messageReceiver"/>  
37.     </rabbit:listener-container>  
38.       
39. </beans>  

其中配置内容和Bluemix上的对应关系如下：

5、Spring中加载rabbitmq.xml的配置内容

整个application.xml内容如下：

[html] view plain copy

 

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
4.     xmlns:p="http://www.springframework.org/schema/p"  
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
6.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">  
7.   
8.   
9.     <import resource="classpath*:rabbitmq.xml" />  
10.       
11.       
12.     <!-- 扫描指定package下所有带有如@controller,@services,@resource,@ods并把所注释的注册为Spring Beans -->  
13.     <context:component-scan base-package="com.lin.consumer,com.lin.producer" />  
14.       
15.   
16.           
17.     <!-- 激活annotation功能 -->  
18.     <context:annotation-config />  
19.     <!-- 激活annotation功能 -->  
20.     <context:spring-configured />  
21.   
22.       
23.       
24. </beans>  

6、测试消息服务

这里笔者简单写了一个不断发送消息和一个不断接收消息的测试

[java] view plain copy

 

1. package com.lin;  
2.   
3. import javax.annotation.Resource;  
4.   
5. import org.junit.Before;  
6. import org.junit.Test;  
7. import org.slf4j.Logger;  
8. import org.slf4j.LoggerFactory;  
9. import org.springframework.amqp.core.AmqpTemplate;  
10. import org.springframework.context.ApplicationContext;  
11. import org.springframework.context.support.ClassPathXmlApplicationContext;  
12. import org.springframework.retry.backoff.Sleeper;  
13.   
14. import com.lin.producer.MessageProducer;  
15.   
16. /** 
17.  * 功能概要： 
18.  *  
19.  * @author linbingwen 
20.  * @since  2016年1月15日  
21.  */  
22. public class MessageTest  {  
23.       
24.     private Logger logger = LoggerFactory.getLogger(MessageTest.class);  
25.       
26.     private ApplicationContext context = null;  
27.       
28.     @Before  
29.     public void setUp() throws Exception {  
30.         context = new ClassPathXmlApplicationContext("application.xml");  
31.     }  
32.   
33.     @Test  
34.     public void should_send_a_amq_message() throws Exception {  
35.        MessageProducer messageProducer = (MessageProducer) context.getBean("messageProducer");  
36.        int a = Integer.MAX_VALUE;  
37.        while (a > 0) {  
38.            messageProducer.sendMessage("Hello, I am amq sender num :" + a--);  
39.            try {  
40.                //暂停一下，好让消息消费者去取消息打印出来  
41.                Thread.sleep(1000);  
42.            } catch (InterruptedException e) {  
43.                e.printStackTrace();   
44.            }  
45.       
46.        }  
47.     }  
48. }  

来看看Eclipse上运行的结果：

可以看到，消息不断的产生和消费。

当然，您也可以进入到RabbitMq的消息服务中心，点击如下：

点击进去如下显示，这里可以看到消息队列、当前的连接数

queueTest就是上面的代码中配置的队列

还可以看到其消息生产和消费的速度等。

三、web项目中来使用rabbitMq

1、定义一个页面用来发消息和接消息：

[html] view plain copy

 

1. <!DOCTYPE html>  
2. <html>  
3. <head>  
4. <meta charset="UTF-8">  
5. <script src="<%=request.getContextPath()%>/static/js/jquery-2.1.4.min.js"></script>  
6. </head>  
7. <body>  
8. <h2>Hello World!</h2>  
9. <div>  
10. <textarea rows="10" cols="40" id = "msg"></textarea>  
11. </div>  
12. <div>  
13. <button id = "sendMsg">发送消息</button>  
14. <button id = "recvMsg">接收消息</button>  
15. </div>  
16. </body>  
17. <script type="text/javascript">  
18. $(document).ready(function(){  
19.       
20.     //获取当前项目的路径  
21.     var urlRootContext = (function () {  
22.         var strPath = window.document.location.pathname;  
23.         var postPath = strPath.substring(0, strPath.substr(1).indexOf('/') + 1);  
24.         return postPath;  
25.     })();  
26.       
27.       $("#sendMsg").click(function(){  
28.           var msg = $('#msg').val();  
29.           if (msg == '') {  
30.             alert('请输入消息内容 ');  
31.             return false;  
32.           }  
33.             
34.           $.ajax( {    
35.                 url:urlRootContext + '/sendMsg',// 跳转到 action    
36.                 data:{    
37.                          message :msg ,    
38.                 },    
39.                 type:'POST',    
40.                 async:false,  
41.                 dataType:'json',    
42.                 success:function(data) {    
43.                         console.log(data);  
44.                         alert("发送信息成功！");    
45.                           
46.                  },    
47.                  error: function(xhr, type, exception) {  
48.                      alert("服务器异常，请稍候重试!");  
49.                      console.log(xhr);  
50.                      console.log(type);  
51.                      console.log(exception);  
52.                  }  
53.             });  
54.       });  
55.         
56.         
57.       $("#recvMsg").click(function(){  
58.           $.ajax( {    
59.                 url:urlRootContext + '/revcMsg',// 跳转到 action    
60.                 type:'POST',    
61.                 async:false,  
62.                 dataType:'json',    
63.                 success:function(data) {    
64.                         console.log(data);  
65.                         alert("接收一条消息成功！,消息为：" + data.string);    
66.                           
67.                  },    
68.                  error: function(xhr, type, exception) {  
69.                      alert("服务器异常，请稍候重试!");  
70.                      console.log(xhr);  
71.                      console.log(type);  
72.                      console.log(exception);  
73.                  }  
74.             });  
75.       });  
76.         
77.         
78.     });  
79.   
80. </script>  
81. </html>  

其中，发消息和接消息都是通过ajax的方式来传递到Controller层中，然后返回json数据到前台。

页面效果如下：

2、Controller层：

这里需要注意的是消息生产者是的数据服务中心是使用rabbitmq.xml里的配置，但是消息消费都这里是用Java代码来实现的。

[java] view plain copy

 

1. package com.lin.controller;  
2.   
3.   
4. import java.io.IOException;  
5. import java.util.HashMap;  
6. import java.util.Map;  
7.   
8. import javax.annotation.Resource;  
9.   
10. import net.sf.json.JSONObject;  
11.   
12. import org.slf4j.Logger;  
13. import org.slf4j.LoggerFactory;  
14. import org.springframework.stereotype.Controller;  
15. import org.springframework.web.bind.annotation.RequestMapping;  
16. import org.springframework.web.bind.annotation.ResponseBody;  
17.   
18. import com.lin.consumer.MessageConsumer;  
19. import com.lin.producer.MessageProducer;  
20. import com.rabbitmq.client.Channel;  
21. import com.rabbitmq.client.Connection;  
22. import com.rabbitmq.client.ConnectionFactory;  
23. import com.rabbitmq.client.ConsumerCancelledException;  
24. import com.rabbitmq.client.QueueingConsumer;  
25. import com.rabbitmq.client.ShutdownSignalException;  
26. import com.rabbitmq.client.QueueingConsumer.Delivery;  
27.   
28. /** 
29.  * 功能概要：UserController 
30.  *  
31.  * @author linbingwen 
32.  * @since  2015年9月28日  
33.  */  
34. @Controller  
35. public class MessageController  {  
36.       
37.     @Resource  
38.     private MessageProducer messageProducer;  
39.       
40.     private Logger logger = LoggerFactory.getLogger(getClass());  
41.       
42.     /** 
43.      * 显示首页 
44.      * @author linbingwen 
45.      * @since  2015年10月23日  
46.      * @return 
47.      */  
48.     @RequestMapping("/test")    
49.     public String message(){  
50.         logger.info("open message.jsp");  
51.         return "message";  
52.     }  
53.       
54.     /** 
55.      * 用来发送消息 
56.      * @author linbingwen 
57.      * @since  2016年2月19日  
58.      * @param message 
59.      * @return 
60.      */  
61.     @RequestMapping("/sendMsg")  
62.     @ResponseBody  
63.     public String sendMsg(String message) {  
64.         logger.info("to send message:{}",message);  
65.         messageProducer.sendMessage(message);  
66.         Map<String,Object> map = new HashMap<String,Object>();  
67.         map.put("flag", true);  
68.         JSONObject jsonObject =  JSONObject.fromObject(map);  
69.         return jsonObject.toString();  
70.     }  
71.       
72.       
73.     /** 
74.      * 用来接收消息 
75.      * @author linbingwen 
76.      * @since  2016年2月19日  
77.      * @param message 
78.      * @return 
79.      */  
80.     @RequestMapping("/revcMsg")  
81.     @ResponseBody  
82.     public String revcMsg() {  
83.         String string = getMsg();  
84.         if (string != null) {  
85.               
86.         } else {  
87.             string = "null";  
88.         }  
89.         Map<String,Object> map = new HashMap<String,Object>();  
90.         map.put("string", string);  
91.         JSONObject jsonObject =  JSONObject.fromObject(map);  
92.         return jsonObject.toString();  
93.     }  
94.       
95.       
96.     public  String getMsg() {  
97.         ConnectionFactory connFac = new ConnectionFactory() ;  
98.           
99.         connFac.setHost("white-swan.rmq.cloudamqp.com");  
100.         connFac.setPassword("DRR6tF7DCuEq7ugHwlBP8A9zTwu6jI8D");  
101.         connFac.setUsername("zqwocdmu");  
102.         connFac.setVirtualHost("zqwocdmu");  
103.         Connection conn = null;  
104.       
105.           
106.         try {  
107.             conn = connFac.newConnection();  
108.         } catch (IOException e) {  
109.             e.printStackTrace();  
110.         }  
111.           
112.         Channel channel = null;  
113.         try {  
114.             channel = conn.createChannel();  
115.         } catch (IOException e) {  
116.             e.printStackTrace();  
117.         }  
118.           
119.         String queueName = "queueTest";  
120.           
121.         try {  
122.             channel.queueDeclare(queueName, true, false, false, null) ;  
123.         } catch (IOException e) {  
124.             e.printStackTrace();  
125.         }  
126.           
127.         //配置好获取消息的方式  
128.         QueueingConsumer consumer = new QueueingConsumer(channel) ;  
129.         try {  
130.             channel.basicConsume(queueName, true, consumer) ;  
131.         } catch (IOException e) {  
132.             e.printStackTrace();  
133.         }  
134.           
135. //      //循环获取消息  
136. //      while(true){  
137.               
138.             //获取消息，如果没有消息，这一步将会一直阻塞  
139.             Delivery delivery = null;  
140.             try {  
141.                 delivery = consumer.nextDelivery();  
142.             } catch (ShutdownSignalException e) {  
143.                 e.printStackTrace();  
144.             } catch (ConsumerCancelledException e) {  
145.                 e.printStackTrace();  
146.             } catch (InterruptedException e) {  
147.                 e.printStackTrace();  
148.             }  
149.               
150.             String msg = new String(delivery.getBody()) ;    
151.               
152.             System.out.println("received message[" + msg + "] from " + queueName);  
153. //      }  
154.             try {  
155.                 conn.close();                 
156.             } catch (IOException e) {  
157.                 e.printStackTrace();  
158.             }  
159.      return  msg;  
160.     }  
161.       
162.       
163. }  

3、rabbitMq.xml内容如下：

和上面的工程相比，去掉了消息监听器。而把它放在Controller层中来使用。就是上面的getMsg（）代码。

[html] view plain copy

 

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"  
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
5.      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
6.      http://www.springframework.org/schema/beans  
7.      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
8.      http://www.springframework.org/schema/rabbit  
9.      http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd">  
10.     <!--配置connection-factory，指定连接rabbit server参数 -->  
11. <!--     <rabbit:connection-factory id="connectionFactory" -->  
12. <!--         username="asdf" password="123456" host="10.75.4.25" port="5672" /> -->  
13. <rabbit:connection-factory id="connectionFactory"    
14.         username="zqwocdmu" password="DRR6tF7DCuEq7ugHwlBP8A9zTwu6jI8D" host = "white-swan.rmq.cloudamqp.com" virtual-host="zqwocdmu" />  
15.           
16.     <!--定义rabbit template用于数据的接收和发送 -->  
17.     <rabbit:template id="amqpTemplate"  connection-factory="connectionFactory"   
18.         exchange="exchangeTest" />  
19.           
20.     <!--通过指定下面的admin信息，当前producer中的exchange和queue会在rabbitmq服务器上自动生成 -->  
21.     <rabbit:admin connection-factory="connectionFactory" />  
22.   
23.     <!--定义queue -->  
24.     <rabbit:queue name="queueTest" durable="true" auto-delete="false" exclusive="false" />  
25.   
26.     <!-- 定义direct exchange，绑定queueTest -->  
27.     <rabbit:direct-exchange name="exchangeTest" durable="true" auto-delete="false">  
28.         <rabbit:bindings>  
29.             <rabbit:binding queue="queueTest" key="queueTestKey"></rabbit:binding>  
30.         </rabbit:bindings>  
31.     </rabbit:direct-exchange>  
32.       
33.     <!-- 消息接收者 -->  
34. <!--     <bean id="messageReceiver" class="com.lin.consumer.MessageConsumer"></bean> -->  
35.       
36.     <!-- queue litener  观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象-->  
37. <!--     <rabbit:listener-container connection-factory="connectionFactory"> -->  
38. <!--              <rabbit:listener queues="queueTest" ref="messageReceiver"/> -->  
39. <!--     </rabbit:listener-container> -->  
40.       
41. </beans>  

这是给远程的Bluemix上绑定的服务中心发消息，

这是获取消息

当然，也可以看日志：

最后一步打war包，然后上传到Bluemix中心即可：

发送消息

接收消息：

（这里要注意一定要先发送消息，要不接收消息会一直阻塞会去，整个页面会卡死，而且接收消息的过程非常缓慢，请耐心等待！）

  本文实例访问：http://javahelloworld2.mybluemix.net/

   本文工程下载：http://download.csdn.net/detail/evankaka/9427970