ActiveMQ学习总结——相关集成

最新推荐文章于 2024-04-18 14:04:19 发布
最新推荐文章于 2024-04-18 14:04:19 发布
阅读量199 收藏
点赞数
分类专栏： ActiveMq 文章标签： activemq spring spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChEnSL275/article/details/109679006
版权

ActiveMQ集成

一、ActiveMQ集成Spring

1. 创建项目

在这里插入图片描述

2. 配置POM

	<properties>
        <activemq.version>5.15.5</activemq.version>
        <slf4j.version>1.7.25</slf4j.version>
        <lombok.version>1.16.20</lombok.version>
        <spring.version>4.3.29.RELEASE</spring.version>
    </properties>
    <dependencies>
        <!--        ActiveMQ配置-->
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-all</artifactId>
            <version>${activemq.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-pool</artifactId>
            <version>${activemq.version}</version>
        </dependency>
        <!--        jms-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--        slf4j通用配置-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!--        lombok配置-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
    </dependencies>

3. 队列模式（Queue）

3.1 创建application-queue.xml

在这里插入图片描述

3.2 配置连接工厂
<bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory" destroy-method="stop">
    <property name="connectionFactory">
        <bean class="org.apache.activemq.ActiveMQConnectionFactory">
            <property name="brokerURL" value="tcp://**.**.**.**:61616"/>
        </bean>
    </property>
    <!-- 最大连接数 -->
    <property name="maxConnections" value="100"/>
</bean>
3.3 配置目的地
<bean id="destinationQueue" class="org.apache.activemq.command.ActiveMQQueue">
    <!--   使用构造方法的参数注入队列名称     -->
    <constructor-arg index="0" value="MQ-Queue"/>
</bean>
3.4 配置操作MQ对象的jmsTemplate
<bean id="JmsTemplate" class="org.springframework.jms.core.JmsTemplate">
    <!-- 注入工厂-->
    <property name="connectionFactory" ref="jmsFactory" />
    <!-- 注入消息发送的默认目的地-->
    <property name="defaultDestination" ref="destinationQueue" />
    <!--  消息转换器-->
    <property name="messageConverter">
        <bean lass="org.springframework.jms.support.converter.SimpleMessageConverter" />
    </property>
</bean>
3.5 生产者
public class QueueProducer {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application-queue.xml");
        JmsTemplate jmsTemplate= context.getBean(JmsTemplate.class);
//        发消息(发送到默认的目的地)
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
//                创建消息
                TextMessage message = session.createTextMessage("MQ-Spring-Queue");
                message.setStringProperty("String","StringProperty");
                return message;
            }
        });
        System.out.println("发送成功！");
    }
}
3.6 消费者
public class QueueConsumer {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application-queue.xml");
        JmsTemplate jmsTemplate= context.getBean(JmsTemplate.class);
        try {
// 如果不设置目的地，迷人监听的是默认的目的地 -jmsTemplate.receive(destination)->监听指定目的地
            TextMessage message = (TextMessage) jmsTemplate.receive();
            System.out.println("接收消息： "+message.getText()+" "+message.getStringProperty("String"));
        } catch (JMSException e) {
            e.printStackTrace();
        }
        /* 消息转换器接收
        Object o = jmsTemplate.receiveAndConvert();
        System.out.println(o);
         */
    }
}

4.主题/订阅模式（Topic）

4.1 修改目的地配置
<bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">
    <!--   使用构造方法的参数注入队列名称     -->
    <constructor-arg index="0" value="MQ-Topic"/>
</bean>
4.2 修改操作jmsTemplate对象配置
<bean id="JmsTemplate" class="org.springframework.jms.core.JmsTemplate">
    <!-- 注入工厂-->
    <property name="connectionFactory" ref="jmsFactory" />
    <!-- 注入消息发送的默认目的地-->
    <property name="defaultDestination" ref="destinationTopic" />
    <!--  消息转换器-->
    <property name="messageConverter">
        <bean lass="org.springframework.jms.support.converter.SimpleMessageConverter" />
    </property>
</bean>

5.监听器模式

