Spring集成Active重要组成
> SingleConnectionFactory 用于管理ACTIVEMQ的连接工厂.
> CachingConnectionFactory 继承SingleConnectionFactory 同时增加了缓存功能 它可以缓存Session、MessageProducer和MessageConsumer
> JmsTemplate 用于消息发送和接收 继承 抽象类 JmsDestinationAccessor,JmsAccessor 一般只用来发送消息
> DefaultMessageListenerContainer,SimpleMessageListenerContainer 消息监听容器_用于管理监听器_,监听消息分发给监听器_.需要知道连接和(消息的队列或者topic)即消 息的目的地信息然后分发给真正的消息监听器 不可缺少的三个参数
____>SimpleMessageListenerContainer会在一开始的时候就创建一个会话session和消费者Consumer,并且会使用标准的JMS MessageConsumer.setMessageListener()方 法注册监听器让JMS提供者调用监听器的回调函数。它不会动态的适应运行时需要和参与外部的事务管理。兼容性方面,它非常接近于独立的JMS规范,但一般不兼容 Java EE 的JMS限制。
____>DefaultMessageListenerContainer 大多数情况下我们还是使用的DefaultMessageListenerContainer,跟SimpleMessageListenerContainer相比 Default会动态的适应运 行时需要,并且能够参与外部的事务管理。它很好的平衡了对JMS提供者要求低、先进功能如事务参与和兼容Java EE环境。定义处理消息的MessageListener
________> connectionFactory 连接工厂
________> destination 消息目的地
________> messageListener 消息监听器 消息监听器有三种
____________1. 实现 MessageListener 实现 onMessage 获取消息
____________2. 实现 SessionAwareMessageListener 特性是收到消息后可以给指定的队列回送消息
____________3.使用MessageListenerAdapter 来管理一个实体类_,利用反射机制交给实体类收发信息 如果MessageListenerAdapter 监听方法有返回值并且 生产者有 (textMessage.setJMSReplyTo(responseDestination) 或 bean配置的监听适配器有 defaultResponseDestination 设置此属性)那么将会把返回值消息发送到 指 定队列 responseDestination 这是MessageListenerAdapter 特性
3中监听的配置
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package="com" />
<!-- 真正可以产生Connection的ConnectionFactory,由对应的 JMS服务厂商提供-->
<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://localhost:61616"/>
</bean>
<!--
CachingConnectionFactory继承了SingleConnectionFactory,
所以它拥有SingleConnectionFactory的所有功能,同时它还新增了缓存功能,
它可以缓存Session、MessageProducer和MessageConsumer。
-->
<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
<property name="targetConnectionFactory" ref="targetConnectionFactory"/>
</bean>
<!-- Spring提供的JMS工具类,它可以进行消息发送、接收等 -->
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
<!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
<property name="connectionFactory" ref="connectionFactory"/>
</bean>
<!-- begin MessageListener -->
<!--这个是队列目的地,点对点的-->
<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg>
<value>queue</value>
</constructor-arg>
</bean>
<!--这个是主题目的地,一对多的
<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
<constructor-arg value="topic"/>
</bean> -->
<!-- 消息监听器 -->
<bean id="consumerMessageListener" class="com.listen.ConsumerMessageListener"/>
<!-- 消息监听容器 -->
<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="queueDestination" />
<property name="messageListener" ref="consumerMessageListener" />
</bean>
<!-- end MessageListener -->
<!-- begin SessionAwareMessageListener -->
<!--这个是队列目的地,点对点的-->
<bean id="sessionAwareQueue" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg>
<value>sessionAware</value>
</constructor-arg>
</bean>
<!-- 消息监听器 -->
<bean id="consumerSessionAwareMessageListener" class="com.listen.ConsumerSessionAwareMessageListener">
<property name="destination" ref="sessionAwareQueue"/>
</bean>
<!-- 消息监听容器 -->
<bean id="jmsSessionAwareContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="sessionAwareQueue" />
<property name="messageListener" ref="consumerSessionAwareMessageListener" />
</bean>
<!-- end SessionAwareMessageListener -->
<!-- begin MessageListenerAdapter -->
<!--这个是队列目的地,点对点的-->
<bean id="messageAdapterQueue" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg>
<value>messageAdapter</value>
</constructor-arg>
</bean>
<!-- 消息适配器 -->
<bean id="messageListenerAdapter" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
<property name="delegate">
<bean class="com.listen.ConsumerMessageAdapterListener"/>
</property>
<!--
<property name="defaultListenerMethod" value="receiveMessage"/>
-->
<property name="defaultResponseDestination" ref="queueDestination"></property>
</bean>
<!-- 消息监听容器 -->
<bean id="jmsMessageAdapterContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="messageAdapterQueue" />
<property name="messageListener" ref="messageListenerAdapter" />
</bean>
<!-- end MessageListenerAdapter -->
</beans>
下面是3中监听器的实现类
1.MessageListener
public class ConsumerMessageListener implements MessageListener {
public void onMessage(Message message) {
/*
这里我们知道生产者发送的就是一个纯文本消息,所以这里可以直接进行强制转换,
或者直接把onMessage方法的参数改成Message的子类TextMessage
*/
TextMessage textMsg = (TextMessage) message;
System.out.println("MessageListener 接收到一个纯文本消息。");
try {
System.out.println("消息内容是:" + textMsg.getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
}
2.SessionAwareMessageListener
public class ConsumerSessionAwareMessageListener implements SessionAwareMessageListener<TextMessage>{
private Destination destination;
public void onMessage(TextMessage message, Session session) throws JMSException {
System.out.println("Session 收到一条消息");
System.out.println("Session 消息内容是:" + message.getText());
MessageProducer producer = session.createProducer(destination);
Message textMessage = session.createTextMessage("ConsumerSessionAwareMessageListener。。。");
producer.send(textMessage);
}
public Destination getDestination() {
return destination;
}
public void setDestination(Destination destination) {
this.destination = destination;
}
}
3.MessageListenerAdapter
public class ConsumerMessageAdapterListener {
public String handleMessage(String message) {
System.out.println("ConsumerListener通过handleMessage接收到一个纯文本消息,消息内容是:" + message);
return "this is ConsumerListener defulate Method return value";
}
public void receiveMessage(String message) {
System.out.println("ConsumerListener通过receiveMessage接收到一个纯文本消息,消息内容是:" + message);
}
}
>生产者
@Component
public class ProducerServiceImpl implements ProducerService {
@Autowired
private JmsTemplate jmsTemplate;
@Autowired
@Qualifier("queueDestination")
private Destination responseDestination;
public void sendMessage(Destination destination, final String message) {
System.out.println("---------------生产者发送消息1-----------------");
System.out.println("---------------生产者发了一个消息1:" + message);
jmsTemplate.send(destination, new MessageCreator() {
public Message createMessage(Session session) throws JMSException {
TextMessage textMessage = session.createTextMessage(message);
//textMessage.setJMSReplyTo(responseDestination);
return textMessage;
}
});
}
public JmsTemplate getJmsTemplate() {
return jmsTemplate;
}
public void setJmsTemplate(JmsTemplate jmsTemplate) {
this.jmsTemplate = jmsTemplate;
}
}
> 测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/beans.xml")
public class ProducerConsumerTest {
@Autowired
private ProducerService producerService;
@Autowired
@Qualifier("queueDestination")
private Destination destination;
@Test
public void testSend() {
for (int i=0; i<1; i++) {
producerService.sendMessage(destination, "你好,生产者!这是消息:" + (i+1));
}
}
}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/beans.xml")
public class ProducerSessionAwareConsumerTest {
@Autowired
private ProducerService producerService;
@Autowired
@Qualifier("sessionAwareQueue")
private Destination sessionAwareQueue;
@Test
public void testSessionAwareMessageListener() {
producerService.sendMessage(sessionAwareQueue, "测试SessionAwareMessageListener");
}
}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/beans.xml")
public class ProducerMessageAdapterConsumerTest {
@Autowired
private ProducerService producerService;
@Autowired
@Qualifier("messageAdapterQueue")
private Destination destination;
@Test
public void testSend() {
producerService.sendMessage(destination, "test send message to MessageListenerAdapter");
}
}