Spring+ActiveMQ实现消息的交换

最新推荐文章于 2020-04-01 21:22:55 发布
最新推荐文章于 2020-04-01 21:22:55 发布
阅读量1k 收藏 1
点赞数
分类专栏： ActiveMQ

基础示例1

1.使用maven管理依赖包

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
< dependencies >
     < dependency >
         < groupId >junit</ groupId >
         < artifactId >junit</ artifactId >
         < version >4.12</ version >
         < scope >test</ scope >
     </ dependency >
     < dependency >
         < groupId >org.apache.activemq</ groupId >
         < artifactId >activemq-all</ artifactId >
         < version >5.11.0</ version >
     </ dependency >
     < dependency >
         < groupId >org.springframework</ groupId >
         < artifactId >spring-jms</ artifactId >
         < version >4.1.4.RELEASE</ version >
     </ dependency >
     < dependency >  
         < groupId >org.springframework</ groupId >  
         < artifactId >spring-test</ artifactId >  
         < version >4.1.4.RELEASE</ version >  
     </ dependency > 
</ dependencies >


2.队列消息的收发

2.1Spring配置文件
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<? xml  version = "1.0"  encoding = "UTF-8" ?>
< beans  xmlns = "http://www.springframework.org/schema/beans"
     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd">
 
     <!-- 配置JMS连接工厂 -->
     < bean  id = "connectionFactory"  class = "org.apache.activemq.ActiveMQConnectionFactory" >
         < property  name = "brokerURL"  value = "failover:(tcp://localhost:61616)"  />
     </ bean >
     
     <!-- 定义消息队列（Queue） -->
     < bean  id = "queueDestination"  class = "org.apache.activemq.command.ActiveMQQueue" >
         <!-- 设置消息队列的名字 -->
         < constructor-arg >
             < value >queue1</ value >
         </ constructor-arg >
     </ bean >
     
     <!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
     < bean  id = "jmsTemplate"  class = "org.springframework.jms.core.JmsTemplate" >
         < property  name = "connectionFactory"  ref = "connectionFactory"  />
         < property  name = "defaultDestination"  ref = "queueDestination"  />
         < property  name = "receiveTimeout"  value = "10000"  />
     </ bean >
     
     <!--queue消息生产者 -->
     < bean  id = "producerService"  class = "guo.examples.mq02.queue.ProducerServiceImpl" >
         < property  name = "jmsTemplate"  ref = "jmsTemplate" ></ property >
     </ bean >
 
     <!--queue消息消费者 -->
     < bean  id = "consumerService"  class = "guo.examples.mq02.queue.ConsumerServiceImpl" >
         < property  name = "jmsTemplate"  ref = "jmsTemplate" ></ property >
     </ bean >


2.2消息生产者代码

从下面的代码可以出，使用Spring JMS，可以减少重复代码（接口类ProducerService代码省略）。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package  guo.examples.mq02.queue;
 
import  javax.jms.Destination;
import  javax.jms.JMSException;
import  javax.jms.Message;
import  javax.jms.Session;
 
import  org.springframework.jms.core.JmsTemplate;
import  org.springframework.jms.core.MessageCreator;
 
public  class  ProducerServiceImpl  implements  ProducerService {
 
   private  JmsTemplate jmsTemplate;
   
   /**
    * 向指定队列发送消息
    */
   public  void  sendMessage(Destination destination,  final  String msg) {
     System.out.println( "向队列"  + destination.toString() +  "发送了消息------------"  + msg);
     jmsTemplate.send(destination,  new  MessageCreator() {
       public  Message createMessage(Session session)  throws  JMSException {
         return  session.createTextMessage(msg);
       }
     });
   }
 
/**
  * 向默认队列发送消息
  */
   public  void  sendMessage( final  String msg) {
     String destination =  jmsTemplate.getDefaultDestination().toString();
     System.out.println( "向队列"  +destination+  "发送了消息------------"  + msg);
     jmsTemplate.send( new  MessageCreator() {
       public  Message createMessage(Session session)  throws  JMSException {
         return  session.createTextMessage(msg);
       }
     });
 
   }
 
   public  void  setJmsTemplate(JmsTemplate jmsTemplate) {
     this .jmsTemplate = jmsTemplate;
   }
 
}
2.3消息消费者代码
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package  guo.examples.mq02.queue;
 
import  javax.jms.Destination;
import  javax.jms.JMSException;
import  javax.jms.TextMessage;
 
import  org.springframework.jms.core.JmsTemplate;
 