5.1 创建Listener并集成MessageListener接口
// 监听器相当于消费者
public class ListenerHandler implements MessageListener {
    public void onMessage(Message message) {
        if (message instanceof TextMessage){
            try {
                System.out.println("监听器收到："+((TextMessage) message).getText());
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}
5.2 配置监听器对象
<bean id="listener" class="com.csl.listener.ListenerHandler" />
5.3 配置监听器容器
<bean id="queueListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="connectionFactory" ref="jmsFactory" />
    <property name="destination" ref="destinationQueue" />
    <property name="messageListener" ref="listener" />
</bean>

二、ActiveMQ集成SpringBoot

1. 创建项目

在这里插入图片描述

重点：

  • 在主程序上添加@EnableJms注解，即ActivemqSpringApplication
  • 添加@EnableScheduling注解，即开启延时

2. 配置POM

<dependencies>
<!--        mq-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-activemq</artifactId>
    </dependency>
<!--        devtools-热部署-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
<!--         configuration -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
<!--        lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
<!--        test-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

3. 队列模式（Queue）

3.1 配置application.yaml
spring:
  activemq:
    broker-url: tcp://**.**.**.**:61616
    user: admin
    password: admin
    pool:
      max-connections: 100
  jms:
    pub-sub-domain: false #false代表队列，true代表主题
#声明队列的名称
queue: activemq-boot-queue #@Value()
3.2 配置队列
@Component
public class QueueConfig {
    @Value("${queue}")
    private String queue;
    @Bean
    public Queue queue(){
        return new ActiveMQQueue(queue);
    }
}
3.3 生产者
@Component
public class QueueProducer {

    @Autowired
    private JmsMessagingTemplate jmsMessagingTemplate;
    @Autowired
    private Queue queue;

    @SuppressWarnings("deprecation")
    public void produceMsg(){
        jmsMessagingTemplate.convertAndSend(queue,"Queue-message==="+new Date().toString());
    }

    Integer i;
    /**
     * 延时发送
     */
    @SuppressWarnings("deprecation")
    @Scheduled(fixedDelay = 5000)
    public void producerMsgScheduled(){
        jmsMessagingTemplate.convertAndSend(queue,"****Queue-Scheduled***"+i++);
    }
}
3.4 消费者
@Service
public class QueueConsumer {

    @JmsListener(destination = "${queue}")
    public void receive(TextMessage message) throws JMSException {
        System.out.println("接收消息："+message.getText());
    }
}

监听到的延时发送的消息结果为：
在这里插入图片描述

4. 主题模式（Topic）

4.1修改application.yaml
	jms:
    	pub-sub-domain: true #false代表队列，true代表主题
#声明主题的名称
topic: activemq-boot-topic #@Value()
4.2 配置主题
@Component
public class TopicConfig {
    @Value("${topic}")
    private String topic;
    @Bean
    public Topic topic(){
        return new ActiveMQTopic(topic);
    }
}
4.3 生产者
@Component
public class TopicProducer {

    @Autowired
    private JmsMessagingTemplate jmsMessagingTemplate;
    @Autowired
    private Topic topic;
    @SuppressWarnings("deprecation")
    public void produceMsg(){
//        设置主题发送方式
        jmsMessagingTemplate.getJmsTemplate().setPubSubDomain(true);
        jmsMessagingTemplate.convertAndSend(topic,"Topic-message==="+new Date().toString());
    }

    Integer i=0;

    /**
     * 延时发送
     */
    @SuppressWarnings("deprecation")
    @Scheduled(fixedDelay = 5000)
    public void producerMsgScheduled(){
        jmsMessagingTemplate.getJmsTemplate().setPubSubDomain(true);
        jmsMessagingTemplate.convertAndSend(topic,"****Topic-Scheduled***"+i++);
    }
}
4.4 消费者
@Service
public class TopicConsumer {
    @JmsListener(destination = "${topic}")
    public void receive(TextMessage message) throws JMSException {
        System.out.println("接收消息："+message.getText());
    }
}

监听到的延时发送的消息结果为：
在这里插入图片描述

三、分布式集成(Web充当发送者及同时监听多个队列和主题)

1. 创建项目

在这里插入图片描述

2. 添加依赖

<properties>
        <activemq.version>2.3.5.RELEASE</activemq.version>
        <java.version>1.8</java.version>
        <lombok.version>1.18.16</lombok.version>
    </properties>

    <dependencies>
        <!--        mq-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-activemq</artifactId>
            <version>${activemq.version}</version>
        </dependency>

        <!--        devtools-热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <version>${activemq.version}</version>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <!--         configuration -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <version>${activemq.version}</version>
            <optional>true</optional>
        </dependency>
        <!--        lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </dependency>
        <!--        test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>${activemq.version}</version>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

3. 创建子项目-生产者(ActiveMQ-Producer)

在这里插入图片描述

重点：在主程序添加@EnableJms注解

3.1 导入父项目的依赖并添加Web模块的依赖
<parent>
    <artifactId>ActiveMQ-Parent</artifactId>
    <groupId>org.example</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.3.5.RELEASE</version>
    </dependency>
</dependencies>
3.2 配置application.yaml
spring:
  activemq:
    broker-url: tcp://**.**.**.**:61616
    user: admin
    password: admin
    pool:
      max-connections: 100
  jms:
    pub-sub-domain: false
3.3 Controller发送消息队列和主题
@RestController
@RequestMapping("/send")
public class ProducerController {

    @Autowired
    private JmsTemplate jmsTemplate;

    /**
     * 发送队列1
     * @return 返回成功信息
     */
    @RequestMapping("/sendQueue1")
    public Map<String,Object> sendQueue1(){
        Map<String,Object> map = new HashMap<String, Object>(12);
        jmsTemplate.setDefaultDestination(new ActiveMQQueue("queue-1"));
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                TextMessage message = session.createTextMessage("queue1-producer-msg");
                return message;
            }
        });
        map.put("success","发送成功！");
        return map;
    }

