Java消息队列-Spring整合ActiveMq

最新推荐文章于 2021-08-24 23:02:44 发布

feiwofeifeiwo_###

最新推荐文章于 2021-08-24 23:02:44 发布

阅读量312

点赞数

CC 4.0 BY-SA版权

分类专栏：消息中间件

本文链接：https://blog.youkuaiyun.com/qq_36407090/article/details/81348534

消息中间件专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一个基于Spring框架实现的消息队列应用案例，涵盖了ActiveMQ的配置、消息生产和消费流程，并展示了如何使用Spring JMS进行消息传递。

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jms</artifactId>
</dependency>

 <!-- xbean 如<amq:connectionFactory /> -->
 <dependency>
   <groupId>org.apache.xbean</groupId>
   <artifactId>xbean-spring</artifactId>
   <version>3.16</version>
 </dependency>

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

web.xml
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        classpath*:applicationContext.xml,
        classpath*:applicationContext-common.xml
    </param-value>
</context-param>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:amq="http://activemq.apache.org/schema/core"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms-4.1.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core-5.12.1.xsd">

        <context:component-scan base-package="com.imooc.mvcdemo">
        <context:exclude-filter type="annotation"                 expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>
        
    <context:annotation-config/>


    <amq:connectionFactory id="amqConnectionFactory"
                           brokerURL="tcp://localhost:61616"
                           userName="admin"
                           password="admin" />

    <!--Spring提供的连接池-->
    <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
        <constructor-arg ref="amqConnectionFactory" />
        <property name="sessionCacheSize" value="100" />
    </bean>

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

    <!-- 配置 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>

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

    <!-- 配置自定义消费者消息监听器 -->
    <!--<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")
    JmsTemplate jmsTemplate;




    public void sendMessage(Destination destination,final String message) {
       jmsTemplate.send(destination, new MessageCreator() {

           public Message createMessage(Session session) throws JMSException {
               TextMessage textMessage = session.createTextMessage(message);
               System.out.println("消息已发送：" + textMessage.getText());
               return textMessage;
           }
       });
    }

    /**
     * 向默认队列发送消息
     */
    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);
            }
        });
    }
}

package com.imooc.mvcdemo.service.impl;

import com.alibaba.fastjson.JSON;
import com.imooc.mvcdemo.model.Person;
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 Administrator on 2018/7/22.
 */
@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());
            Person fromJson = JSON.parseObject(textMessage.getText(), Person.class);
        } catch (JMSException e) {
            e.printStackTrace();
        }
        return textMessage;
    }
}

package com.imooc.mvcdemo.listener;

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("ConsumerMessageListener监听到了文本消息：" + textMessage.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

package com.imooc.mvcdemo.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
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.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

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

/**
 * Created by Administrator on 2018/7/22.
 */
@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(@RequestParam("message") String message) {
        /*logger.info(Thread.currentThread().getName()+"------------send to jms Start");
        producer.sendMessage(msg);
        logger.info(Thread.currentThread().getName()+"------------send to jms End");*/
        System.out.println("------------send to jms");
        JSONObject jsonObj = new com.alibaba.fastjson.JSONObject();
        jsonObj.put("name", "张三");
        jsonObj.put("sex", "男");
        jsonObj.put("age", 20);
        String resultjson= JSON.toJSONString(jsonObj);
        ModelAndView mv = null;
        producer.sendMessage(destination, resultjson);
    }

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