public  class  ConsumerServiceImpl  implements  ConsumerService {
 
     private  JmsTemplate jmsTemplate;
 
     /**
      * 接受消息
      */
     public  void  receive(Destination destination) {
         TextMessage tm = (TextMessage) jmsTemplate.receive(destination);
         try  {
             System.out.println( "从队列"  + destination.toString() +  "收到了消息：\t"
                     + tm.getText());
         }  catch  (JMSException e) {
             e.printStackTrace();
         }
     }
 
     public  void  setJmsTemplate(JmsTemplate jmsTemplate) {
         this .jmsTemplate = jmsTemplate;
     }
 
}


2.4队列消息监听

接受消息的时候，可以不用2.3节中的方式，Spring JMS同样提供了消息监听的模式，下面给出对应的配置和代码。

Spring配置

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<!-- 定义消息队列（Queue），我们监听一个新的队列，queue2 -->
     < bean  id = "queueDestination2"  class = "org.apache.activemq.command.ActiveMQQueue" >
         <!-- 设置消息队列的名字 -->
         < constructor-arg >
             < value >queue2</ value >
         </ constructor-arg >
     </ bean >
     
     <!-- 配置消息队列监听者（Queue），代码下面给出，只有一个onMessage方法 -->
     < bean  id = "queueMessageListener"  class = "guo.examples.mq02.queue.QueueMessageListener"  />
     
     <!-- 消息监听容器（Queue），配置连接工厂，监听的队列是queue2，监听器是上面定义的监听器 -->
     < bean  id = "jmsContainer"
         class = "org.springframework.jms.listener.DefaultMessageListenerContainer" >
         < property  name = "connectionFactory"  ref = "connectionFactory"  />
         < property  name = "destination"  ref = "queueDestination2"  />
         < property  name = "messageListener"  ref = "queueMessageListener"  />
     </ bean >

监听类代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package  guo.examples.mq02.queue;
 
import  javax.jms.JMSException;
import  javax.jms.Message;
import  javax.jms.MessageListener;
import  javax.jms.TextMessage;
 
public  class  QueueMessageListener  implements  MessageListener {
         //当收到消息时，自动调用该方法。
     public  void  onMessage(Message message) {
         TextMessage tm = (TextMessage) message;
         try  {
             System.out.println( "ConsumerMessageListener收到了文本消息：\t"
                     + tm.getText());
         }  catch  (JMSException e) {
             e.printStackTrace();
         }
     }
 
}



3.主题消息收发

     在使用Spring JMS的时候，主题（Topic）和队列消息的主要差异体现在JmsTemplate中"pubSubDomain"是否设置为True。如果为True，则是Topic；如果是false或者默认，则是queue。

?
1
< property  name = "pubSubDomain"  value = "true"  />


3.1Spring配置
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<!-- 定义消息主题（Topic） -->
     < bean  id = "topicDestination"  class = "org.apache.activemq.command.ActiveMQTopic" >
         < constructor-arg >
             < value >guo_topic</ value >
         </ constructor-arg >
     </ bean >
     <!-- 配置JMS模板（Topic），pubSubDomain="true"-->
     < bean  id = "topicJmsTemplate"  class = "org.springframework.jms.core.JmsTemplate" >
         < property  name = "connectionFactory"  ref = "connectionFactory"  />
         < property  name = "defaultDestination"  ref = "topicDestination"  />
         < property  name = "pubSubDomain"  value = "true"  />
         < property  name = "receiveTimeout"  value = "10000"  />
     </ bean >
     <!--topic消息发布者 -->
     < bean  id = "topicProvider"  class = "guo.examples.mq02.topic.TopicProvider" >
         < property  name = "topicJmsTemplate"  ref = "topicJmsTemplate" ></ property >
     </ bean >
     <!-- 消息主题监听者 和 主题监听容器 可以配置多个，即多个订阅者 -->
     <!-- 消息主题监听者(Topic) -->
     < bean  id = "topicMessageListener"  class = "guo.examples.mq02.topic.TopicMessageListener"  />
     <!-- 主题监听容器 （Topic） -->
     < bean  id = "topicJmsContainer"
         class = "org.springframework.jms.listener.DefaultMessageListenerContainer" >
         < property  name = "connectionFactory"  ref = "connectionFactory"  />
         < property  name = "destination"  ref = "topicDestination"  />
         < property  name = "messageListener"  ref = "topicMessageListener"  />
     </ bean >
3.2消息发布者
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package  guo.examples.mq02.topic;
 
