消息队列中间件（二）使用 ActiveMQ

最新推荐文章于 2021-12-09 00:44:07 发布
最新推荐文章于 2021-12-09 00:44:07 发布
阅读量397 收藏
点赞数
分类专栏： 中间件通信 文章标签： 中间件 消息队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013735734/article/details/84948343
版权

点赞再看，动力无限。Hello world : ) 微信搜「 程序猿阿朗 」。

本文 Github.com/niumoo/JavaNotes 和 未读代码博客 已经收录，有很多知识点和系列文章。

ActiveMQ 介绍

Active MQ 是由 Apache 出品的一款流行的功能强大的开源消息中间件，它速度快，支持跨语言的客户端，具有易于使用的企业集成模式和许多的高级功能，同时完全支持 JSM1.1 和 J2EE1.4 。

ActiveMQ 特点

  • 支持Java，C，C ++，C＃，Ruby，Perl，Python，PHP等各种跨语言客户端和协议，如 OpenWire , Stomp , AMQP , MQTT.
  • 完全支持JMS 1.1和 J2EE 1.4，支持瞬态，持久，事务和XA消息传递。
  • 对 Spring 框架的支持以便ActiveMQ可以轻松嵌入到Spring应用程序中。
  • 通过了常见的 J2EE 服务器测试，如 TomEE，Geronimo，JBoss，GlassFish 和 WebLogic 。
  • 连接方式的多样化，ActiveMQ 提供了多种连接模式，例如 in-VM、TCP、SSL、NIO、UDP、多播、JGroups、JXTA。
  • 可以通过使用 JDBC 和 journal 实现消息的快速持久化。
  • 专为高性能群集，客户端 - 服务器，点对点通信而设计。
  • 提供与语言无关的 REST API。
  • 支持 Ajax 方式调用 ActiveMQ。
  • ActiveMQ 可以轻松地与 CXF、Axis 等 Web Service 技术整合，以提供可靠的消息传递。
  • 可用作为内存中的 JMS 提供者，非常适合 JMS 单元测试。

ActiveMQ 消息

  1. 点对点队列模式
    消息到达消息系统，被保留在消息队列中，然后由一个或者多个消费者消费队列中的消息，一个消息只能被一个消费者消费，然后就会被移除。例如订单处理系统。
  2. 发布-订阅模式
    消息发送时指定主题（或者说通道），消息被保留在指定的主题中，消费者可以订阅多个主题，并使用主题中的所有的消息，例如现实中的电视与电视频道。所有客户端包括发布者和订阅者，主题中的消息可以被所有的订阅者消费，消费者只能消费订阅之后发送到主题中的消息。

ActiveMQ 概念

  • Broker，消息代理，表示消息队列服务器实体，接受客户端连接，提供消息通信的核心服务。
  • Producer，消息生产者，业务的发起方，负责生产消息并传输给 Broker 。
  • Consumer，消息消费者，业务的处理方，负责从 Broker 获取消息并进行业务逻辑处理。
  • Topic，主题，发布订阅模式下的消息统一汇集地，不同生产者向 Topic 发送消息，由 Broker 分发到不同的订阅者，实现消息的广播。
  • Queue，队列，点对点模式下特定生产者向特定队列发送消息，消费者订阅特定队列接收消息并进行业务逻辑处理。
  • Message，消息体，根据不同通信协议定义的固定格式进行编码的数据包，来封装业务 数据，实现消息的传输。

ActiveMQ 工程实例

下面是使用 ActiveMQ 的队列模式和发布-订阅模式的 Java 代码示例。

POM 依赖

        <!-- Active-MQ -->
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-all</artifactId>
            <version>5.15.5</version>
        </dependency>

队列模式消费者

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

/**
 * <p>
 * 消息消费者，用于消费消息
 *
 * @Author niujinpeng
 * @Date 2018/9/4 23:45
 */
public class AppConsumer {

    private static final String url = "tcp://127.0.0.1:61616";
    private static final String queueName = "queue-test";

