Spring整合ActiveMQ
1、导入依赖
<!--ActiveMQ连接池-->
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-pool</artifactId>
<version>5.15.5</version>
</dependency>
<!-- spring支持jms的包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>${spring-version}</version>
</dependency>
2、Spring的配置文件中添加如下配置(我这里Spring的配置文件是 /conf/spring/applicationContext.xml)
<?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:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--配置包扫描,spring扫描该包下面除了@Controller之外的所有注解-->
<context:component-scan base-package="com.bocom">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--ActiveMQ与Spring整合相关配置-->
<bean id="connectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory" destroy-method="stop">
<property name="connectionFactory">
<!--真正可以生产Connection的ConnectionFactory,由对应的JMS服务商提供-->
<bean class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://192.168.229.129:61616"/>
</bean>
</property>
<property name="maxConnections" value="100"/>
</bean>
<!--这个是队列目的地,点对点的Queue-->
<bean id="destinationQueue" class="org.apache.activemq.command.ActiveMQQueue">
<!--通过构造注入Queue名-->
<constructor-arg index="0" value="spring-active-queue"/>
</bean>
<!--这个是队列目的地,发布订阅的主题Topic-->
<bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">
<!--通过构造注入Topic名-->
<constructor-arg index="0" value="spring-active-topic"/>
</bean>
<!--Spring提供的JMS工具类,他可以进行消息发送,接收等-->
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
<!--传入连接工厂-->
<property name="connectionFactory" ref="connectionFactory"/>
<!--传入目的地-->
<property name="defaultDestination" ref="destinationQueue"/>
<!--消息自动转换器-->
<property name="messageConverter">
<bean class="org.springframework.jms.support.converter.SimpleMessageConverter"/>
</property>
</bean>
</beans>
3、队列
模式一:生产者发送队列消息至缺省的队列,消费者从缺省的队列中获取消息
1、生产者
@Service
public class JmsProducer {
@Autowired
private JmsTemplate jmsTemplate;
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/conf/spring/applicationContext.xml");
JmsProducer jmsProducer = (JmsProducer) context.getBean("jmsProducer");
for (int i = 1; i < 7; i++) {
jmsProducer.jmsTemplate.send(new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
TextMessage textMessage = session.createTextMessage(
"queue:::" + UUID.randomUUID().toString().replace("-", ""));
return textMessage;
}
});
}
System.out.println("JmsProducer send message ok!!!");
}
}
执行生产者代码之后,可以看出,生产者将消息发送至MQ服务器,队列的名称为 spring-active-queue,这个队列的名称就是我们在Spring的配置文件中配置的缺省的Destination
2、消费者
@Service
public class JmsConsumer {
@Autowired
private JmsTemplate jmsTemplate;
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/conf/spring/applicationContext.xml");
JmsConsumer jmsConsumer = (JmsConsumer) context.getBean("jmsConsumer");
while (true) {
String textMessage = (String) jmsConsumer.jmsTemplate.receiveAndConvert();
System.out.println("接收到的消息是:" + textMessage);
}
}
}
执行完消费者代码之后,我们可以看到,消息已经被消费了.
3、控制台
虽然这个时候,生产者发送完了消息,消费者也消费完了消息,但是生产者和消费者的程序还是处于执行的状态,并没有断开.
模式二:生产者发送队列消息至指定的队列,消费者从指定的队列中获取消息
1、生产者
@Service
public class JmsProducer {
@Autowired
private JmsTemplate jmsTemplate;
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/conf/spring/applicationContext.xml");
JmsProducer jmsProducer = (JmsProducer) context.getBean("jmsProducer");
// 使用该代码,可以让生产者将队列消息发送到指定名称的队列中,而不是发送达到缺省的Destination
jmsProducer.jmsTemplate.setDefaultDestinationName("spring-active-queue-dynamic");
for (int i = 1; i < 7; i++) {
jmsProducer.jmsTemplate.send(new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
TextMessage textMessage = session.createTextMessage(
"queue:::dynamic" + UUID.randomUUID().toString().replace("-", ""));
return textMessage;
}
});
}
System.out.println("JmsProducer send message ok!!!");
}
}
执行生产者代码之后,可以看到,我们的消息不再发送到Spring配置文件中配置的缺省队列(spring-active-queue)中了,而是发送到了我们自己指定的队列(spring-active-queue-dynamic)中了
2、消费者
@Service
public class JmsConsumer {
@Autowired
private JmsTemplate jmsTemplate;
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/conf/spring/applicationContext.xml");
JmsConsumer jmsConsumer = (JmsConsumer) context.getBean("jmsConsumer");
while (true) {
// 可以让消费者从指定的队列中获取消息(队列的名称为:spring-active-queue-dynamic),而不是从缺省的Destination中获取
jmsConsumer.jmsTemplate.setDefaultDestinationName("spring-active-queue-dynamic");
String textMessage = (String) jmsConsumer.jmsTemplate.receiveAndConvert();
System.out.println("接收到的消息是:" + textMessage);
}
}
}
消费者指定代码之后,可以从指定的队列(spring-active-queue-dynamic)中消费消息,不再从缺省的Destination中消费消息了.
d
3、控制台
4、主题
在发送主题消息之前,需要将上面的Spring的配置文件的Destination切换到主题模式
// 之前缺省的Destination是队列,这里改为主题
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
<!--传入连接工厂-->
<property name="connectionFactory" ref="connectionFactory"/>
<!--传入目的地-->
<property name="defaultDestination" ref="destinationTopic"/>
<!--消息自动转换器-->
<property name="messageConverter">
<bean class="org.springframework.jms.support.converter.SimpleMessageConverter"/>
</property>
</bean>
模式一:生产者发送主题消息至缺省的topic,消费者从缺省的topic中获取消息
由于topic默认不是持久化的,所以我们这里要先运行消费者,就是做一个注册的操作
1、消费者
@Service
public class JmsConsumer {
@Autowired
private JmsTemplate jmsTemplate;
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/conf/spring/applicationContext.xml");
JmsConsumer jmsConsumer = (JmsConsumer) context.getBean("jmsConsumer");
while (true) {
String textMessage = (String) jmsConsumer.jmsTemplate.receiveAndConvert();
System.out.println("接收到的消息是:" + textMessage);
}
}
}
运行完消费者之后,可以看到,消费者在名称为:spring-active-topic的主题上等待消费消息
2、生产者
@Service
public class JmsProducer {
@Autowired
private JmsTemplate jmsTemplate;
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/conf/spring/applicationContext.xml");
JmsProducer jmsProducer = (JmsProducer) context.getBean("jmsProducer");
for (int i = 1; i < 7; i++) {
jmsProducer.jmsTemplate.send(new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
TextMessage textMessage = session.createTextMessage(
"topic:::" + UUID.randomUUID().toString().replace("-", ""));
return textMessage;
}
});
}
System.out.println("JmsProducer send message ok!!!");
}
}
生产者运行完之后,可以看到6条topic类型的消息,都发送到了我们在Spring配置文件配置的缺省Destination中(spring-active-topic)
3、控制台
这里有一个问题,生产者生产了6条消息,但是消费者只消费了4条消息,有两条消息没有被消费到,我猜测是不是消费者没有持久化的原因,所以尝试着在消费者中加入以下代码,但是最后还是会有消息没有消费到,(暂时原因不明,以后再探究)
// 尝试着能不能持久化
jmsConsumer.jmsTemplate.setDeliveryMode(DeliveryMode.PERSISTENT);
String textMessage = (String) jmsConsumer.jmsTemplate.receiveAndConvert();
System.out.println("接收到的消息是:" + textMessage);
模式二:生产者发送主题消息至指定的topic,消费者从指定的topic中获取消息
1、消费者
@Service
public class JmsConsumer {
@Autowired
private JmsTemplate jmsTemplate;
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/conf/spring/applicationContext.xml");
JmsConsumer jmsConsumer = (JmsConsumer) context.getBean("jmsConsumer");
while (true) {
//可以让消费者从指定的队列中获取消息(队列的名称为:spring-active-queue-dynamic),而不是从缺省的Destination中获取
ActiveMQTopic activeMQTopic = new ActiveMQTopic("spring-active-queue-dynamic");
jmsConsumer.jmsTemplate.setDefaultDestination(activeMQTopic);
String textMessage = (String) jmsConsumer.jmsTemplate.receiveAndConvert();
System.out.println("接收到的消息是:" + textMessage);
}
}
}
执行完消费者代码之后,可以看到消费者已经在等待名称为 spring-active-queue-dynamic的主题上的消息了,并不是使用spring配置文件中缺省的Destination
2、生产者
@Service
public class JmsProducer {
@Autowired
private JmsTemplate jmsTemplate;
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/conf/spring/applicationContext.xml");
JmsProducer jmsProducer = (JmsProducer) context.getBean("jmsProducer");
// 使用该代码,可以让生产者将队列消息发送到指定名称的队列中,而不是发送到缺省的Destination
ActiveMQTopic activeMQTopic = new ActiveMQTopic("spring-active-queue-dynamic");
jmsProducer.jmsTemplate.setDefaultDestination(activeMQTopic);
for (int i = 1; i < 7; i++) {
jmsProducer.jmsTemplate.send(new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
TextMessage textMessage = session.createTextMessage(
"topic:::dynamic" + UUID.randomUUID().toString().replace("-", ""));
return textMessage;
}
});
}
System.out.println("JmsProducer send message ok!!!");
}
}
执行完生产者之后,发现6条消息确实发送到了指定的主题 spring-active-topic-dynamic上了
3、控制台
从MQ的管理界面和控制台上看到,我们总共发送了6条消息,只消费了3条消息,为什么剩下的3条消息没有消费到呢?
5、配置消费者的监听类
1、在spring的配置文件中加上这一段
<!--配置监听程序-->
<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory"></property>
<property name="destination" ref="destinationTopic"></property>
<!--自定义消息监听类MyMessageListener implements MessageListener接口-->
<property name="messageListener" ref="myMessageListerer"></property>
</bean>
2、消息监听类(有了消息监听类之后就不需要启动消费者了,直接可以获取消息,因为spring的配置文件已经启动了消费者)
@Component("myMessageListerer")
public class MyMessageListerer implements MessageListener {
@Override
public void onMessage(Message message) {
if (message != null && message instanceof TextMessage) {
TextMessage textMessage = (TextMessage) message;
try {
System.out.println("接收到的消息是:" + textMessage.getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
}
}