import  javax.jms.Destination;
import  javax.jms.JMSException;
import  javax.jms.Message;
import  javax.jms.Session;
 
import  org.springframework.jms.core.JmsTemplate;
import  org.springframework.jms.core.MessageCreator;
 
public  class  TopicProvider {
 
     private  JmsTemplate topicJmsTemplate;
 
     /**
      * 向指定的topic发布消息
      * 
      * @param topic
      * @param msg
      */
     public  void  publish( final  Destination topic,  final  String msg) {
 
         topicJmsTemplate.send(topic,  new  MessageCreator() {
             public  Message createMessage(Session session)  throws  JMSException {
                 System.out.println( "topic name 是"  + topic.toString()
                         +  "，发布消息内容为:\t"  + msg);
                 return  session.createTextMessage(msg);
             }
         });
     }
 
     public  void  setTopicJmsTemplate(JmsTemplate topicJmsTemplate) {
         this .topicJmsTemplate = topicJmsTemplate;
     }
 
}
3.3消息订阅者（监听）
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package  guo.examples.mq02.topic;
 
import  javax.jms.JMSException;
import  javax.jms.Message;
import  javax.jms.MessageListener;
import  javax.jms.TextMessage;
/**
  *和队列监听的代码一样。
  */
public  class  TopicMessageListener  implements  MessageListener {
 
     public  void  onMessage(Message message) {
         TextMessage tm = (TextMessage) message;
         try  {
             System.out.println( "TopicMessageListener \t"  + tm.getText());
         }  catch  (JMSException e) {
             e.printStackTrace();
         }
     }
 
}


4.测试

4.1 测试代码
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
package  guo.examples.mq02;
 
import  javax.jms.Destination;
 
import  guo.examples.mq02.queue.ConsumerService;
import  guo.examples.mq02.queue.ProducerService;
import  guo.examples.mq02.topic.TopicProvider;
 
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.beans.factory.annotation.Qualifier;
import  org.springframework.test.context.ContextConfiguration;
import  org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
  * 测试Spring JMS
  * 
  * 1.测试生产者发送消息
  * 
  * 2. 测试消费者接受消息
  * 
  * 3. 测试消息监听
  * 
  * 4.测试主题监听
  *
  */
@RunWith (SpringJUnit4ClassRunner. class )
// ApplicationContext context = new
// ClassPathXmlApplicationContext("applicationContext.xml");
@ContextConfiguration ( "/applicationContext.xml" )
public  class  SpringJmsTest {
 
     /**
      * 队列名queue1
      */
     @Autowired
     private  Destination queueDestination;
 
     /**
      * 队列名queue2
      */
     @Autowired
     private  Destination queueDestination2;
 
     /**
      * 主题 guo_topic
      */
     @Autowired
     @Qualifier ( "topicDestination" )
     private  Destination topic;
 
     /**
      * 主题消息发布者
      */
     @Autowired
     private  TopicProvider topicProvider;
 
     /**
      * 队列消息生产者
      */
     @Autowired
     @Qualifier ( "producerService" )
     private  ProducerService producer;
 
     /**
      * 队列消息生产者
      */
     @Autowired
     @Qualifier ( "consumerService" )
     private  ConsumerService consumer;
 
     /**
      * 测试生产者向queue1发送消息
      */
     @Test
     public  void  testProduce() {
         String msg =  "Hello world!" ;
         producer.sendMessage(msg);
     }
 
     /**
      * 测试消费者从queue1接受消息
      */
     @Test
     public  void  testConsume() {
         consumer.receive(queueDestination);
     }
 
     /**
      * 测试消息监听
      * 
      * 1.生产者向队列queue2发送消息
      * 
      * 2.ConsumerMessageListener监听队列，并消费消息
      */
     @Test
     public  void  testSend() {
         producer.sendMessage(queueDestination2,  "Hello China~~~~~~~~~~~~~~~" );
     }
 
     /**
      * 测试主题监听
      * 
      * 1.生产者向主题发布消息
      * 
      * 2.ConsumerMessageListener监听主题，并消费消息
      */
     @Test
     public  void  testTopic()  throws  Exception {
         topicProvider.publish(topic,  "Hello T-To-Top-Topi-Topic!" );
     }
 
}
4.2 测试结果
?
1
2
3
4
5
6
topic name 是topic: //guo_topic ，发布消息内容为:    Hello T-To-Top-Topi-Topic!
TopicMessageListener   Hello T-To-Top-Topi-Topic!
向队列queue: //queue2 发送了消息------------Hello China~~~~~~~~~~~~~~~
ConsumerMessageListener收到了文本消息： Hello China~~~~~~~~~~~~~~~
向队列queue: //queue1 发送了消息------------Hello world!
从队列queue: //queue1 收到了消息： Hello world!

