基础示例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连接工厂
- <bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
- <property name="brokerURL" value="tcp://localhost:61616" /> </bean>
- <bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
- <property name="brokerURL" value="tcp://localhost:61616" /> </bean>
定义JMS Template
- <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
- <property name="connectionFactory" ref="jmsFactory" /> </bean>
- <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
- <property name="connectionFactory" ref="jmsFactory" /> </bean>
- <bean id="dreamDestination" class="org.apache.activemq.command.ActiveMQQueue"> <constructor-arg index="0" value="dream.force" /> </bean>
- <bean id="dreamDestination" class="org.apache.activemq.command.ActiveMQQueue"> <constructor-arg index="0" value="dream.force" /> </bean>
- <bean id="myTextListener" class="com.darcy.jms.TextListener">
- </bean>
- <bean id="myTextListener" class="com.darcy.jms.TextListener">
- </bean>
- <bean id="jmsTopic" class="org.apache.activemq.command.ActiveMQTopic"
- autowire="constructor">
- <constructor-arg value="STOCKS.Dreamforce.jms" />
- </bean>
- <bean id="jmsTopic" class="org.apache.activemq.command.ActiveMQTopic"
- autowire="constructor">
- <constructor-arg value="STOCKS.Dreamforce.jms" />
- </bean>
- <bean id="javaConsumer"
- class="org.springframework.jms.listener.DefaultMessageListenerContainer">
- <property name="connectionFactory" ref="jmsFactory" />
- <property name="destination" ref="chartDestination" />
- <property name="messageListener" ref="myTextListener" />
- </bean>
- <bean id="javaConsumer"
- class="org.springframework.jms.listener.DefaultMessageListenerContainer">
- <property name="connectionFactory" ref="jmsFactory" />
- <property name="destination" ref="chartDestination" />
- <property name="messageListener" ref="myTextListener" />
- </bean>
- <bean id="publisher" class="com.darcy.jms.SpringPublish">
- <property name="template">
- <ref local="jmsTemplate" />
- </property>
- <property name="destinations" ref="chartDestination" />
- </bean>
- <bean id="publisher" class="com.darcy.jms.SpringPublish">
- <property name="template">
- <ref local="jmsTemplate" />
- </property>
- <property name="destinations" ref="chartDestination" />
- </bean>
JAVA核心代码一般由三个部分组成: 监听器(Listener),发布端(Publisher), 消息生产者(Creator)
监听器:
- package com.darcy.jms;
- import java.util.Date;
- import javax.jms.JMSException;
- import javax.jms.Message;
- import javax.jms.MessageListener;
- import javax.jms.TextMessage;
- import org.apache.activemq.command.ActiveMQMapMessage;
- public class TextListener implements MessageListener{
- public void onMessage(Message message) {
- ActiveMQMapMessage msg = null;
- System.out.println("ONMessage-----------------"+message.toString());
- try {
- if (message instanceof ActiveMQMapMessage) {
- msg = (ActiveMQMapMessage) message;
- String sentDate = msg.getString("date");
- String reMessage = msg.getString("message");
- int sentCount = msg.getInt("count");
- System.out.println("-------------New Message Arrival-----------"+new Date());
- System.out.println("It's "+sentCount+" time From Darcy: "+reMessage+" ---Send time :" + sentDate);
- }
- } catch (JMSException e) {
- System.out.println("JMSException in onMessage(): " + e.toString());
- } catch (Throwable t) {
- System.out.println("Exception in onMessage():" + t.getMessage());
- }
- }
- }
- package com.darcy.jms;
- import java.util.Date;
- import javax.jms.JMSException;
- import javax.jms.Message;
- import javax.jms.MessageListener;
- import javax.jms.TextMessage;
- import org.apache.activemq.command.ActiveMQMapMessage;
- public class TextListener implements MessageListener{
- public void onMessage(Message message) {
- ActiveMQMapMessage msg = null;
- System.out.println("ONMessage-----------------"+message.toString());
- try {
- if (message instanceof ActiveMQMapMessage) {
- msg = (ActiveMQMapMessage) message;
- String sentDate = msg.getString("date");
- String reMessage = msg.getString("message");
- int sentCount = msg.getInt("count");
- System.out.println("-------------New Message Arrival-----------"+new Date());
- System.out.println("It's "+sentCount+" time From Darcy: "+reMessage+" ---Send time :" + sentDate);
- }
- } catch (JMSException e) {
- System.out.println("JMSException in onMessage(): " + e.toString());
- } catch (Throwable t) {
- System.out.println("Exception in onMessage():" + t.getMessage());
- }
- }
- }
发布端:
- package com.darcy.jms;
- import java.util.HashMap;
- import java.util.Scanner;
- import javax.jms.Destination;
- import org.springframework.jms.core.JmsTemplate;
- public class SpringPublish {
- private JmsTemplate template;
- private Destination[] destinations;
- public void chart(){
- boolean chart = true;
- int count = 0;
- while(chart){
- count ++;
- Scanner cin=new Scanner(System.in);
- System.out.println("输入聊天内容,输入N停止聊天");
- String text=cin.nextLine();
- if(text.equals("N")) {
- chart = false;
- }
- System.out.println("我:"+text);
- sendChartMessage(count,text);
- }
- }
- protected void sendChartMessage(int count , String strMessage) {
- MyMessageCreator creator = new MyMessageCreator(count,strMessage);
- template.send(destinations[0], creator);
- }
- public JmsTemplate getTemplate() {
- return template;
- }
- public void setTemplate(JmsTemplate template) {
- this.template = template;
- }
- public Destination[] getDestinations() {
- return destinations;
- }
- public void setDestinations(Destination[] destinations) {
- this.destinations = destinations;
- }
- }
- package com.darcy.jms;
- import java.util.HashMap;
- import java.util.Scanner;
- import javax.jms.Destination;
- import org.springframework.jms.core.JmsTemplate;
- public class SpringPublish {
- private JmsTemplate template;
- private Destination[] destinations;
- public void chart(){
- boolean chart = true;
- int count = 0;
- while(chart){
- count ++;
- Scanner cin=new Scanner(System.in);
- System.out.println("输入聊天内容,输入N停止聊天");
- String text=cin.nextLine();
- if(text.equals("N")) {
- chart = false;
- }
- System.out.println("我:"+text);
- sendChartMessage(count,text);
- }
- }
- protected void sendChartMessage(int count , String strMessage) {
- MyMessageCreator creator = new MyMessageCreator(count,strMessage);
- template.send(destinations[0], creator);
- }
- public JmsTemplate getTemplate() {
- return template;
- }
- public void setTemplate(JmsTemplate template) {
- this.template = template;
- }
- public Destination[] getDestinations() {
- return destinations;
- }
- public void setDestinations(Destination[] destinations) {
- this.destinations = destinations;
- }
- }
消息生产者:
- package com.darcy.jms; import java.util.Date;
- import javax.jms.JMSException;
- import javax.jms.MapMessage;
- import javax.jms.Message;
- import javax.jms.Session;
- import org.springframework.jms.core.MessageCreator;
- public class MyMessageCreator implements MessageCreator {
- private int msgNo;
- private String strMessage;
- public MyMessageCreator(int no,String paramMessage) {
- this.msgNo = no;
- this.strMessage = paramMessage;
- }
- public Message createMessage(Session session) throws JMSException {
- MapMessage message = session.createMapMessage();
- message.setString("date", new Date().toString());
- message.setString("message", strMessage);
- message.setInt("count", msgNo);
- return message;
- }
- }
- package com.darcy.jms; import java.util.Date;
- import javax.jms.JMSException;
- import javax.jms.MapMessage;
- import javax.jms.Message;
- import javax.jms.Session;
- import org.springframework.jms.core.MessageCreator;
- public class MyMessageCreator implements MessageCreator {
- private int msgNo;
- private String strMessage;
- public MyMessageCreator(int no,String paramMessage) {
- this.msgNo = no;
- this.strMessage = paramMessage;
- }
- public Message createMessage(Session session) throws JMSException {
- MapMessage message = session.createMapMessage();
- message.setString("date", new Date().toString());
- message.setString("message", strMessage);
- message.setInt("count", msgNo);
- return message;
- }
- }
完成上述的代码,聊天器的功能已经实现了,现在开始写一个TestCase来运行以上的代码
本例的TestCase用例是基于Spring的集成测试环境,同时你要保证将applicationContext-jms.xml纳入Spring的管理。
如果还不清楚如何搭建Spring集成测试环境的童鞋,请移步到这里 搭建Spring集成测试环境
- package test.JSM;
- import com.darcy.common.BaseTestCase;
- import com.darcy.jms.SpringPublish;
- import org.springframework.jms.listener.DefaultMessageListenerContainer;
- public class SpringJmsTestMain extends BaseTestCase {
- private SpringPublish publisher;
- private DefaultMessageListenerContainer javaConsumer;
- public SpringPublish getPublisher(){
- return publisher;
- }
- public void setPublisher(SpringPublish publisher){
- this.publisher = publisher;
- }
- public void testJMS(){
- javaConsumer.start();
- publisher.chart();
- }
- public void setJavaConsumer(DefaultMessageListenerContainer javaConsumer) {
- this.javaConsumer = javaConsumer;
- }
- public DefaultMessageListenerContainer getJavaConsumer() {
- return javaConsumer;
- }
- }
- package test.JSM;
- import com.darcy.common.BaseTestCase;
- import com.darcy.jms.SpringPublish;
- import org.springframework.jms.listener.DefaultMessageListenerContainer;
- public class SpringJmsTestMain extends BaseTestCase {
- private SpringPublish publisher;
- private DefaultMessageListenerContainer javaConsumer;
- public SpringPublish getPublisher(){
- return publisher;
- }
- public void setPublisher(SpringPublish publisher){
- this.publisher = publisher;
- }
- public void testJMS(){
- javaConsumer.start();
- publisher.chart();
- }
- public void setJavaConsumer(DefaultMessageListenerContainer javaConsumer) {
- this.javaConsumer = javaConsumer;
- }
- public DefaultMessageListenerContainer getJavaConsumer() {
- return javaConsumer;
- }
- }
下载地址:http://activemq.apache.org/download.html
解压后,进入Conf目录,打开ActiveMQ.xml编辑
- <transportConnectors>
- <transportConnector name="openwire" uri="tcp://localhost:61616"/>
- </transportConnectors>
- <transportConnectors>
- <transportConnector name="openwire" uri="tcp://localhost:61616"/>
- </transportConnectors>
启动ActionMQ, 运行bin目录里的ActionMQ.bat.
同时你也可以进入WEB Console, 默认访问地址为:http://localhost:8161/admin/
运行TestCase,开始聊天吧~~~嘿嘿,不可上面的代码只支持单人聊天模式,接受端只是从JMS获取消息并输出。
附录:
Maven相关Denpendency(JMS
- <dependency>
- <groupId>org.springframework</groupId>
- <artifactId>spring-jms</artifactId>
- <version>3.1.1.RELEASE</version>
- </dependency>
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-jms_1.1_spec</artifactId>
- <version>1.1</version>
- </dependency>
- <dependency>
- <groupId>org.springframework</groupId>
- <artifactId>spring-jms</artifactId>
- <version>3.1.1.RELEASE</version>
- </dependency>
- <dependency>
- <groupId>org.apache.geronimo.specs</groupId>
- <artifactId>geronimo-jms_1.1_spec</artifactId>
- <version>1.1</version>
- </dependency>