使用spring集成JMS连接ActiveMQ

最新推荐文章于 2021-03-30 17:10:08 发布

feiwofeifeiwo_###

最新推荐文章于 2021-03-30 17:10:08 发布

阅读量1k

点赞数

分类专栏：消息中间件 HTTP

本文链接：https://blog.csdn.net/qq_36407090/article/details/81329035

版权

消息中间件同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

HTTP

4 篇文章 0 订阅

订阅专栏

ConnectionFactory用于管理连接的连接工厂

JmsTemplate用于发送和接收消息的模板类

MessageListerner消息监听器

ConnectionFactory

一个Spring为我们提供的连接池

JmsTemplate每次发消息都会重新创建连接，会话和producer

spring中提供了SingleConnectionFactory和CachingConnectionFactory(继承了SingleConnectionFactory有缓存)

JmsTemplate
是spring提供的，只需向spring容器内注入这个类就可以使用JmsTemplate方便操作jms
JmsTemplate类是线程安全的，可以在整个应用范围使用。

MessageListerner
实现一个onMessage方法，该方法只接收一个Message参数

pom文件里添加引用
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>${spring.version}</version>
</dependency>

<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-core</artifactId>
<version>5.7.0</version>

<exclusions>
<exclusion>
<artifactId>spring-context</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
</exclusions>
</dependency>

web.xml里的配置
<!--spring应用上下文，理解层次化的ApplicationContext-->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>
      classpath:applicationContext*.xml
  </param-value>
</context-param>

applicationContext-common.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: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/context 
       http://www.springframework.org/schema/context/spring-context.xsd">
    
    <context:annotation-config/>

    <context:component-scan base-package="com.imooc.mvcdemo">
        <!-- 这里只扫描Controller，不可重复加载Service -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- ActiveMQ 提供的ConnectionFactory -->
    <bean id="activeMQConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <!-- 配置 brokerURL，这里为你自己开启 ActiveMQ 服务的地址-->
        <property name="brokerURL" value="tcp://10.10.20.79:61616"/>
    </bean>

    <!-- Spring 提供的连接池 -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
        <property name="targetConnectionFactory" ref="activeMQConnectionFactory"/>
    </bean>

    <!-- 
        点对点或队列模型
        配置队列的目的地 
    -->
    <bean id="activeMQQueue" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg value="spring-jms-queue"/>
    </bean>


    <!-- 
        发布者／订阅者模型
        配置主题的目的地 
    -->
    <!--<bean id="activeMQTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg name="name" value="spring-jms-topic"/>
    </bean>-->



</beans>

applicationContext-producer.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 导入公共配置 -->
    <import resource="applicationContext-common.xml"/>

    <!-- 配置 JmsTemplate -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="defaultDestination" ref="activeMQQueue" />
        <!-- true是topic，false是queue，默认是false，此处显示写出false -->
        <property name="pubSubDomain" value="false" />
    </bean>

</beans>

applicationContext-consumer.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 导入公共配置 -->
    <import resource="applicationContext-common.xml"/>

    <!-- 配置自定义消费者消息监听器 -->
    <!-- <bean id="consumerMessageListener" class="com.imooc.mvcdemo.listener.ConsumerMessageListener"/>-->

    <!-- 配置消息监听器的容器 -->
    <!--<bean id="container" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="destination" ref="activeMQQueue"/>
        &lt;!&ndash;
            配置发布者／订阅者模型的目的地
            <property name="destination" ref="activeMQTopic"/>
         &ndash;&gt;
        <property name="messageListener" ref="consumerMessageListener"/>
    </bean>-->

</beans>

package com.imooc.mvcdemo.service.impl;

import com.imooc.mvcdemo.service.ProducerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.jms.*;

/**
 * @author Jas
 * @create 2018-04-14 9:21
 **/
@Service
public class ProducerServiceImpl implements ProducerService {

