spring+activemq实战之配置监听多队列实现不同队列消息消费

最新推荐文章于 2021-08-09 10:40:29 发布
最新推荐文章于 2021-08-09 10:40:29 发布
阅读量1k 收藏
点赞数
分类专栏： spring activemq 文章标签： spring  activemq 配置

摘要: 最近在项目开发中，需要用到activemq，用的时候，发现在同一个项目中point-to-point模式中，配置多个队列，消息生成者只能往一个队列中发消息或者往多个队列发送相同消息，并且监听器只能监听一个队列，这样配置多个队列也没有意义，作者想要实现的是：配置多个队列，并且生产者可以往多个队列中发送不同的消息，监听器消费时，可以判断根据不同的队列进行相应的业务处理，网上搜了一个，发现都是单个队列和监听，研究了一下，发现是可以实现的，废话不多说，直接上代码：

maven所需依赖：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>com.gxf</groupId>  
  <artifactId>springmq</artifactId>  
  <packaging>war</packaging>  
  <version>0.0.1-SNAPSHOT</version>  
  <name>springmq Maven Webapp</name>  
  <url>http://maven.apache.org</url>  
<!-- 版本管理 -->  
  <properties>  
      <springframework>4.1.8.RELEASE</springframework>  
      <javax.servlet>3.1.0</javax.servlet>  
  </properties>  

  <dependencies>  

    <dependency>  
      <groupId>junit</groupId>  
      <artifactId>junit</artifactId>  
      <version>4.10</version>  
      <scope>test</scope>  
    </dependency>  

    <dependency>  
        <groupId>jstl</groupId>  
        <artifactId>jstl</artifactId>  
        <version>1.2</version>  
    </dependency>  

    <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>javax.servlet-api</artifactId>  
            <version>${javax.servlet}</version>  
    </dependency>  

    <!-- spring -->  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-core</artifactId>  
        <version>${springframework}</version>  
    </dependency>  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-context</artifactId>  
        <version>${springframework}</version>  
    </dependency>  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-tx</artifactId>  
        <version>${springframework}</version>  
    </dependency>  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-webmvc</artifactId>  
        <version>${springframework}</version>  
    </dependency>  
    <dependency>    
        <groupId>org.springframework</groupId>    
        <artifactId>spring-jms</artifactId>    
        <version>${springframework}</version>    
    </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.14.3</version>    
    </dependency>    

  </dependencies>  

  <build>  
    <finalName>springmq</finalName>  
  </build>  
</project>

-activemq配置文件：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.14.3.xsd"  
        >  

    <context:component-scan base-package="com.gxf" />  
    <mvc:annotation-driven />  

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

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

    <!-- 定义消息队列（Queue） -->  
    <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">  
        <!-- 配置两个消息队列：queue1,queue2 -->  
         <constructor-arg index="0" value="queue1,queue2" />  
    </bean>  
  <!--测试Topic-->
    <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg index="0" value="spring-topic"/>

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

    <!-- 配置消息队列监听者（Queue） -->  
    <bean id="queueMessageListener" class="com.gxf.listener.QueueMessageListener" />  
    <bean id="queueListenerContainer"        class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
        <property name="connectionFactory" ref="connectionFactory" />  
        <property name="destination" ref="queueDestination" />  
        <property name="messageListener" ref="queueMessageListener" />  
    </bean>  

 </beans>

-springmvc配置文件：springmvc.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"  
    xmlns:mvc="http://www.springframework.org/schema/mvc"  
    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-4.1.xsd  
        http://www.springframework.org/schema/mvc   
        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">  

    <context:component-scan base-package="com.gxf" />  
    <mvc:annotation-driven />  

    <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">  
        <property name="viewClass"  
            value="org.springframework.web.servlet.view.JstlView" />  
        <property name="prefix" value="/WEB-INF/views/" />  
        <property name="suffix" value=".jsp" />  
    </bean>  
</beans>

-Controll层 MainHandler.java代码：：

package com.gxf.handler;  

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

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


import org.apache.activemq.command.ActiveMQDestination;  
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 com.gxf.service.ProducerService;  


/** 
 *  
 * @author stark2017 
 * 
 */  
