Spring mvc 注入activemq

最新推荐文章于 2020-08-18 15:45:19 发布
最新推荐文章于 2020-08-18 15:45:19 发布
阅读量507 收藏
点赞数
分类专栏： Java web 文章标签： activemq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miss_min/article/details/79096710
版权

一、pom.xml中添加相关依赖

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

二、加入activemq.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: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="service" />
    <mvc:annotation-driven />

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

    <!-- 配置JMS连接工厂 -->
    <bean id="connectionFactory"
          class="org.springframework.jms.connection.CachingConnectionFactory">
        <constructor-arg ref="amqConnectionFactory" />
        <property name="sessionCacheSize" value="100" />
    </bean>

    <!-- 定义消息队列（Queue） -->
    <bean id="demoQueueDestination" class="org.apache.activemq.command.ActiveMQQueue">
        <!-- 设置消息队列的名字 -->
        <!--<constructor-arg>-->
            <!--<value>qiao,xiao</value>-->
        <!--</constructor-arg>-->
        <constructor-arg index="0" value="MQ-FTP,MQ-Analysis,MQ-AnalysisResult,MQ-ImageBack" />
    </bean>

    <!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="defaultDestination" ref="demoQueueDestination" />
        <property name="receiveTimeout" value="10000" />
        <!-- true是topic，false是queue，默认是false，此处显示写出false -->
        <property name="pubSubDomain" value="false" />
    </bean>

    <!-- 配置消息队列监听者（Queue） -->
    <!--配置监听类的路径-->
    <bean id="queueMessageListener" class="MQ.QueueMessageListener" />

    <!-- 显示注入消息监听容器（Queue），配置连接工厂，监听的目标是demoQueueDestination，监听器是上面定义的监听器 -->
    <bean id="queueListenerContainer"
          class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="destination" ref="demoQueueDestination" />
        <property name="messageListener" ref="queueMessageListener" />
        <!--<property name="concurrentConsumers" value="4"/>-->
    </bean>

</beans>

三、web.xml里边配置activemq.xml的路径

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:activemq.xml</param-value>
  </context-param>

四、添加消息生产者Service

package service;

import model.User;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

import java.io.Serializable;

@Service
public class ProducerService {
    @Resource(name="jmsTemplate")
    private JmsTemplate jmsTemplate;

    /**
     * 向指定队列发送消息
     */
    public void sendMessage(Destination destination, final String msg) {
        System.out.println("向队列" + destination.toString() + "发送了消息------------" + msg);
        jmsTemplate.send(destination, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(msg);
            }
        });
    }

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

            }
        });

    }

    /**
     * 向指定Destination发送序列化的对象
     *
     * @param destination
     * @param object
     *            object 必须序列化
     */
    public void sendObjectMessage(Destination destination, final Serializable object) {
        if (null == destination) {
            destination = jmsTemplate.getDefaultDestination();
        }
        jmsTemplate.send(destination, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createObjectMessage(object);
            }
        });
        System.out.println("springJMS send object message...");
    }

}

五、加入消息监听器自动消费消息

package MQ;

import ftpManage.FtpEntity;
import ftpManage.FtpUtil;
import model.TvdsImage;
import model.TvdsResult;
import org.apache.activemq.command.ActiveMQDestination;
import org.springframework.beans.factory.annotation.Autowired;
import service.ProducerService;
import service.TvdsImageService;
import service.TvdsResultService;

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

/**
 * 当收到消息自动调用onMessage方法
 * 一旦有新消息，将自动读取消费
 * 监听器检测到消息，将立即消费掉
 */

public class QueueMessageListener implements MessageListener {

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

    @Autowired
    private TvdsResultService tvdsResultService;

    @Autowired
    private TvdsImageService tvdsImageService;