示例二：在Spring中整合JMS，同时结合Apache ActiveMQ来实现一个模拟聊天器的功能。

来务场景： A在输入端输入相应消息，消息会异步发送到ActiveMQ，B端会监听这个队列，如果有新数据入队，则接收此消息。

根据本实例，你可以通过简单的修改实现双人或多人自由聊天功能。

在本例中，使用Apache 的ActiveMQ来作为JMS中间件，这是一款相当成熟且开源的产品，得到了许多业内人士的好评。

开发采用Spirng Maven集成开发环境，所有的Jar包通过Maven进行管理 ， 如果对Spring Maven集成开发环境配置不熟悉的，可以先看这里：http://dreamforce.me/archives/87

新建一个ApplicationContext-JMS.xml

定义JMS连接工厂

Java代码  复制代码  收藏代码
  1. <bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
  2. <property name="brokerURL" value="tcp://localhost:61616" /> </bean>
[java]  view plain copy
  1. <bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">          
  2. <property name="brokerURL" value="tcp://localhost:61616" />     </bean>   

定义JMS Template

Java代码  复制代码  收藏代码
  1. <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
  2. <property name="connectionFactory" ref="jmsFactory" /> </bean>
[java]  view plain copy
  1. <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">           
  2. <property name="connectionFactory" ref="jmsFactory" />     </bean>   
定义消息目的地
Java代码  复制代码  收藏代码
  1. <bean id="dreamDestination" class="org.apache.activemq.command.ActiveMQQueue"> <constructor-arg index="0" value="dream.force" /> </bean>
[java]  view plain copy
  1. <bean id="dreamDestination" class="org.apache.activemq.command.ActiveMQQueue">         <constructor-arg index="0" value="dream.force" />     </bean>   
定义接收监听器
Java代码  复制代码  收藏代码
  1. <bean id="myTextListener" class="com.darcy.jms.TextListener">
  2. </bean>
[java]  view plain copy
  1. <bean id="myTextListener" class="com.darcy.jms.TextListener">       
  2. </bean>   

定义一个JMS话题
Java代码  复制代码  收藏代码
  1. <bean id="jmsTopic" class="org.apache.activemq.command.ActiveMQTopic"
  2. autowire="constructor">
  3. <constructor-arg value="STOCKS.Dreamforce.jms" />
  4. </bean>
[java]  view plain copy
  1. <bean id="jmsTopic" class="org.apache.activemq.command.ActiveMQTopic"  
  2.        autowire="constructor">   
  3.        <constructor-arg value="STOCKS.Dreamforce.jms" />   
  4.    </bean>  

定义消费者（接收端）
Java代码  复制代码  收藏代码
  1. <bean id="javaConsumer"
  2. class="org.springframework.jms.listener.DefaultMessageListenerContainer">
  3. <property name="connectionFactory" ref="jmsFactory" />
  4. <property name="destination" ref="chartDestination" />
  5. <property name="messageListener" ref="myTextListener" />
  6. </bean>
[java]  view plain copy
  1. <bean id="javaConsumer"  
  2.        class="org.springframework.jms.listener.DefaultMessageListenerContainer">   
  3.        <property name="connectionFactory" ref="jmsFactory" />   
  4.        <property name="destination" ref="chartDestination" />   
  5.        <property name="messageListener" ref="myTextListener" />   
  6.    </bean>   

定义发布者
Java代码  复制代码  收藏代码
  1. <bean id="publisher" class="com.darcy.jms.SpringPublish">
  2. <property name="template">
  3. <ref local="jmsTemplate" />
  4. </property>
  5. <property name="destinations" ref="chartDestination" />
  6. </bean>
[java]  view plain copy
  1. <bean id="publisher" class="com.darcy.jms.SpringPublish">          
  2.  <property name="template">              
  3.  <ref local="jmsTemplate" />           
  4. </property>           
  5. <property name="destinations" ref="chartDestination" />       
  6. </bean>   

JAVA核心代码一般由三个部分组成： 监听器（Listener），发布端(Publisher), 消息生产者(Creator)

监听器：