    public static void main(String[] args) throws JMSException {
        // 1.创建ConnectionFactory
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
        // 2.创建Connection
        Connection connection = connectionFactory.createConnection();
        // 3.启动连接
        connection.start();

        // 4.创建会话,false，不使用事务，自动应答模式
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // 5.创建一个目标
        Destination destination = session.createQueue(queueName);
        // 6.创建消费者
        MessageConsumer consumer = session.createConsumer(destination);

        // 7.创建一个监听器
        consumer.setMessageListener(new MessageListener() {
            public void onMessage(Message message) {
                TextMessage textMessage = (TextMessage) message;
                try {
                    System.out.println("接收消息：" + textMessage.getText());
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        });

        // 8.关闭连接
        //connection.close();
    }
}

队列模式生产者

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

/**
 * <p>
 * 消息提供者，用于向消息中间件发送消息
 *
 * @Author niujinpeng
 * @Date 2018/9/4 23:28
 */
public class AppProducer {

    private static final String url = "tcp://127.0.0.1:61616";
    private static final String queueName = "queue-test";

    public static void main(String[] args) throws JMSException {
        // 1.创建ConnectionFactory
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
        // 2.创建Connection
        Connection connection = connectionFactory.createConnection();
        // 3.启动连接
        connection.start();

        // 4.创建会话,false，不使用事务，自动应答模式
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // 5.创建一个目标
        Destination destination = session.createQueue(queueName);
        // 6.创建生产者
        MessageProducer producer = session.createProducer(destination);

        // 7.创建消息并发送
        for (int i = 0; i < 10; i++) {
            // 创建消息
            TextMessage textMessage = session.createTextMessage("textMessage" + i);
            // 发布消息
            producer.send(textMessage);
            System.out.println("发送消息：" + textMessage.getText());
        }

        // 8.关闭连接
        connection.close();

    }
}

发布订阅模式生产者

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

/**
 * <p>
 * 主题模式
 * 消息消费者，用于消费消息
 *
 * @Author niujinpeng
 * @Date 2018/9/4 23:45
 */
public class AppConsumer {

    private static final String url = "tcp://127.0.0.1:61616";
    private static final String topicName = "topic-test";

    public static void main(String[] args) throws JMSException {
        // 1.创建ConnectionFactory
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
        // 2.创建Connection
        Connection connection = connectionFactory.createConnection();
        // 3.启动连接
        connection.start();

        // 4.创建会话,false，不使用事务，自动应答模式
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // 5.创建一个目标
        Destination destination = session.createTopic(topicName);
        // 6.创建消费者
        MessageConsumer consumer = session.createConsumer(destination);

        // 7.创建一个监听器
        consumer.setMessageListener(new MessageListener() {
            public void onMessage(Message message) {
                TextMessage textMessage = (TextMessage) message;
                try {
                    System.out.println("接收消息：" + textMessage.getText());
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        });

        // 8.关闭连接
        //connection.close();
    }
}

发布订阅模式生产者

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

/**
 * <p>
 * 主题模式
 * 消息提供者，用于向消息中间件发送消息
 *
 * @Author niujinpeng
 * @Date 2018/9/4 23:28
 */
public class AppProducer {

    private static final String url = "tcp://127.0.0.1:61616";
    private static final String topicName = "topic-test";

    public static void main(String[] args) throws JMSException {
        // 1.创建ConnectionFactory
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
        // 2.创建Connection
        Connection connection = connectionFactory.createConnection();
        // 3.启动连接
        connection.start();

        // 4.创建会话,false，不使用事务，自动应答模式
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // 5.创建一个目标
        Destination destination = session.createTopic(topicName);
        // 6.创建生产者
        MessageProducer producer = session.createProducer(destination);

        // 7.创建消息并发送
        for (int i = 0; i < 10; i++) {
            // 创建消息
            TextMessage textMessage = session.createTextMessage("textMessage" + i);
            // 发布消息
            producer.send(textMessage);
            System.out.println("发送消息：" + textMessage.getText());
        }

        // 8.关闭连接
        connection.close();

    }
}

GitHub源码：https://github.com/niumoo/message-queue

Spring 整合 ActiveMQ

在 Spring 中配置 Active MQ 就像Spring 整合其他功能一样，我们需要在 XML 配置中配置几个关键的实例即可。在 Active MQ 中有几个对象的实例是至关重要的，如 Active MQ jms 连接工厂，为了减少连接断开性能时间消耗的 jms 连接池以及生产者消费者等。

下面是一些详细说明。

  • ConnectionFactory 用于管理连接的连接工厂（Spring提供）。
    • 一个 Spring 为我们提供的连接池。
    • JmsTemplate 每次发送都会重新创建连接，会话和 Productor。
    • Spring 中提供了SingleConnectionFactory 和CachingConnectionFactory（增加了缓存功能）。
  • JmsTemplate 是用于发送和接收消息的模板类。
    • 是spring提供的，只需要向Spring 容器内注册这个类就可以使用 JmsTemplate 方便的操作jms。
    • JmsTemplate 类是线程安全的，可以在整个应用范围使用。
  • MessageListerner 消息监听器
    • 使用一个onMessage方法，该方法只接收一个Message参数。

POM 依赖

<properties>
        <spring.version>5.0.4.RELEASE</spring.version>
    </properties>
    <dependencies>

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- 这个版本的Spring需要使用JMS 2.0版本，但spring-jms的依赖没有自动导入JMS 2.0，而activemq-core会导入JMS 1.1的依赖 -->
        <dependency>
            <groupId>javax.jms</groupId>
            <artifactId>javax.jms-api</artifactId>
            <version>2.0.1</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>
                <exclusion>
                    <groupId>org.apache.geronimo.specs</groupId>
                    <artifactId>geronimo-jms_1.1_spec</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

XML 配置

XML 公共配置

为了份文件配置方便管理，下面是提取出来的公共配置，为了在独立配置生产者和消费者 XML文件时引入，当然也可以直接把生产者和消费者以及所有的 XML bean 配置在一个文件里。

<?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:content="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">

    <content:annotation-config/>

    <!-- ActiveMQ为我们提供的connection factory -->
    <bean id="targerConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://127.0.0.1:61616"/>
    </bean>

    <!-- spring jms为我们提供的连接池 -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
        <property name="targetConnectionFactory" ref="targerConnectionFactory"/>
    </bean>

    <!-- 一个队列模式目的地（队列名称），点对点的消息模式 -->
    <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg value="queue-spring"/>
    </bean>

    <!-- 一个主题模式目的地（主题名称），发布订阅消息模式 -->
    <bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg value="topic-spring"/>
    </bean>

</beans>
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:content="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">

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

    <!-- 配置消息监听器 -->
    <bean id="consumerMessageListener" class="net.codingme.jms.consumer.ConsumerMessageListener"/>

    <!-- 配置消息监听容器 -->
    <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory"/>
        <!-- 队列模式 -->
        <!--<property name="destination" ref="queueDestination"/>-->
        <!-- 主题模式 -->
        <property name="destination" ref="topicDestination"/>
        <property name="messageListener" ref="consumerMessageListener"/>
    </bean>

</beans>
XML 生产者

生成者的配置主要是使用 spring jms 模版对象，创建生产者实例用于生产消息。

<?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:content="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">

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

    <!-- jms模版-->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
    </bean>

    <bean class="net.codingme.jms.producer.ProducerServiceImpl"></bean>

</beans>

生产者编写

1. 定义接口

package net.codingme.jms.producer;

/**
 * <p>
 *
 * @Author niujinpeng
 * @Date 2018/11/2518:19
 */
public interface ProducerService {
    public void sendMessage(String message);
}

2. 主题模式生产者

package net.codingme.jms.producer;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

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


/**
 * <p>
 *
 * @Author niujinpeng
 * @Date 2018/11/25 19:24
 */
public class ProducerServiceImpl implements ProducerService {

    @Autowired
    JmsTemplate jmsTemplate;
    /**
     * 主题模式
     */
    @Resource(name = "topicDestination")
    Destination destination;

    @Override
    public void sendMessage(String message) {
        // 使用jmsTemplate发送消息
        jmsTemplate.send(destination, new MessageCreator() {
            // 创建消息
            @Override
            public Message createMessage(Session session) throws JMSException {
                TextMessage textMessage = session.createTextMessage(message);
                return textMessage;
            }
        });
        System.out.println("发送消息：" + message);

    }
}

3. Spring 启动 生产者

package net.codingme.jms.producer;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * <p>
 * 启动器
 *
 * @Author niujinpeng
 * @Date 2018/11/25 21:48
 */
public class AppProducer {

    public static void main(String[] args) {
        // 装载配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:producer.xml");
        ProducerService service = context.getBean(ProducerService.class);

        for (int i = 0; i < 10; i++) {
            service.sendMessage("test" + i);
        }
        context.close();
    }

}

消费者编写

Spring启动和生产者类似。下面是消费者监听器的实现。

package net.codingme.jms.consumer;

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

/**
 * <p>
 * 消息监听器
 *
 * @Author niujinpeng
 * @Date 2018/11/25 22:28
 */
public class ConsumerMessageListener implements MessageListener {
    @Override
    public void onMessage(Message message) {
        TextMessage textMessage = (TextMessage) message;
        try {
            System.out.println("接收消息：" + textMessage.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

运行测试

首先主题模式下启动两个消费者，使用生产者推送10条消息。
测试
在每个消费者下面都可以看到推送的完整消息。
测试
文中代码已经上传到GitHub：https://github.com/niumoo/message-queue

<完>

Hello world : ) 我是阿朗，一线技术工具人，认认真真写文章。

点赞的个个都是人才，不仅长得帅气好看，说话还好听。

文章持续更新，可以关注公众号「 程序猿阿朗 」或访问「未读代码博客 」。

回复【资料】有我准备的各系列知识点和必看书籍。

本文 Github.com/niumoo/JavaNotes 已经收录，有很多知识点和系列文章，欢迎Star。

等你好久

程序猿阿朗
关注
专栏目录
java activemq连接池_使用ActiveMQ-pool建立的连接总是无任何征兆的自动关闭。
weixin_33260484的博客
02-23 1099
在消费者端使用PooledConnectionFactory建立与MQ服务器的连接，启动的时候初始化10个消费者。相关代码如下： protected JMSConnectionUtill(String MQ_LOCATION,String userName,String password) {this.MQ_LOCATION=MQ_LOCATION;this.userName=userName;t...
ActiveMQ 详解 （精）
nanZhaiXiaoLang的博客
06-04 3636
ActiveMQ JMS（Java Message Service） 它是一种与厂商无关的API，用来访问消息和收发系统消息。它类似于JDBC，JDBC是可以用来访问不同的关系型数 据库的API，而JMS则提供同样与厂商无关的访问消息收发服务的方法,这样就可以通过消息收发服务实现从一个JMS 客户端向另一个JMS客户端发送消息，所需要的是厂商支持JMS。换句话说，JMS是Java平台上有关面向消息中间件 的技术规范。 JMS提供的对象 连接工厂，是客户用来创建连接的对象，ActiveMQ提供的是Active
Kafka与RabbitMQ、ActiveMQ协议区别
heima201907的博客
04-24 240
对于Kafka与RabbitMQ、ActiveMQ协议，它们具体的区别如下： activemq： activemq支持主从复制、集群。但是集群功能看起来很弱，只有failover功能，即我连一个失败了，可以切换到其他的broker上。这一点貌似不太科学。假设有三个broker，其中一个上面没有consumer，但另外两个挂了，消息会转到这个上面来，堆...
ActiveMQ使用
dgush2000的博客
10-05 101
一、Windows安装ActiveMQ 1．下载解压 2．启动服务 二、Linux安装ActiveMQ 1．下载解压 2．启动访问 三、队列模式 1．创建maven项目 2．生产者 3．消费者 四、主题模式 1．修改队列名字 2．修改主题 五、Spring集成ActiveMQ 1．p...
消息中间件ActiveMQ详解
wx_l617188072的博客
07-14 336
一、消息中间件的介绍 介绍 ​消息队列是指利用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。 特点(作用) 应用解耦 异步通信 流量削峰 (海量)日志处理 消息通讯 …... 应用场景 根据消息队列的特点，可以衍生出很多场景，或者说很多场景都能用到。下面举几个例子： 1）异步通信 ​ 注册时的短信、邮件通知，减少响应时间； 2）应用解耦 ​ 信息发送者和消息接受者无需耦合，比如调用第三方； 3）流量削峰 ​ 例如秒杀系...
ActiveMq整合Spring
z1340954953
07-27 208
ActiveMq-config.xml文件创建 &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:amq="http://activemq.apache.org/...
实验三 消息中间件应用开发：ActiveMQ实现单线程多队列
05-13
本实验主要关注的是如何使用ActiveMQ这一开源的消息中间件来实现单线程多队列的场景。ActiveMQ是由Apache软件基金会开发的，它是Java消息服务（JMS）的实现，支持多种协议，并且可以跨平台运行。 【描述】：...
ActiveMQ RabbitMQ RokcetMQ 消息队列中间件视频教程
12-24
作为消息中间件的MQ在java开发中起着举足轻重的地位，无论是ActiveMQ、RabbitMQ、还是RokcetMQ至少要会一个，否则别说自己是java程序员。Java自学网整理了目前行业最常用的消息中间件视频供大家学习。
ActiveMQ RabbitMQ RokcetMQ Kafka实战 消息队列中间件视频教程
09-15
ActiveMQ RabbitMQ RokcetMQ Kafka实战 消息队列中间件视频教程
浅谈Java消息队列总结篇（ActiveMQ、RabbitMQ、ZeroMQ、Kafka）
08-25
3. 流量削锋：在秒杀或团抢活动中，使用消息队列控制活动的人数，缓解短时间内高流量压垮应用。 4. 日志处理：使用消息队列解决大量日志传输的问题，实现日志数据的接收、存储和转发。 5. 消息通讯：使用消息队列...
activemq-core-5.7.0-API文档-中文版.zip
04-08
赠送jar包：activemq-core-5.7.0.jar； 赠送原API文档：activemq-core-5.7.0-javadoc.jar； 赠送源代码：activemq-core-5.7.0-sources.jar； 包含翻译后的API文档：activemq-core-5.7.0-javadoc-API文档-中文(简体)版.zip 对应Maven信息：groupId：org.apache.activemq，artifactId：activemq-core，version：5.7.0 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
spring+activeMq的配置以及发送和接收
blog_csdn_lijun的博客
12-19 1005
1.发送目录结构 pom.xml配置文件 &lt;properties&gt; &lt;spring.version&gt;4.1.3.RELEASE&lt;/spring.version&gt; &lt;activemq-core.version&gt;5.7.0&lt;/activemq-core.version&gt; &lt;activemq-pool.version...
ActiveMQ的使用(一)
yaonianlong的专栏
12-03 532
ActiveMQ 是Apache出品的开源消息总线。完全支持JMS1.1规范 　　首先我们要了解一下JMS JMS简介 Java消息服务（Java Message Service，JMS）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提
springboot activemq关闭持久化不起作用
withwindluo的博客
12-09 1823
需要写jmsTemplate.setExplicitQosEnabled(true); @Bean public JmsTemplate jmsTemplate(ActiveMQConnectionFactory connectionFactory) { JmsTemplate jmsTemplate = new JmsTemplate(); jmsTemplate.setConnectionFactory(connectionFactory);
activemq使用PoolConnectionFactory中的问题与activemq jar版本问题
热门推荐
codeeee的博客
06-06 1万+
最近使用activemq来替代UDP进行消息的发送与接收，在整改项目中，踩了很多坑，为了给以后留下经验，总结了使用中遇到的问题。1 、 activemq的安装也遇到了一些问题，下次总结，总之流程时，先在官网上下载activemq在本地，根据电脑系统选择bin下对于的文件夹，点击activemq.bat批处理文件进行安装。安装完成后在浏览器打开 http://localhost:8161/admin...
Listener 监听器的简述与应用
Regino的博客
04-26 3654
本文介绍了 JavaWeb 中 Listener（监听器）的简述与应用的相关内容。。。
7.SpringBoot整合Kafka
扛麻袋的少年的博客
09-10 1387
1.引入Maven依赖 <!-- springboot整合kafka --> <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>...
Java消息队列深度解析：ActiveMQ、RabbitMQ、ZeroMQ、Kafka实战指南
对于异步处理，举例说明了用户注册时，通过使用消息队列将发送邮件和短信的任务异步化，避免了传统串行或并行处理可能导致的性能瓶颈。引入消息队列后，系统吞吐量显著提升，响应时间明显缩短。在应用解耦示例中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值