@Controller  
public class MainHandler {  


    //队列名  
    @Resource(name="queueDestination")  
    private Destination queueDestination;  


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



    @RequestMapping(value="/main",method=RequestMethod.GET)  
    public String producer(){  

        return "main";  
    }  
    /** 
     * 往队列queue1中发送消息 
     * @param message 
     * @return 
     */  
    @RequestMapping(value="/sendone",method=RequestMethod.POST)  
    public String producer(@RequestParam("message") String message) {  

        /** 
         * 将destination强制转换为ActiveMQDestination，在ActiveMQDestination对象中， 
         *    通过getCompositeDestinations()方法获取destination队列数组：queue://queue1  queue://queue2 
         *   
         */  
        ActiveMQDestination activeMQDestination=(ActiveMQDestination) queueDestination;  
        /** 
         * 往队列queue1中发送文本消息 
         */  
        System.out.println("往队列"+activeMQDestination.getCompositeDestinations()[0].getPhysicalName()+"中发送文本消息");  
        producerService.sendTxtMessage(activeMQDestination.getCompositeDestinations()[0], message);  
        /** 
         * 往队列queue1中发送MapMessage消息 
         */  
        System.out.println("往队列"+activeMQDestination.getCompositeDestinations()[0].getPhysicalName()+"中发送MapMessage消息");  
        producerService.sendMapMessage(activeMQDestination.getCompositeDestinations()[0], message);  

        //String bb="fdsalfkasdfkljasd;flkajsfd";  
        //byte[] b =  bb.getBytes();  

       // producer.sendBytesMessage(demoQueueDestination, b);  

        //producer.sendMapMessage(mqQueueDestination, message);  

        return "main";  
    }  
    /** 
     * 往消息队列queue2中发送消息 
     * @param message 
     * @return 
     */  
    @RequestMapping(value="/sendtwo",method=RequestMethod.POST)  
    public String producertwo(@RequestParam("message") String message) {  


        /** 
         * 将destination强制转换为ActiveMQDestination，在ActiveMQDestination对象中， 
         *    通过getCompositeDestinations()方法获取destination队列数组：queue://queue1  queue://queue2 
         *   
         */  
        ActiveMQDestination activeMQDestination=(ActiveMQDestination) queueDestination;  
        /** 
         * 队列queue2中发送文本消息 
         */  
        System.out.println("往队列"+activeMQDestination.getCompositeDestinations()[1].getPhysicalName()+"中发送文本消息");  
        producerService.sendTxtMessage(activeMQDestination.getCompositeDestinations()[1], message);  
        /** 
         * 队列queue2中发送mapMessage消息 
         */  
        System.out.println("往队列"+activeMQDestination.getCompositeDestinations()[1].getPhysicalName()+"中发送文本消息");  
        producerService.sendMapMessage(activeMQDestination.getCompositeDestinations()[1], message);  

        String bb="fdsalfkasdfkljasd;flkajsfd";  
        byte[] b =  bb.getBytes();  

       // producer.sendBytesMessage(demoQueueDestination, b);  

        //producer.sendMapMessage(mqQueueDestination, message);  

        return "main";  
    }  




}

-生产者ProducerService.java代码：

package com.gxf.service;  

import java.io.Serializable;  
import java.util.List;  
import java.util.Map;  

import javax.annotation.Resource;  
import javax.jms.BytesMessage;  
import javax.jms.Destination;  
import javax.jms.JMSException;  
import javax.jms.MapMessage;  
import javax.jms.Message;  
import javax.jms.Session;  
import javax.jms.StreamMessage;  

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

@Service  
public class ProducerService {  

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

    /** 
     * 向指定Destination发送text消息 
     *  
     * @param destination 
     * @param message 
     */  
    public void sendTxtMessage(Destination destination, final String message) {  
        if ( == destination) {  
            destination = jmsTemplate.getDefaultDestination();  
        }  
        jmsTemplate.send(destination, new MessageCreator() {  
            public Message createMessage(Session session) throws JMSException {  
                return session.createTextMessage(message);  
            }  
        });  
        System.out.println("springJMS send text message...");  
    }  