    @Resource(name = "jmsTemplate")
    private JmsTemplate jmsTemplate;



    public void sendMessage(final String message) {
        Destination destination = jmsTemplate.getDefaultDestination();
        System.out.println(Thread.currentThread().getName()+" 向队列"+destination.toString()+"发送消息---------------------->"+message);
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                TextMessage textMessage = session.createTextMessage(message);
                return textMessage;
            }
        });
        System.out.println("消息已发送：" + message);
    }

    public void sendMessage(Destination destination,final String message){
        System.out.println(Thread.currentThread().getName()+" 向队列"+destination.toString()+"发送消息---------------------->"+message);
        jmsTemplate.send(destination, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(message);
            }
        });
    }

}

package com.imooc.mvcdemo.service.impl;

import com.imooc.mvcdemo.service.ConsumerService;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.TextMessage;

/**
 * Created by QXJJ1697 on 2018/7/16.
 */
@Service
public class ConsumerServiceImpl implements ConsumerService {

    @Resource(name="jmsTemplate")
    private JmsTemplate jmsTemplate;

    public TextMessage receive(Destination destination){
        TextMessage textMessage = (TextMessage) jmsTemplate.receive(destination);
        try{
            System.out.println("从队列" + destination.toString() + "收到了消息：\t"
                    + textMessage.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
        return textMessage;
    }
}

package com.imooc.mvcdemo.listener;

import org.springframework.stereotype.Component;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

/**
 * @author Jas
 * @create 2018-04-14 10:07
 **/
public class ConsumerMessageListener implements MessageListener {

    public void onMessage(Message message) {
        TextMessage textMessage = (TextMessage) message;
        try {
            System.out.println("消息已接收：" + textMessage.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

package com.imooc.mvcdemo.controller;

import com.imooc.mvcdemo.service.ConsumerService;
import com.imooc.mvcdemo.service.ProducerService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import javax.jms.Destination;
import javax.jms.TextMessage;


/**
 * Created by QXJJ1697 on 2018/7/16.
 */

@Controller
@RequestMapping("/message")
public class MessageController {
    private Logger logger = LoggerFactory.getLogger(MessageController.class);
    @Resource(name = "activeMQQueue")
    private Destination destination;

    //队列消息生产者
    @Resource(name = "producerServiceImpl")
    private ProducerService producer;

    //队列消息消费者
    @Resource(name = "consumerServiceImpl")
    private ConsumerService consumer;

    @RequestMapping(value = "/SendMessage", method = RequestMethod.POST)
    @ResponseBody
    public void send(String msg) {
        logger.info(Thread.currentThread().getName()+"------------send to jms Start");
        //producer.sendMessage(msg);
        producer.sendMessage(destination,msg);
        logger.info(Thread.currentThread().getName()+"------------send to jms End");
    }

    @RequestMapping(value= "/ReceiveMessage",method = RequestMethod.GET)
    @ResponseBody
    public void receive(){
        logger.info(Thread.currentThread().getName()+"------------receive from jms Start");
        consumer.receive(destination);
        logger.info(Thread.currentThread().getName()+"------------receive from jms End");
    }
}

在上面的配置文件中，我们已经默认的添加了这段监听器的配置文件，如果同学们不想使用这个监听器，可以直接注释掉。

 <!-- 配置自定义消费者消息监听器 -->
    <!-- <bean id="consumerMessageListener" class="com.imooc.mvcdemo.listener.ConsumerMessageListener"/>-->

    <!-- 配置消息监听器的容器 -->
    <!--<bean id="container" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="destination" ref="activeMQQueue"/>
        &lt;!&ndash;
            配置发布者／订阅者模型的目的地
            <property name="destination" ref="activeMQTopic"/>
         &ndash;&gt;
        <property name="messageListener" ref="consumerMessageListener"/>
    </bean>-->

我们可以看到，使用监听器的效果，和手动接收消息的效果是一样的。