Java代码  复制代码  收藏代码
  1. package com.darcy.jms;
  3. import java.util.Date;
  4. import javax.jms.JMSException;
  5. import javax.jms.Message;
  6. import javax.jms.MessageListener;
  7. import javax.jms.TextMessage;
  8. import org.apache.activemq.command.ActiveMQMapMessage;
  10. public class TextListener implements MessageListener{
  12. public void onMessage(Message message) {
  13. ActiveMQMapMessage msg = null;
  14. System.out.println("ONMessage-----------------"+message.toString());
  16. try {
  18. if (message instanceof ActiveMQMapMessage) {
  19. msg = (ActiveMQMapMessage) message;
  20. String sentDate = msg.getString("date");
  21. String reMessage = msg.getString("message");
  22. int sentCount = msg.getInt("count");
  23. System.out.println("-------------New Message Arrival-----------"+new Date());
  24. System.out.println("It's "+sentCount+" time From Darcy: "+reMessage+" ---Send time :" + sentDate);
  25. }
  26. } catch (JMSException e) {
  27. System.out.println("JMSException in onMessage(): " + e.toString());
  28. } catch (Throwable t) {
  29. System.out.println("Exception in onMessage():" + t.getMessage());
  30. }
  31. }
  32. }
[java]  view plain copy
  1. package com.darcy.jms;  
  2.    
  3. import java.util.Date;   
  4. import javax.jms.JMSException;  
  5. import javax.jms.Message;   
  6. import javax.jms.MessageListener;   
  7. import javax.jms.TextMessage;   
  8. import org.apache.activemq.command.ActiveMQMapMessage;    
  9.   
  10. public class TextListener implements MessageListener{         
  11.   
  12.    public void onMessage(Message message) {           
  13.     ActiveMQMapMessage msg = null;           
  14.     System.out.println("ONMessage-----------------"+message.toString());           
  15.   
  16.     try {               
  17.   
  18.         if (message instanceof ActiveMQMapMessage) {                   
  19.             msg = (ActiveMQMapMessage) message;                   
  20.             String sentDate = msg.getString("date");                   
  21.             String reMessage  = msg.getString("message");                   
  22.             int sentCount  = msg.getInt("count");                   
  23.             System.out.println("-------------New Message Arrival-----------"+new Date());   
  24.             System.out.println("It's "+sentCount+" time From Darcy: "+reMessage+"   ---Send time :" + sentDate);               
  25.         }           
  26.     } catch (JMSException e) {               
  27.         System.out.println("JMSException in onMessage(): " + e.toString());           
  28.     } catch (Throwable t) {               
  29.         System.out.println("Exception in onMessage():" + t.getMessage());           
  30.     }       
  31.    }     
  32. }   

发布端：

Java代码  复制代码  收藏代码
  1. package com.darcy.jms;
  2. import java.util.HashMap;
  3. import java.util.Scanner;
  4. import javax.jms.Destination;
  5. import org.springframework.jms.core.JmsTemplate;
  7. public class SpringPublish {
  9. private JmsTemplate template;
  10. private Destination[] destinations;
  12. public void chart(){
  13. boolean chart = true;
  14. int count = 0;
  16. while(chart){
  17. count ++;
  18. Scanner cin=new Scanner(System.in);
  19. System.out.println("输入聊天内容，输入N停止聊天");
  20. String text=cin.nextLine();
  21. if(text.equals("N")) {
  22. chart = false;
  23. }
  24. System.out.println("我："+text);
  25. sendChartMessage(count,text);
  26. }
  27. }
  29. protected void sendChartMessage(int count , String strMessage) {
  30. MyMessageCreator creator = new MyMessageCreator(count,strMessage);
  31. template.send(destinations[0], creator);
  32. }
  34. public JmsTemplate getTemplate() {
  35. return template;
  36. }
  38. public void setTemplate(JmsTemplate template) {
  39. this.template = template;
  40. }
  42. public Destination[] getDestinations() {
  43. return destinations;
  44. }
  46. public void setDestinations(Destination[] destinations) {
  47. this.destinations = destinations;
  48. }
  50. }