    /** 
     * 向指定Destination发送map消息 
     *  
     * @param destination 
     * @param message 
     */  
    public void sendMapMessage(Destination destination, final String message) {  
        if ( == destination) {  
            destination = jmsTemplate.getDefaultDestination();  
        }  
        jmsTemplate.send(destination, new MessageCreator() {  
            public Message createMessage(Session session) throws JMSException {  
                MapMessage mapMessage = session.createMapMessage();  
                mapMessage.setString("msgId", message);  
                return mapMessage;  
            }  
        });  
        System.out.println("springJMS send map message...");  
    }  

    /** 
     * 向指定Destination发送序列化的对象 
     *  
     * @param destination 
     * @param object 
     *            object 必须序列化 
     */  
    public void sendObjectMessage(Destination destination, final Serializable object) {  
        if ( == 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...");  
    }  

    /** 
     * 向指定Destination发送字节消息 
     *  
     * @param destination 
     * @param bytes 
     */  
    public void sendBytesMessage(Destination destination, final byte[] bytes) {  
        if ( == destination) {  
            destination = jmsTemplate.getDefaultDestination();  
        }  
        jmsTemplate.send(destination, new MessageCreator() {  
            public Message createMessage(Session session) throws JMSException {  
                BytesMessage bytesMessage = session.createBytesMessage();  
                bytesMessage.writeBytes(bytes);  
                return bytesMessage;  

            }  
        });  
        System.out.println("springJMS send bytes message...");  
    }  

    /** 
     * 向默认队列发送Stream消息 
     */  
    public void sendStreamMessage(Destination destination) {  
        jmsTemplate.send(new MessageCreator() {  
            public Message createMessage(Session session) throws JMSException {  
                StreamMessage message = session.createStreamMessage();  
                message.writeString("stream string");  
                message.writeInt(11111);  
                return message;  
            }  
        });  
        System.out.println("springJMS send Strem message...");  
    }  

}

-队列消息监听器QueueMessageListener.java代码：：

package com.gxf.listener;  
import javax.jms.BytesMessage;  
import javax.jms.JMSException;  
import javax.jms.MapMessage;  
import javax.jms.Message;  
import javax.jms.MessageListener;  
import javax.jms.ObjectMessage;  
import javax.jms.StreamMessage;  
import javax.jms.TextMessage;  

import org.apache.activemq.advisory.DestinationEvent;  
import org.apache.activemq.command.ActiveMQDestination;  
import org.apache.activemq.command.ActiveMQMessage;  
import org.apache.activemq.command.DestinationInfo;  


public class QueueMessageListener implements MessageListener {  


