ActiveMQ(二) ActiveMQ + spring 集成

最新推荐文章于 2024-07-12 07:00:00 发布

liuqiango

最新推荐文章于 2024-07-12 07:00:00 发布

阅读量222

点赞数

分类专栏： ActiveMQ

本文链接：https://blog.csdn.net/u011498644/article/details/52764018

版权

ActiveMQ 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

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" />


<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://localhost:61616"/>
</bean>



<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">

<property name="targetConnectionFactory" ref="targetConnectionFactory"/>
</bean>


<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">

<property name="connectionFactory" ref="connectionFactory"/>
</bean>




<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg>
<value>queue</value>
</constructor-arg>
</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>






<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>





<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="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>


</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");
}
}