[java]  view plain copy
  1. package com.darcy.jms;     
  2. import java.util.HashMap;   
  3. import java.util.Scanner;   
  4. import javax.jms.Destination;  
  5. import org.springframework.jms.core.JmsTemplate;     
  6.   
  7. public class SpringPublish {         
  8.   
  9. private JmsTemplate template;       
  10. private Destination[] destinations;   
  11.         
  12. public void chart(){          
  13.      boolean chart = true;          
  14.      int count = 0;           
  15.   
  16.     while(chart){               
  17.         count ++;               
  18.         Scanner cin=new Scanner(System.in);   
  19.         System.out.println("输入聊天内容，输入N停止聊天");  
  20.                 String text=cin.nextLine();  
  21.             if(text.equals("N")) {  
  22.                      chart = false;  
  23.                 }               
  24.         System.out.println("我："+text);  
  25.         sendChartMessage(count,text);           
  26.     }         
  27. }       
  28.   
  29. protected void sendChartMessage(int count , String strMessage) {  
  30.          MyMessageCreator creator = new MyMessageCreator(count,strMessage);  
  31.          template.send(destinations[0], creator);  
  32. }         
  33.   
  34. public JmsTemplate getTemplate() {           
  35.     return template;       
  36. }         
  37.   
  38. public void setTemplate(JmsTemplate template) {   
  39.         this.template = template;       
  40. }         
  41.   
  42. public Destination[] getDestinations() {   
  43.         return destinations;       
  44. }         
  45.   
  46. public void setDestinations(Destination[] destinations) {   
  47.         this.destinations = destinations;       
  48. }     
  49.   
  50. }   

消息生产者：

Java代码  复制代码  收藏代码
  1. package com.darcy.jms; import java.util.Date;
  3. import javax.jms.JMSException;
  5. import javax.jms.MapMessage;
  6. import javax.jms.Message;
  7. import javax.jms.Session;
  8. import org.springframework.jms.core.MessageCreator;
  10. public class MyMessageCreator implements MessageCreator {
  11. private int msgNo;
  12. private String strMessage;
  14. public MyMessageCreator(int no,String paramMessage) {
  15. this.msgNo = no;
  16. this.strMessage = paramMessage;
  17. }
  19. public Message createMessage(Session session) throws JMSException {
  20. MapMessage message = session.createMapMessage();
  21. message.setString("date", new Date().toString());
  22. message.setString("message", strMessage);
  23. message.setInt("count", msgNo);
  24. return message;
  25. }
  27. }
[java]  view plain copy
  1. package com.darcy.jms; import java.util.Date;     
  2.   
  3. import javax.jms.JMSException;   
  4.   
  5. import javax.jms.MapMessage;   
  6. import javax.jms.Message;  
  7. import javax.jms.Session;   
  8. import org.springframework.jms.core.MessageCreator;   
  9.   
  10. public class MyMessageCreator implements MessageCreator {       
  11. private int msgNo;       
  12. private String strMessage;         
  13.   
  14. public MyMessageCreator(int no,String paramMessage) {          
  15.     this.msgNo = no;           
  16.     this.strMessage = paramMessage;       
  17. }         
  18.   
  19. public Message createMessage(Session session) throws JMSException {           
  20.     MapMessage message = session.createMapMessage();           
  21.     message.setString("date", new Date().toString());           
  22.     message.setString("message", strMessage);           
  23.     message.setInt("count", msgNo);           
  24.     return message;       
  25. }   
  26.   
  27. }   

完成上述的代码，聊天器的功能已经实现了，现在开始写一个TestCase来运行以上的代码

本例的TestCase用例是基于Spring的集成测试环境，同时你要保证将applicationContext-jms.xml纳入Spring的管理。

如果还不清楚如何搭建Spring集成测试环境的童鞋，请移步到这里 搭建Spring集成测试环境

Java代码  复制代码  收藏代码
  1. package test.JSM;
  2. import com.darcy.common.BaseTestCase;
  3. import com.darcy.jms.SpringPublish;
  4. import org.springframework.jms.listener.DefaultMessageListenerContainer;
  6. public class SpringJmsTestMain extends BaseTestCase {
  8. private SpringPublish publisher;
  9. private DefaultMessageListenerContainer javaConsumer;
  11. public SpringPublish getPublisher(){
  12. return publisher;
  13. }
  15. public void setPublisher(SpringPublish publisher){
  16. this.publisher = publisher;
  17. }
  19. public void testJMS(){
  20. javaConsumer.start();
  21. publisher.chart();
  22. }
  24. public void setJavaConsumer(DefaultMessageListenerContainer javaConsumer) {
  25. this.javaConsumer = javaConsumer;
  26. }
  28. public DefaultMessageListenerContainer getJavaConsumer() {
  29. return javaConsumer;
  30. }
  32. }