    //当收到消息后，自动调用该方法  
    @Override  
    public void onMessage(Message message) {  
         try {  
             ActiveMQDestination queues=(ActiveMQDestination)message.getJMSDestination();  

             /** 
              * 监听消息队列queue1中的消息 
              */  
            if(queues.getPhysicalName().equalsIgnoreCase("queue1"))  
            {  
                 System.out.println("监听队列:"+queues.getPhysicalName()+"消费了消息:");  
                // 如果是文本消息  
                    if (message instanceof TextMessage) {  
                        TextMessage tm = (TextMessage) message;  
                        try {  
                            System.out.println("from get textMessage：\t" + tm.getText());  
                        } catch (JMSException e) {  
                            // TODO Auto-generated catch block  
                            e.printStackTrace();  
                        }  
                    }  

                    // 如果是Map消息  
                    if (message instanceof MapMessage) {  
                        MapMessage mm = (MapMessage) message;  
                        try {  
                            System.out.println("from get MapMessage：\t" + mm.getString("msgId"));  
                        } catch (JMSException e) {  
                            // TODO Auto-generated catch block  
                            e.printStackTrace();  
                        }  
                    }  
            }  
            /** 
             * 监听消息队列queue2中的消息 
             */  
           if(queues.getPhysicalName().equalsIgnoreCase("queue2"))  
           {  
                System.out.println("监听队列:"+queues.getPhysicalName()+"消费了消息:");  
               // 如果是文本消息  
                   if (message instanceof TextMessage) {  
                       TextMessage tm = (TextMessage) message;  
                       try {  
                           System.out.println("from get textMessage：\t" + tm.getText());  
                       } catch (JMSException e) {  
                           // TODO Auto-generated catch block  
                           e.printStackTrace();  
                       }  
                   }  

                   // 如果是Map消息  
                   if (message instanceof MapMessage) {  
                       MapMessage mm = (MapMessage) message;  
                       try {  
                           System.out.println("from get MapMessage：\t" + mm.getString("msgId"));  
                       } catch (JMSException e) {  
                           // TODO Auto-generated catch block  
                           e.printStackTrace();  
                       }  
                   }  
           }  

        } catch (JMSException e1) {  
            // TODO Auto-generated catch block  
            e1.printStackTrace();  
        }  


        // 如果是Object消息  
        if (message instanceof ObjectMessage) {  
            ObjectMessage om = (ObjectMessage) message;  
            System.out.println("from get ObjectMessage：\t");  
        }  

        // 如果是bytes消息  
        if (message instanceof BytesMessage) {  
             System.out.println("from get BytesMessage：\t");  
            byte[] b = new byte[1024];  
            int len = -1;  
            BytesMessage bm = (BytesMessage) message;  
            try {  
                while ((len = bm.readBytes(b)) != -1) {  
                    System.out.println(new String(b, 0, len));  
                }  
            } catch (JMSException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  

        // 如果是Stream消息  
        if (message instanceof StreamMessage) {  
            System.out.println("from get BytesMessage：\t");  
            StreamMessage sm = (StreamMessage) message;  
            try {  
                System.out.println(sm.readString());  
                System.out.println(sm.readInt());  
            } catch (JMSException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  

        }}  

}
空城99
关注
专栏目录
JMS之Spring +activeMQ实现消息队列
08-12
总结起来，"JMS之Spring + ActiveMQ实现消息队列"涉及到的关键知识点包括：Spring框架的JMS支持、ActiveMQ的使用、ConnectionFactory的配置、JmsTemplate和MessageListener的实现，以及消息队列在解决系统解耦和异步...
SpringBoot+ActiveMq+MQTT实现消息的发送和接收
11-15
在本文中，我们将深入探讨如何使用SpringBoot、ActiveMQ和MQTT来实现消息的发送与接收。这是一个典型的分布式系统中的消息通信场景，其中SpringBoot作为应用程序框架，ActiveMQ作为消息中间件，而MQTT（Message ...
ActiveMQ多个消费者消费不均匀问题
weixin_34331102的博客
08-30 222
如果客户端处理很慢的话，Broker会在之前发送消息的反馈之前，继续发送新的消息到客户端。如果客户端依旧很慢的话，没有得到确认反馈的消息会持续增长。在这种情况下，Broker有可能会停止发送消息给消费者。当未被反馈的消息达到了prefetch limit设置的数字时，Broker将会停止给消费者发送新的消息。除非消费者开始给与反馈，否则得不到任何消息。DefaultPref...
Spring整合ActiveMQ及多个Queue消息监听的配置
11-15 342
消息队列（MQ）越来越火，在java开发的项目也属于比较常见的技术，MQ的相关使用也成java开发人员必备的技能。笔者公司采用的MQ是ActiveMQ，且消息都是用的点对点的模式。本文记录了实现Spring整合ActivateMQ的全过程及如何使用MQ，便于后续查阅。一、项目的搭建 采用maven构建项目，免去了copy jar包的麻烦。因此，我们创建了一个java类型的M...
spring 整合activemq实现自定义动态消息队列
04-18
百度spring整合activemq 发现几乎都只是在xml文件配置固定的消息队列而且太麻烦。并没有根据需求进行动态生成主题和队列。本文档参考了纯粹的activemq java代码和百度上的demo，很简洁的实现了动态消息队列的生成和...
spring + activemq 消息sample
08-14
4. **消息消费者**：定义一个监听器容器（MessageListenerContainer），并配置监听特定的队列或主题。然后创建一个实现MessageListener接口的类，用于处理接收到的消息。 ```xml ...
Activemq消息队列
月光秦城
10-18 356
activemq是由apache出品的，是强劲的开源消息总线，支持多种传输协议：in-VM,TCP,SSL,NIO,UDP,JGROUPS,JXTA。 windows环境下，下载解压软件包，点击bin目录下的activemq.bat linux环境下，运行bin下的命令，./activemq.setup 此时使用的默认服务端口是61616和默认console端口8161。 修改端口，就...
Spring整合ActiveMQ及多个Queue消息监听的配置（转载）
zgphacker2010的专栏
08-07 1096
消息队列（MQ）越来越火，在java开发的项目也属于比较常见的技术，MQ的相关使用也成java开发人员必备的技能。笔者公司采用的MQ是ActiveMQ，且消息都是用的点对点的模式。本文记录了实现Spring整合ActivateMQ的全过程及如何使用MQ，便于后续查阅。 一、项目的搭建 采用maven构建项目，免去了copy jar包的麻烦。因此，我们创建了一个java类型的Ma...
activemq java 队列_ActiveMQ的消息模式——队列模式（Queue）
weixin_35176891的博客
02-16 325
前言此处的代码只是简化理解，实际项目会结合Spring使用。一、队列模式特点客户端包括生产者和消费者队列中的消息只能被一个消费者消费消费者可以随时消费队列中的消息二、创建过程1.创建连接Connection2.创建会话Session3.通过Session来创建其它的(MessageProducer、MessageConsumer、Destination、TextMessage)4.将生产者 Mes...
activemq 开启监听_ACTIVEMQ之监听
weixin_39630637的博客
12-19 170
配置文件(spring-jms.xml)xsi:schemaLocation="queue3class="org.springframework.jms.listener.DefaultMessageListenerContainer">监听代码package org.soa.test.activemq.listeners;import org.soa.test.activemq.Stude...
activeMq开启jmx监听（遍历消息队列、获得消息队列的名称、队列中剩余的消息数量、消费者数等）
Caiabcd的博客
08-09 1363
第一步：开启jmx 找到一下路径下的文件：apache-activemq-5.16.2\conf\activemq.xml 以文本文件打开，修改一下两个参数 图一：在对应位置处天剑useJMX=“true” 图二：注意端口号，链接监听时需要 第二部：代码 //jmx服务地址，注意端口 String jmxserviceURL="service:jmx:rmi:///jndi/rmi://localhost:61618/jmxrmi"; //brokername是对应的ip String o
java activemq 封装_简单的activemq的封装和使用
weixin_39577289的博客
02-26 236
1 packagech02.chat;23 importjava.io.Serializable;45 importjavax.jms.Connection;6 importjavax.jms.ConnectionFactory;7 importjavax.jms.Destination;8 importjavax.jms.JMSException;9 importjavax.jms.Messag...
SpringBoot之使用ApacheArtemis(ActiveMQ分支)实现发送和处理消息
编程学习者的博客
03-01 1702
1.声明 当前内容主要用于本人学习和使用SpringBoot方式操作Artemis(apache-artemis-2.17.0)的基本操作 2.基本pom依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.18.RELEASE</vers
SpringBoot2.x教程——SpringBoot整合MQ之ActiveMQ实现消息传递
qianfeng_dashuju的博客
05-11 369
我在上一章节中，给大家介绍了ActiveMQ，本节中我会介绍Spring Boot中如何整合ActiveMQ，实现消息的创建和消费。 一. Spring Boot中整合ActiveMQ 1. 创建web项目 我们按照之前的经验，创建一个web程序，并将之改造成Spring Boot项目，具体过程略。 2. 添加依赖包 <dependency> <groupId>org.springframework.boot</groupId> <a
SpringBoot中简单的使用ActiveMQ实现发送和处理消息
编程学习者的博客
08-13 1155
环境：JDK1.8、MAVEN 3.6.1、eclipse 1.导入ActiveMQ的依赖 当前的pom文件内容如下： <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId&...
Spring集成ActiveMQ实现消息队列配置
Spring是一种流行的Java应用程序框架，通过与ActiveMQ集成，可以实现灵活的消息队列和消息监听配置。 在本文中，我们将详细介绍如何将Spring集成ActiveMQ，以发送和接收JMS消息。首先，我们需要下载ActiveMQ的jar包...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值