    /**
     * 发送队列2
     * @return 返回成功信息
     */
    @RequestMapping("/sendQueue2")
    public Map<String,Object> sendQueue2(){
        Map<String,Object> map = new HashMap<String, Object>(12);
        jmsTemplate.setDefaultDestination(new ActiveMQQueue("queue-2"));
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                TextMessage message = session.createTextMessage("queue2-producer-msg");
                return message;
            }
        });
        map.put("success","发送成功！");
        return map;
    }

    /**
     * 发送主题1
     * @return 返回成功信息
     */
    @RequestMapping("/sendTopic1")
    public Map<String,Object> sendTopic1(){
        Map<String,Object> map = new HashMap<String, Object>(12);
        jmsTemplate.setDefaultDestination(new ActiveMQTopic("topic-1"));
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                TextMessage message = session.createTextMessage("topic1-producer-msg");
                return message;
            }
        });
        map.put("success","发送成功！");
        return map;
    }

    /**
     * 发送主题2
     * @return 返回成功信息
     */
    @RequestMapping("/sendTopic2")
    public Map<String,Object> sendTopic2(){
        Map<String,Object> map = new HashMap<String, Object>(12);
        jmsTemplate.setDefaultDestination(new ActiveMQTopic("topic-2"));
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                TextMessage message = session.createTextMessage("topic2-producer-msg");
                return message;
            }
        });
        map.put("success","发送成功！");
        return map;
    }
}

4. 创建子项目-消费者(ActiveMQ-Consumer)

在这里插入图片描述

重点：在主程序添加@EnableJms注解

4.1 导入父项目的依赖
<parent>
    <artifactId>ActiveMQ-Parent</artifactId>
    <groupId>org.example</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
4.2 配置application.yaml
spring:
  activemq:
    broker-url: tcp://**.**.**.**:61616
    user: admin
    password: admin
    pool:
      max-connections: 100
  jms:
    pub-sub-domain: false
4.3 配置主题创建工厂（队列默认为false,可以不用配置）
@Configuration
public class JmsContainerFactoryConfig {

    @Bean("jmsTopicContainerFactory")
    public DefaultJmsListenerContainerFactory listenerTopicContainer(@Qualifier("jmsConnectionFactory") ConnectionFactory connectionFactory) {
        DefaultJmsListenerContainerFactory container = new DefaultJmsListenerContainerFactory();
        container.setConnectionFactory(connectionFactory);
//        设置对主题的监听（false为队列，true为主题）
        container.setPubSubDomain(true);
        return container;
    }
}
4.4 创建消息监听
@Component
public class MsgListener {

    /**
     * 监听队列1
     * containerFactory可以不配置--》因为默认监听队列
     * @param message
     * @throws JMSException
     */
    @JmsListener(destination = "queue-1")
    public void getQueue1(TextMessage message) throws JMSException {
        System.out.println("接收消息："+message.getText());
    }