[java]  view plain copy
  1. package test.JSM;   
  2. import com.darcy.common.BaseTestCase;   
  3. import com.darcy.jms.SpringPublish;   
  4. import org.springframework.jms.listener.DefaultMessageListenerContainer;     
  5.   
  6. public class SpringJmsTestMain extends BaseTestCase {    
  7.        
  8. private SpringPublish publisher;       
  9. private DefaultMessageListenerContainer javaConsumer;  
  10.        
  11. public SpringPublish getPublisher(){           
  12.     return publisher;       
  13. }       
  14.   
  15. public void setPublisher(SpringPublish publisher){           
  16.     this.publisher = publisher;       
  17. }       
  18.   
  19. public void testJMS(){            
  20.     javaConsumer.start();            
  21.     publisher.chart();         
  22. }       
  23.   
  24. public void setJavaConsumer(DefaultMessageListenerContainer javaConsumer) {    
  25.        this.javaConsumer = javaConsumer;       
  26. }       
  27.   
  28. public DefaultMessageListenerContainer getJavaConsumer() {           
  29.     return javaConsumer;       
  30. }   
  31.   
  32. }   
至此代码书写已经完成。但是在运行之前我们需要启动Apache ActionMQ，以使JAVA端能访问到JMS组件。

下载地址：http://activemq.apache.org/download.html

解压后，进入Conf目录，打开ActiveMQ.xml编辑

Java代码  复制代码  收藏代码
  1. <transportConnectors>
  2. <transportConnector name="openwire" uri="tcp://localhost:61616"/>
  3. </transportConnectors>
[java]  view plain copy
  1. <transportConnectors>   
  2.       <transportConnector name="openwire" uri="tcp://localhost:61616"/>   
  3.   </transportConnectors>   
上面的代码是JMS通信地址，这里需要和Spring配置地址一致

启动ActionMQ, 运行bin目录里的ActionMQ.bat.

同时你也可以进入WEB Console, 默认访问地址为：http://localhost:8161/admin/

activeMQ console

运行TestCase,开始聊天吧~~~嘿嘿，不可上面的代码只支持单人聊天模式，接受端只是从JMS获取消息并输出。

附录：

Maven相关Denpendency（JMS

Java代码  复制代码  收藏代码
  1. <dependency>
  2. <groupId>org.springframework</groupId>
  3. <artifactId>spring-jms</artifactId>
  4. <version>3.1.1.RELEASE</version>
  5. </dependency>
  7. <dependency>
  8. <groupId>org.apache.geronimo.specs</groupId>
  9. <artifactId>geronimo-jms_1.1_spec</artifactId>
  10. <version>1.1</version>
  11. </dependency>
[java]  view plain copy
  1. <dependency>   
  2.     <groupId>org.springframework</groupId>   
  3.     <artifactId>spring-jms</artifactId>   
  4.     <version>3.1.1.RELEASE</version>   
  5. </dependency>   
  6.   
  7. <dependency>   
  8.     <groupId>org.apache.geronimo.specs</groupId>   
  9.     <artifactId>geronimo-jms_1.1_spec</artifactId>   
  10.     <version>1.1</version>   
  11. </dependency>   

由于各种原因，javax.jms包不能从maven默认的repository上下载，所以请使用这个dependency,当然jboss也提供了这个jms包的下载，请自由选择。