    //当收到消息后，自动调用该方法
    public void onMessage(Message message) {

//        TextMessage tm = (TextMessage) message;
//        try {
//            System.out.println("QueueMessageListener监听到了文本消息：\t" + tm.getText());
//            //do something ...
//        } catch (JMSException e) {
//            e.printStackTrace();
//        }

        //测试发送多个队列的
        try {
            ActiveMQDestination activeMQDestination=(ActiveMQDestination)message.getJMSDestination();

            /**
             * 监听消息队列queue1中的消息
             * ftp下载0
             */
            if(activeMQDestination.getPhysicalName().equalsIgnoreCase("MQ-FTP"))
            {
                System.out.println("监听队列:"+activeMQDestination.getPhysicalName()+"消费了消息:");
                // 如果是文本消息
                if (message instanceof TextMessage) {
                    TextMessage _tm = (TextMessage) message;
                    try {
                        System.out.println("from get textMessage：\t" + _tm.getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }

                // 如果是Object消息
                if (message instanceof ObjectMessage) {
                    ObjectMessage objMsg = (ObjectMessage) message;
                    try {
                        FtpEntity ftp=(FtpEntity) objMsg.getObject();
                        System.out.println("addrIp："+ftp.getIpAddr()+"  port:"+ftp.getPort()+"用户名："+ftp.getUserName()+"密码："+ftp.getPwd());
                        //开始ftp 下载
                        FtpUtil ftpUtil = new FtpUtil();
                        ftpUtil.startDown(ftp,ftp.getLocalPath(),ftp.getRemotePath());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }

            /**
             * 监听消息队列queue2中的消息
             * 视频分析
             */
            if(activeMQDestination.getPhysicalName().equalsIgnoreCase("MQ-Analysis"))
            {
                System.out.println("监听队列:"+activeMQDestination.getPhysicalName()+"消费了消息:");
                // 如果是文本消息
                if (message instanceof TextMessage) {
                    TextMessage __tm = (TextMessage) message;
                    try {
                        System.out.println("from get textMessage：\t" + __tm.getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }

                // 如果是Object消息
                if (message instanceof ObjectMessage) {
                    ObjectMessage objMsg = (ObjectMessage) message;
                    try {



                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

            }
            /**
             * 监听消息队列queue3
             * 识别结果队列
             */
            if(activeMQDestination.getPhysicalName().equalsIgnoreCase("MQ-AnalysisResult"))
            {
                System.out.println("监听队列:"+activeMQDestination.getPhysicalName()+"消费了消息:");
                // 如果是文本消息
                if (message instanceof TextMessage) {
                    TextMessage __tm = (TextMessage) message;
                    try {
                        System.out.println("from get textMessage：\t" + __tm.getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }

                // 如果是Object消息
                if (message instanceof ObjectMessage) {
                    ObjectMessage objMsg = (ObjectMessage) message;
                    try {
                        TvdsResult tvdsResult = (TvdsResult)objMsg.getObject();
                        tvdsResultService.insertByEntity(tvdsResult);

                        System.out.println("往队列"+activeMQDestination.getCompositeDestinations()[2].getPhysicalName()+"中发送对象消息");
                        producerService.sendObjectMessage(activeMQDestination.getCompositeDestinations()[2], tvdsResult);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

            }


            /**
             * 监听消息队列queue4
             * 图片队列
             */
            if(activeMQDestination.getPhysicalName().equalsIgnoreCase("MQ-ImageBack"))
            {
                System.out.println("监听队列:"+activeMQDestination.getPhysicalName()+"消费了消息:");
                // 如果是文本消息
                if (message instanceof TextMessage) {
                    TextMessage __tm = (TextMessage) message;
                    try {
                        System.out.println("from get textMessage：\t" + __tm.getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }

                // 如果是Object消息
                if (message instanceof ObjectMessage) {
                    ObjectMessage objMsg = (ObjectMessage) message;
                    try {

                        TvdsImage tvdsImage = (TvdsImage)objMsg.getObject();
                        tvdsImageService.insertByEntity(tvdsImage);
                        System.out.println("往队列"+activeMQDestination.getCompositeDestinations()[3].getPhysicalName()+"中发送对象消息");
                        producerService.sendObjectMessage(activeMQDestination.getCompositeDestinations()[3], tvdsImage);

                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

            }

        } catch (JMSException e1) {
            e1.printStackTrace();
        }
    }

}

六、处理页面的Controller

（1）欢迎页WelcomeController 

package controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class WelcomeController {

    @RequestMapping(value="/welcome",method=RequestMethod.GET)
    public ModelAndView welcome(){
        System.out.println("------------welcome");
        ModelAndView mv = new ModelAndView();
        mv.setViewName("welcome");
        return mv;
    }
}

欢迎页welcome.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2017/12/28 0028
  Time: 13:08
  To change this template use File | Settings | File Templates.
--%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Welcome</title>
</head>
<body>
<h1>Welcome!!!</h1>
<h2><a href="producer">去发消息</a></h2>
<h2><a href="receive">从队列中取一个消息</a></h2>
</body>
</html>

（2）发送消息页面DemoController

package controller;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

import javax.annotation.Resource;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.TextMessage;
import javax.management.MBeanServerConnection;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;

import org.springframework.beans.factory.annotation.Autowired;
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.servlet.ModelAndView;
import service.ConsumerService;
import service.ProducerService;
import service.UserService;


@Controller
public class DemoController {

    @Autowired
    protected UserService userService;

    //队列名gzframe.demo
    @Resource(name="demoQueueDestination")
    private Destination demoQueueDestination;

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

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

    @RequestMapping(value="/producer",method=RequestMethod.GET)
    public ModelAndView producer(){
        System.out.println("------------go producer");

        Date now = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = dateFormat.format( now );

        ModelAndView mv = new ModelAndView();
        mv.addObject("time", time);
        mv.setViewName("jms_producer");
        return mv;
    }

    @RequestMapping(value="/onsend",method=RequestMethod.POST)  //发消息
    public ModelAndView producer(@RequestParam("message") String message) {
        System.out.println("开始发送消息------------send to jms");
        ModelAndView mv = new ModelAndView();
        producer.sendMessage(demoQueueDestination, message);
        mv.setViewName("welcome");
        return mv;
    }

    @RequestMapping(value="/receive",method=RequestMethod.GET)
    public ModelAndView queue_receive() throws JMSException {
        System.out.println("------------receive message");
        ModelAndView mv = new ModelAndView();

        TextMessage tm = consumer.receive(demoQueueDestination);
        mv.addObject("textMessage", tm.getText());

        mv.setViewName("queue_receive");
        return mv;
    }

    /*
     * ActiveMQ Manager Test
     */
    @RequestMapping(value="/jms",method=RequestMethod.GET)
    public ModelAndView jmsManager() throws IOException {
        System.out.println("------------jms manager");
        ModelAndView mv = new ModelAndView();
        mv.setViewName("welcome");

        JMXServiceURL url = new JMXServiceURL("");
        JMXConnector connector = JMXConnectorFactory.connect(url);
        connector.connect();
        MBeanServerConnection connection = connector.getMBeanServerConnection();

        return mv;
    }
}

发送消息页面jms_producer.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2017/12/28 0028
  Time: 13:09
  To change this template use File | Settings | File Templates.
--%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>JMS-Producer</title>
</head>
<body>
<h1>JMS-Producer!!!</h1>
<form action="onsend" method="post">

    MessageText:<textarea name="message">${time }</textarea>

    <input type="submit" value="提交" />
</form>
<h2><a href="welcome">返回主页</a></h2>
</body>
</html>
Miss_min
关注
专栏目录
Spring整合ActiveMq
马小果v:ma-xiaoguo的博客
02-19 860
1、概述 多种语言和协议编写客户端。语言: Java, C, C++, C#, Ruby, Perl, Python, PHP。应用协议: OpenWire,Stomp REST,WS Notification,XMPP,AMQP 完全支持JMS1.1和J2EE 1.4规范 (持久化,XA消息,事务) 对Spring的支持,ActiveMQ可以很容易内嵌到使用Spring的系统里面去,而且也支持Spring2.0的特性 通过了常见J2EE服务器(如 Geronimo,JBoss 4, GlassFish,W
Spring全家桶笔记：Spring+Spring Boot+Spring Cloud+Spring MVC
m0_55849656的博客
06-16 554
Spring全家桶笔记：Spring+Spring Boot+Spring Cloud+Spring MVC
springMVC activemq简单聊天室
12-05
springMVC activemq简单聊天室
Spring mvc4 + ActiveMQ 整合
weixin_34168880的博客
12-25 117
一、配置部分 二、代码部分 三、页面部分 四、Controller控制器 五、效果展示 六、加入监听器 七、最最重要的，别忘了打赏   一、配置部分 ActiveMQ的安装这就不说了，很简单， 这个例子采用maven构建，首先看一下pom.xml &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi...
springmvc+activeMQ
nanfang1012的博客
08-11 1379
什么要使用ActiveMQ 多个项目之间集成  (1) 跨平台  (2) 多语言  (3) 多项目 降低系统间模块的耦合度，解耦  (1) 软件扩展性 系统前后端隔离  (1) 前后端隔离，屏蔽高安全区 什么是JMS：     JMS 即Java消息服务（Java Message Service）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用...
spring与activeMQ（嵌入式启动activemq）
dw147258dw的专栏
10-14 614
 一、准备工作         一般的我们发送jms消息都需要启动activemq来当做服务器，消息发送到activemq后，在通过监听activemq的消息来接收到消息，activemq下载地址http://activemq.apache.org/download.html，然后通过activemq.bat来启动， 在这里我将通过一个例子来慢慢的讲解spring嵌入式启动ActiveMQ以...
activeMQ集成SpringMVC,三种方式监听
07-28
activeMQ集成SpringMVC,三种方式监听
spring整合Activemq源码
07-27
1. **Spring框架**：Spring是Java开发中的一个全功能框架，提供依赖注入（Dependency Injection）、面向切面编程（AOP）、事务管理等核心功能，广泛应用于Web应用的开发。SpringMVC是Spring框架的一个模块，专门用于...
Spring和ActiveMQ的整合实例源码ActiveMQSpringDemo.zip
05-03
首先，Spring是一个广泛使用的Java企业级应用开发框架，它简化了依赖注入、AOP（面向切面编程）、数据访问等复杂任务。在本示例中，Spring将作为容器，管理应用程序的组件，同时通过其JMS（Java Message Service）...
activeMq整合spring所需jar包
10-10
在整合Spring和ActiveMQ时，你需要了解以下几个关键知识点： 1. **ActiveMQ**: ActiveMQ是Apache软件基金会开发的一款开源消息中间件，它遵循Java Message Service (JMS) 规范，提供可靠的消息传递服务，支持多种...
springmvc整合activemq消息队列Demo
02-26
该demo在本地启动activemq后放在tomcat中可直接运行，不需要修改配置，连接远程的activemq需要手动修改applicationContext.xml中的activemq连接地址，jdk1.8
springMVC+activeMQ例子
06-26
springMVC整合activeMQ的例子
SpringMVC+JMS（ActiveMQ）整合的Demo
12-04
SpringMVC+JMS（ActiveMQ）整合的Demo，程序可运行。但不排除有一些小问题，请批评指正。
spring 整合activemq实现自定义动态消息队列
04-18
百度spring整合activemq 发现几乎都只是在xml文件配置固定的消息队列而且太麻烦。并没有根据需求进行动态生成主题和队列。本文档参考了纯粹的activemq java代码和百度上的demo，很简洁的实现了动态消息队列的生成和获取，但是没有自定义监听（当前项目不需要），本文档只有功能实现类 即业务层。若要调用和推送 则需要自己根据需求编写。此处提供参考价值。 activemq下载文件中有一个demo 包含所有jar包。此处就不上传了。
springmvc整合ActiveMQ
张erdan的博客
08-18 244
https://cloud.tencent.com/developer/article/1394245 如果整合由于activemq-all，和slf4j冲突，那么activemq组件分别引入。 如果由于javax.jms-api没引入报错，记得引入一下 <dependency> <groupId>javax.jms</groupId> <artifactId>javax.jms-api</artifactId> &
springmvc+activeMQ简单实用
u013170178的博客
11-09 1730
最初参考资料： https://www.cnblogs.com/leiOOlei/p/5075402.html http://blog.csdn.net/u012117656/article/details/62216120
将activeMqUtil注入到IOC容器中，并注入监听器的demo
零零JA
08-30 181
@Configuration public class ActiveMQConfig { @Value("${spring.activemq.broker-url:disabled}") String brokerURL ; @Value("${activemq.listener.enable:disabled}") String listen...
ActiveMq 自学（四） 集成SpringMvc+Spring框架
Cx的博客
10-28 1383
ActiveMq 自学（四） 集成SpringMvc+Spring框架           前面写了很多有关ActiveMq的一些使用案例，基本都是JAVA硬码调用。对于集成在Spring框架还是有一定的繁琐，而Spring早已经有了消息监听接口，用来处理队列请求。下面我们来学习一下在Spring上集成ActiveMq是怎么做的。 其中的重点则是用到了Spring中的JMS框架。
Spring整合JMS(一)——基于ActiveMQ实现
chiyingliao3565的博客
12-10 97
官网配置http://activemq.apache.org/spring-support.html 1.1JMS简介 JMS的全称是Java Message Service，即Java消息服务。它主要用于在生产者和消费者之间进行消息传递，生产者负责产生消息，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值