    /**
     * 监听队列2
     * @param message
     * @throws JMSException
     */
    @JmsListener(destination = "queue-2")
    public void getQueue2(TextMessage message) throws JMSException {
        System.out.println("接收消息："+message.getText());
    }

    /**
     * 监听主题1
     * @param message message
     * @throws JMSException
     */
    @JmsListener(destination = "topic-1",containerFactory = "jmsTopicContainerFactory")
    public void getTopic1(TextMessage message) throws JMSException {
        System.out.println("接收消息："+message.getText());
    }

    /**
     * 监听主题2
     * @param message
     * @throws JMSException
     */
    @JmsListener(destination = "topic-2",containerFactory = "jmsTopicContainerFactory")
    public void getTopic2(TextMessage message) throws JMSException {
        System.out.println("接收消息："+message.getText());
    }
}
橙大西瓜也
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring和ActiveMQ整合的完整实例
06-19
Spring和ActiveMQ整合的完整实例
ActiveMQ集成
weixin_43708218的博客
08-02 210
1 依赖导入和配置 xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </dependency> application.yml 配置文件中，对 activemq 做一下配置： spring: activemq: # activemq url
集成消息队列ActiveMQ
最新发布
weixin_48166564的博客
04-18 854
本例为本地操作消息队列，故需要本地安装。1、本地安装ActiveMQ。（2）、解压后，根据电脑操作系统是32位或者64位选择对应的activemq.，启动ActiveMQ。启动成功，则显示如下内容（3）、成功之后在浏览器输入http://127.0.0.1:8161/地址，可以看到ActiveMQ的管理页面，用户名和密码默认都是admin2、springboot项目中使用（1）、添加pom依赖如下（本例调用junit测试，如果不用junit测试，可忽略junit的依赖）
activemq集成
w_t_y_y的博客
04-02 312
一、activemq环境搭建： 1、安装：官网http://activemq.apache.org/download.html，我这里下载的是windows的，windows的比较简单，下载后解压，进入bin目录双击bat文件即可启动服务： 2、管理后台：浏览器输入http://localhost:8161/，弹框输入用户名密码，初始值均为admin 二、应用：一个简单的acti...
activeMq集成
yuhui666666的博客
08-15 114
activeMq集成： mq类似redis安装好了软件之后，就在java端集成，用工厂工具类调用，mq用于消息推送（结合页面的轮询做聊天工具），结合redis缓解高并发压力---来不及处理的放在队列中， 多系统的事务回滚通知   pom.xml &lt;!-- activemq相关依赖 --&gt; &lt;dependency&gt; &lt;groupId&gt;javax.j...
ActiveMQ集成Spring
点滴记录
04-14 510
一、环境准备 这里以 Maven 作为项目管理工具来创建工程。 项目目录结构： 1.1在pom.xml中添加依赖： &amp;lt;properties&amp;gt; &amp;lt;spring-version&amp;gt;4.3.9.RELEASE&amp;lt;/spring-version&amp;gt; &amp;lt;/properties&amp;gt; &am
ActiveMQ学习总结
02-24
1.在网络通讯中，Http请求默认采用同步请求方式，基于请求与响应模式2....目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ实现方式:面向消息的中间件(MessageOrlentedMiddlewareMO
ActiveMQ——Java连接ActiveMQ
02-24
发布/订阅消息传递域的特点如下：（1）生产者将消息发布到topic中，每个消息可以有多个消费者，属于1：N关系（2）生产者和...启动ActiveMQ之后访问http://localhost:8161/admin/topics.jsp，此时的Topic中什么也没有先
ActiveMQ——Broker
01-27
相当于一个ActiveMQ服务器实例 说白了，Broker其实就是实现了用代码的形式启动ActiveMQ将MQ嵌入到Java 代码中，以便随时用随时启动，在用的时候再去启动这样能节省了资源，也保证了可靠性在conf里面拷贝一个activemp...
Spring Boot 2.0.3 集成 ActiveMQ 5.15.4 与 内嵌启动 ActiveMQ 服务
蚩尤后裔-汪茂雄
10-12 3392
目录 ActiveMQ 5.15.4 集成 Spring Boot 2.0.3 pom.xml 依赖 application.yml 配置 @JmsListener 接收消息 JmsTemplate 发送消息 运行测试 内嵌启动 ActiveMQ 服务 ActiveMQ 5.15.4 集成 Spring Boot 2.0.3 1、SpringBoot 提供了对 JMS 的支持，对...
Spring与ActiveMQ的集成详解一
Donald_Draper
01-02 213
JMS(ActiveMQ) PTP和PUB/SUB模式实例：[url]http://donald-draper.iteye.com/blog/2347445[/url] ActiveMQ连接工厂、连接详解:[url]http://donald-draper.iteye.com/blog/2348070[/url] ActiveMQ会话初始化:[url]http://donald-draper....
Spring与ActiveMQ整合完整案例
04-03
Spring与ActiveMQ整合完整案例，详情请参见博文：http://blog.csdn.net/l1028386804/article/details/68979725
ActiveMQ入门实例
weixin_33827965的博客
02-21 186
1.下载ActiveMQ 去官方网站下载：http://activemq.apache.org/ 2.运行ActiveMQ 解压缩apache-activemq-5.5.1-bin.zip，然后双击apache-activemq-5.5.1\bin\activemq.bat运行ActiveMQ程序。 启动ActiveMQ以后，登陆：http://localhost:8161/admin/，...
activemq系列（4）-activemq集成spring
java小白成长博客
01-31 431
1、新建maven项目，以下是需要依赖的pom文件： <properties> <org.springframework.version>4.3.7.RELEASE</org.springframework.version> <springjunit.version>4.12</springjunit.version> &...
SpringMVC集成ActiveMQ案例实战
Peter_Changyb的博客
08-05 2807
导入jar包activemq-all-5.9.1.jar 在网上下载apache-activemq-5.10.0服务端到D:\apache-activemq-5.10.0下面。 在本地的系统中配置activemq的环境变量 在系统变量中添加：变量名：ACTIVEMQ_HOME；变量值：D:\apache-activemq-5.10.0\apache-activemq-5.10.0 在系统变量...
Spring+activeMq集成详解
sunnyliuqi的专栏
06-13 350
1.      下载ActiveMQ并安装到服务器上 http://activemq.apache.org/ 解压后，根据系统进入对应的目录且执行相应的文件。运行后访问地址 http://localhost:8161/admin/，账户和密码都是admin，效果如下： 2.       Maven 架包依赖 dependency>   groupId>org.springframe
Springboot实战15 消息驱动：如何使用 JmTemplate 集成 ActiveMQ？
sucaiwa的博客
04-09 837
14 讲我们介绍了基于 Kafka 和 KafkaTemplate 实现消息发送和消费，并重构了 SpringCSS 案例系统中的 account-service 和 customer-service 服务。今天，我们继续介绍 ActiveMQ，并基于 JmsTemplate 模板工具类为 SpringCSS 案例添加对应的消息通信机制。
Activemq
爱折腾的Albert
03-22 220
1. 什么是Activemq 1.1 什么是mq 维基百科： 在计算机科学中，消息队列（英语：Message queue）是一种进程间通信或同一进程的不同线程间的通信方式，软件的贮列用来处理一系列的输入，通常是来自用户。消息队列提供了异步的通信协议，每一个贮列中的纪录包含详细说明的数据，包含发生的时间，输入设备的种类，以及特定的输入参数，也就是说：消息的发送者和接收者不需要同时与消息队列交互。消...
ActiveMQ
q1015189243的博客
08-24 246
启动/关闭 /bin下 ：./activemq start/stop 带日志启动：./activemq start > /myactiveMQ/myrumq.log activemq得默认进程端口61616 控制台端口8161 http://192.168.74.138:8161/admin 默认登录用户名密码都是admin JMS总体架构 目的地Destination: 在点对点的消息传递域中，目的地被称为队列(queue) 在发布订阅消息xxxxxxxxxxxxxxxxxxxxxxxx主题(to
activemq topic cpu高_Java学习之——ActiveMQ
05-23
如果你在使用 ActiveMQ 的时候发现 CPU 占用率过高，那么可能是以下原因导致的： 1. 消息消费者数量过多，导致消息处理的压力过大，从而导致 CPU 占用率升高。 2. 消息生产者发送速度过快，导致消息堆积，从而导致...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值