小飞鹤
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java消息服务(第2版)
10-16
· 使用消息驱动的beans在Enterprise JavaBeans(EJB)中实现消息传递 · 使用JMS时结合RESTful应用程序和Spring应用程序框架 消息传递是一个强大的范例，可以更容易地使企业应用程序的不同部分分离。《Java消息服务...
MQ、JMS以及ActiveMQ 关系的理解
dengyiyu5280的博客
01-08 316
MQ、JMS以及ActiveMQ 关系的理解 1、ms的一个标准或者说是一个协议.通常用于企业级应用的消息传递.主要有topic消息(1对多),queue消息(1对1). 2、activemq是一个jms的实现,apache出的. 3、另外还其它的实现jboss ... MQ简介： MQ 全称为Me...
activemq的几种基本通信方式总结
点缀星辰
07-07 1089
简介      在前面一篇文章里讨论过几种应用系统集成的方式，发现实际上面向消息队列的集成方案算是一个总体比较合理的选择。这里，我们先针对具体的一个消息队列Activemq的基本通信方式进行探讨。activemq是JMS消息通信规范的一个实现。总的来说，消息规范里面定义最常见的几种消息通信模式主要有发布-订阅、点对点这两种。另外，通过结合这些模式的具体应用，我们在处理某些应用场景的时候也衍生...
ActiveMQ--配置端口
fox_lht的专栏
02-10 1万+
配置端口 端口配置选项 一般最常用的URI是连接到代理的端口URI，通常为TCP或VM端口。 要注意空格：所有的URI都是基于java.net.URI类，它并不允许使用空格。所以，如果你使用failover:或者static:URI，在逗号内不要留有空白。   虚拟机端口 虚拟机端口允许客户可以在虚拟机内部互相连接而不用使用其上的网络连接。这个连接不是socket连接，而是直接使用方法
基于JTT809协议的车辆信息交换平台架构方案（上级平台）
04-06
809协议网关应用采用mina+spring架构，独立于其他应用，主要负责维护的tcp双通道链接、上行以及下行消息的解码、编码。接入网关采用json消息通过MQ消息（支持ActiveMQ）队列与业务平台进行交互，能够无缝接入各种...
基于JTT808协议的车辆监控系统架构方案
03-08
同时网关采用json消息与平台进行交互，支持jms消息队列以及redis消息队列，默认使用ActiveMQ，能够无缝接入各种不同异构系统。 2、上行消息处理应用采用spring框架，采用基于事件驱动的设计模式处理上行消息，支持...
蚂蚁课堂(每特学院)第一期-Java高端培训视频教程
08-07
教程目录: ├─0001-多线程快速入门.zip ├─0002-多线程之间实现同步.zip ├─0003--多线程之间通讯.zip ├─0004--Java并发编程.zip ├─0005--数据交换格式与SpringIOC底层实现.zip ├─0006--自定义注解与设计...
spring使用activeMQ实现消息发送
01-09
结合博客提供spring+activeMQ的demo源码
ActiveMQ实战——实现一个简易版的聊天室
03-29
NULL 博文链接：https://shhyuhan.iteye.com/blog/1280477
信息交换平台异步通信解决方案 Active MQ
Nothing
08-01 761
信息交换平台异步通信解决方案 Active MQ   一、现在信息交换平台现状及存在的问题     信息交换平台目前主要是通过HTTP/HTTPS来接受来自各种客户端post 的数据，接受到数据后，读取 post 请求的数据流，解析为 xml，通过翻译转换后派发给注册的业务处理插件，处理完毕后将结果以httpResponse 的方式返回给客户端，客户端读取返回结果，判断请求是否成功的被 服务
activemq 数据传送过程
farmwang的专栏
12-29 442
失败过程 成功过程
ActiveMQ讯息传送机制以及ACK机制
热门推荐
Jacob
12-30 5万+
ActiveMQ消息传送机制以及ACK机制详解     AcitveMQ是作为一种消息存储和分发组件，涉及到client与broker端数据交互的方方面面，它不仅要担保消息的存储安全性，还要提供额外的手段来确保消息的分发是可靠的。   一. ActiveMQ消息传送机制     Producer客户端使用来发送消息的， Consumer客户端用来消费消息；它们的协同
ActiveMQ
戴林峰的博客
04-01 271
分布式事务用一句话来说就是在并发的环境下如何解决数据一致性的问题 1.XA协议下的两段式提交 XA协议-> 资源管理器(DB)与事务管理器的接口标准, 在xa协议下,提交一个事务需要两个阶段 阶段一:预备提交 阶段二:提交 基于xa协议的进阶版 tcc 每次提交之前先执行try接口测试数据库是否是通的,数据库都是通的之后再去进行提交操作 需要在业务层实现try confirm接口...
Spring和ActiveMQ集成实现队列消息以及PUB/SUB模型
xwq911的专栏
05-20 1152
前言：本文是基于Spring和ActiveMQ的一个示例文章，包括了Point-To-Point的异步队列消息和PUB/SUB（发布/订阅）模型，只是做了比较简单的实现，无任何业务方面的东西，作为一个入门教程。 适合对象：希望学习ActiveMQ的朋友，以及利用Spring将ActiveMQ集成到系统中 所需知识：Springframework，JMS，如果不清楚可以看看http:
spring+activemq实战之配置监听多队列实现不同队列消息消费
whs_321的博客
07-19 1万+
spring+activemq实战之配置监听多队列实现不同队列消息消费
混合动力无人船上位机.zip
最新发布
05-05
无人机最强算法源码，易于部署和学习交流使用
SpringBoot+ActiveMq+MQTT实现消息的发送和接收
06-01
好的，我可以为您简单介绍一下SpringBoot集成ActiveMQ和MQTT实现消息的发送和接收。 首先，您需要在SpringBoot项目中添加ActiveMQ和MQTT的依赖，可以在pom.xml文件中添加如下代码： ```xml <!-- ActiveMQ --> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值