ActiveMQ(artemis版) 基本安装与Spring JMS基本使用

最新推荐文章于 2024-08-07 09:00:28 发布
最新推荐文章于 2024-08-07 09:00:28 发布
阅读量6.6k 收藏 6
点赞数 1
分类专栏： spring activemq 文章标签： activemq spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/somnus252/article/details/105094723
版权

引言

使用artemis版本MQ。Spring JMS 使用springframework-mvc架构，传统xml配置，部署到tomcat运行。如果采用springboot将更简单。有空将更新成springboot

ActiveMQ基本安装与使用

注： ActiveMQ下载的artemis版本，与之前的ActiveMQ版本有点区别，

下载ActiveMQ

下载地址 https://activemq.apache.org/index.html

在这里插入图片描述在这里插入图片描述## 安装ActiveMQ

  1. apache-artemis-2.11.0.bin.tar.gz解压该文件
  2. 进入cd apache-artemis-2.11.0/bin目录
  3. 运行一下脚本，创建一个实例，自动在software目录下生成一个myInstance目录，
./artemis create /Users/somnus/Documents/software/myInstance
# ./artemis create /Users/somnus/Documents/software/myInstance

在这里插入图片描述

  1. 运行activemq
cd ./artemis create /Users/somnus/Documents/software/myInstance/bin
./artemis run  #运行activemq

在这里插入图片描述5.通过浏览器访问activemq控制台
地址 http://localhost:8161/
在这里插入图片描述6. 进入控制台Management Console
路径：http://localhost:8161/console/login，记不住，直接http://localhost:8161通过点击进入

dfsdfds
在这里插入图片描述

Spring JMS项目

项目POM配置

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>
        <!-- 用于消息转换 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.10.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- jms客户端-->
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>artemis-jms-client</artifactId>
            <version>2.11.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jms -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>

    </dependencies>

web.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
<!--    <listener>-->
<!--        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>-->
<!--    </listener>-->
    <!-- 默认加载 /WEB-INF/applicationContext.xml-->
<!--    <context-param>-->
<!--        <param-name>contextConfigLocation</param-name>-->
<!--        <param-value>/WEB-INF/applicationContext.xml</param-value>-->
<!--    </context-param>-->
    <servlet>
        <servlet-name>app</servlet-name>
        <!-- 默认加载 namespace-servlet.xml配置文件 
        这里是app-servlet.xml -->
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>app</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

springmvc配置

配置文件名：app-servlet.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:mvc="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
        <mvc:component-scan base-package="com.teachayu.activemq" />

        <!-- 链接工厂 -->
        <bean id="connectionFactory" class="org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory" />

        <!-- 缓存JMS工厂 -->
        <bean id="cachingConnectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
                <property name="targetConnectionFactory" ref="connectionFactory"/>
        </bean>

        <!-- jms消息转换器 JmsTemplate发送与接收 -->
        <bean id="messageConverter" class="org.springframework.jms.support.converter.MappingJackson2MessageConverter" >
                <property name="typeIdPropertyName" value="test" />
                <property name="typeIdMappings" >
                        <map>
                                <entry key="test" value="com.teachayu.activemq.controller.UserEntity"/>
                        </map>
                </property>
        </bean>
        <!--点对点 文本消息发送模板 -->
        <bean id="pointJmsTemplate" class="org.springframework.jms.core.JmsTemplate" >
                <constructor-arg ref="connectionFactory"></constructor-arg>
                <!-- 定义默认队列-->
                <property name="defaultDestinationName" value="test"/>
                <property name="messageConverter"  ref="messageConverter"/>
                <!--pubSubDomain true: Publish/Subscribe  false: Point-to-Point-->
                <!-- 默认 Point-to-Point  -->
                <property name="pubSubDomain" value="false" />
        </bean>
        <!-- 文本消息监听器 接收文本消息 -->
        <bean id="receiveListener" class="com.teachayu.activemq.controller.TextReceiveListener"></bean>
        <!--接收文本消息 -->
        <bean id="defaultMessageListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
                <property name="messageListener" ref="receiveListener"/>
                <property name="messageConverter" ref="messageConverter"/>
                <property name="destinationName" value="test"/>
                <property name="connectionFactory" ref="connectionFactory"/>
        </bean>

        <!-- 对象消息转换器 -->
        <bean id="pojoMessageConverter" class="com.teachayu.activemq.controller.PojoMessageConverter"/>
        <!--点对点 发送消息 使用另一个转换器，基于对象-->
        <bean id="pojoJmsTemplate" class="org.springframework.jms.core.JmsTemplate" >
                <constructor-arg ref="connectionFactory"></constructor-arg>
                <!-- 定义默认队列-->
                <property name="defaultDestinationName" value="test"/>
                <property name="messageConverter"  ref="pojoMessageConverter"/>
                <!--pubSubDomain true: Publish/Subscribe  false: Point-to-Point-->
                <!-- 默认 Point-to-Point  -->
                <property name="pubSubDomain" value="false" />
        </bean>
        <!-- 对象消息监听器 -->
        <bean class="com.teachayu.activemq.controller.Pojo1ReceiveListener" id="pojo1ReceiveListener"/>
        <!-- 接收对象消息 -->
        <!--把消息监听器注册到 -->
        <!-- SimpleMessageListenerContainer -->
        <bean class="org.springframework.jms.listener.SimpleMessageListenerContainer" >
                <property name="connectionFactory" ref="connectionFactory"/>
                <property name="destinationName" value="pojo1"/>
                <property name="messageConverter" ref="pojoMessageConverter"/>
                <property name="messageListener" ref="pojo1ReceiveListener"/>
        </bean>

        <!--发布与订阅 -->
        <bean id="pubJmsTemplate" class="org.springframework.jms.core.JmsTemplate" >
                <property name="connectionFactory" ref="cachingConnectionFactory"/>
                <!-- 定义默认队列-->
                <property name="defaultDestinationName" value="pub"/>
                <property name="messageConverter"  ref="pojoMessageConverter"/>
                <!--pubSubDomain true: Publish/Subscribe  false: Point-to-Point-->
                <!-- 默认 Point-to-Point  -->
                <property name="pubSubDomain" value="true" />
        </bean>
        <!-- 订阅消息 Subscribe1Listener -->
        <bean class="com.teachayu.activemq.controller.Subscribe1Listener" id="subscribe1Listener"/>
        <!-- 订阅消息 Subcribe2Listener -->
        <bean class="com.teachayu.activemq.controller.Subscribe2Listener" id="subscribe2Listener"/>
        <bean id="listenerContainer1" class="org.springframework.jms.listener.SimpleMessageListenerContainer">
                <!-- pubSubDomain true:发布订阅模式 -->
                <property name="pubSubDomain" value="true"/>
                <property name="destinationName" value="pub"/>
                <property name="messageListener" ref="subscribe1Listener"/>
                <property name="messageConverter" ref="pojoMessageConverter"/>
                <property name="connectionFactory" ref="cachingConnectionFactory"/>
        </bean>
        <bean id="listenerContainer2" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
                <!-- pubSubDomain true:发布订阅模式 -->
                <property name="pubSubDomain" value="true"/>
                <property name="messageListener" ref="subscribe2Listener"/>
                <property name="messageConverter" ref="pojoMessageConverter"/>
                <property name="destinationName" value="pub"/>
                <property name="connectionFactory" ref="cachingConnectionFactory"/>
        </bean>
        
        <!--http请求转json -->
        <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
                <property name="messageConverters">
                        <list>
                                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                                        <property name="supportedMediaTypes">
                                                <list><value>text/html;charset=UTF-8</value>
                                                      <value>application/json;charset=UTF-8</value>
                                                </list>
                                        </property>
                                </bean>
                        </list>
                </property>
        </bean>

</beans>

消息转换器 与实体类

定义PojoMessageConverter消息转换器，将Object转成ObjectMessage消息，或将ObjectMessage消息转成Object。Object将实现Serializable接口

package com.teachayu.activemq.controller;
import org.springframework.jms.support.converter.MessageConversionException;
import org.springframework.jms.support.converter.MessageConverter;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import java.io.Serializable;
public class PojoMessageConverter implements MessageConverter {
    @Override
    public Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
        return session.createObjectMessage((Serializable) object);

    }
    @Override
    public Object fromMessage(Message message) throws JMSException, MessageConversionException {
        return ((ObjectMessage)message).getObject();
    }
}

实体类，用于测试

package com.teachayu.activemq.controller;
import java.io.Serializable;
public class UserEntity implements Serializable {
    private String name;
    private int age;
    private String address;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "UserEntity{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

生产者

发送消息与发布消息，通过http://localhost:8080/activemq/send 完成简单消息推送

package com.teachayu.activemq.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

/**
 * 使用Point-to-Point模式发送消息
 * 使用Publish/Subscribe 模式发布消息
 */
@RestController
public class ProducerController {
    /**
     * 发送文本消息模板 Point-to-Point
     * MappingJackson2MessageConverter转换器
     */
    private JmsTemplate jmsTemplate;

    /**
     * 发送对象消息 Point-to-Point
     * PojoMessageConverterz转换器
     */
    private JmsTemplate pojoJmsTemplate;

    /**
     * 发布对象消息  Publish/Subscribe
     * PojoMessageConverterz转换器
     */
    private JmsTemplate pubJmsTemplate;
    @RequestMapping("/send")
    public String send(){
        /**
         *  Point-to-Point 模式
         *  使用默认队列发送消息
         *  使用JmsTemplate同步接收
         */

        jmsTemplate.send(new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                //发送TextMessage消息
                return  session.createTextMessage("text队列发送消息(接收同步)："+System.currentTimeMillis());
            }
        });
        /**
         * Point-to-Point 模式
         * 使用默认队列发送消息
         * 异步接收 MessageListener
         */
        jmsTemplate.send("text1", new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                //发送TextMessage消息
                return  session.createTextMessage("text1队列发送消息(接收异步)"+System.currentTimeMillis());
            }
        });

        /**
         * Point-to-Point  模式
         * 使用定义的转换器
         *  org.springframework.jms.support.converter.MappingJackson2MessageConverter
         *  使用pojo队列发送消息
         *  使用JmsTemplate同步接收
         */
        UserEntity userEntity = new UserEntity();
        long l = System.currentTimeMillis();
        userEntity.setName("张三"+l);
        userEntity.setAddress("地址"+l);
        userEntity.setAge(1);
        jmsTemplate.convertAndSend("pojo",userEntity);

        /**
         * Point-to-Point 模式
         * 使用定义的转换器 com.teachayu.activemq.controller.PojoMessageConverter
         * 使用pojo队列发送消息
         * 异步接收 MessageListener
         */
        userEntity = new UserEntity();
        l = System.currentTimeMillis();
        userEntity.setName("张三"+l);
        userEntity.setAddress("地址"+l);
        userEntity.setAge(1);
        pojoJmsTemplate.convertAndSend("pojo1",userEntity);

        /**
         * Publish/Subscribe 模式
         * 发布消息
         * 默认队列 pub  ,配置文件中
         */
        userEntity = new UserEntity();
        l = System.currentTimeMillis();
        userEntity.setName("张三"+l);
        userEntity.setAddress("地址"+l);
        userEntity.setAge(1);
        pubJmsTemplate.convertAndSend("pub",userEntity);

        return "hello";
    }

    @Autowired
    @Qualifier("pointJmsTemplate")
    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    @Autowired
    @Qualifier("pojoJmsTemplate")
    public void setPojoJmsTemplate(JmsTemplate pojoJmsTemplate) {
        this.pojoJmsTemplate = pojoJmsTemplate;
    }

    @Autowired
    @Qualifier("pubJmsTemplate")
    public void setPubJmsTemplate(JmsTemplate pubJmsTemplate) {
        this.pubJmsTemplate = pubJmsTemplate;
    }
}

同步消费者

同步接收消息，是阻塞模式，通过http://localhost:8080/activemq/receive接收消息。
注意：一定要先执行send请求，完成消费发送，不是receive请求将阻塞

package com.teachayu.activemq.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.jms.JMSException;
import javax.jms.TextMessage;

/**
 * 阻塞模式接收消息
 */
@RestController
public class CustomerController {

    private JmsTemplate jmsTemplate;
    @RequestMapping("receive")
    public UserEntity receive() throws JMSException {
        //阻塞接收消息，默认队列，队列中无消息将阻塞
        TextMessage message = (TextMessage)jmsTemplate.receive();
        System.out.println("接收test队列："+message.getText());
        //阻塞接收消息，pojo队列，队列中无消息将阻塞
        UserEntity userEntity = (UserEntity)jmsTemplate.receiveAndConvert("pojo");
        System.out.println("接收pojo队列消息"+ userEntity);
        return userEntity;

    }
    @Autowired
    @Qualifier("pointJmsTemplate")
    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }
}

异步接收消息，监听模式

采用监听模式接收消息，有消息来将自动获取消息

文本消息接收

package com.teachayu.activemq.controller;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
/**
 * 监听接收消息
 */
public class TextReceiveListener implements MessageListener {
    @Override
    public void onMessage(Message message) {
        try {
            String text = ((TextMessage) message).getText();
            System.out.println("接收到test队列消息:"+text);
        } catch (JMSException e) {
            e.printStackTrace();
        }

    }
}

对象消息接收

package com.teachayu.activemq.controller;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
/**
 * 队列监听器 pojo1队列
 * PojoMessageConverter完成转换
 */
public class Pojo1ReceiveListener implements MessageListener {
    @Override
    public void onMessage(Message message) {
        try {
            UserEntity userEntity = (UserEntity)  ((ObjectMessage) message).getObject();
            System.out.println("接收pojo1队列消息:"+ message);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

订阅消息 监听模式

Subscribe1Listener 订阅pub主题消息

package com.teachayu.activemq.controller;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
/**
 * 订阅消息
 */
public class Subscribe1Listener implements MessageListener {
    @Override
    public void onMessage(Message message) {
        UserEntity userEntity = null;
        try {
            userEntity = (UserEntity) ((ObjectMessage) message).getObject();
        } catch (JMSException e) {
            e.printStackTrace();
        }
        System.out.println("Subscribe1Listener订阅pub队列消息:" + userEntity);
    }
}

Subscribe2Listener 订阅pub主题消息

package com.teachayu.activemq.controller;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
/**
 * 订阅消息
 */
public class Subscribe2Listener implements MessageListener {
    @Override
    public void onMessage(Message message) {
        UserEntity userEntity = null;
        try {
            userEntity = (UserEntity) ((ObjectMessage) message).getObject();
        } catch (JMSException e) {
            e.printStackTrace();
        }
        System.out.println("Subscribe2Listener订阅pub队列消息:" + userEntity);
    }
}

测试

前提是运行activemq与springJMS项目，将可以进行以下测试。测试就不截图了。

发送消息

通过浏览器访问 http://localhost:8080/activemq/send 将完成所有消息发送。

接收消息

  1. 采用MessageListener方式在控制台自动打印接收到消息
  2. 通过访问http://localhost:8080/activemq/receive接收text与pojo队列消息

参考资料

https://docs.spring.io/spring/docs/5.2.5.RELEASE/spring-framework-reference/integration.html#remoting-jms

http://localhost:8161/user-manual/index.html #该地址是安装activemq之后访问可以看到。
或者通过以下官网地址查看文档
https://activemq.apache.org/components/artemis/documentation/

Somnu333
关注
专栏目录
Spring In Action 5 学习笔记 chapter8 JMS(ActiveMQ Artemis)要点
既然选择了远方，便只顾风雨兼程
09-30 671
本文记录Sping In Action5 第8章 发送异步消息JMS(ActiveMQ Artemis)中的踩坑情况。第8章的源码请自行github或gitee搜索，或参考一下。
activemq-artemis, Apache Artemis的镜像.zip
10-11
activemq-artemis, Apache Artemis的镜像 ActiveMQ Artemis这个文件描述了在这个项目中开始编码的一些最小'需要知道的东西'。源有关修改代码。构建项目。运行测试。IDE集成的详细信息，请参见我们的黑客指南( ) 。构建异步IO库ActiveMQ Artemi
Apache ActiveMQ Artemis 控制台安装与使用指南
最新发布
gitblog_00038的博客
08-07 484
Apache ActiveMQ Artemis 控制台安装与使用指南 activemq-artemis-consoleApache ActiveMQ Artemis Console项目地址:https://gitcode.com/gh_mirrors/ac/activemq-artemis-console 目录结构及介绍 Apache ActiveMQ Artemis控制台是基于Hawt.io构...
Apache ActiveMQ Artemis简介
咖啡壶的博客
06-15 3265
Apache ActiveMQ Artemis 的简介
Activemq Artemis jmx使用
xiangshui021的博客
05-16 451
1.修改 目录/mybroker/etc/broker.xml 修改: <name>myartemis</name>(后面会用) 加入2行 <jmx-management-enabled>true</jmx-management-enabled> <jmx-domain>my.org.apache.activemq</jmx-domain>(后面会用) 2.生成mybroker文件夹里面 目录/mybroker/...
ActiveMQ|02-Artemis服务部署
c_zyer的博客
01-26 1687
Linux环境下部署：下载源码包，解压、配置并启动，创建Broker实例，启动实例，修改配置，管理后台 Docker环境下部署：获取镜像，启动服务
Kubernetes activemq系列| k8s 部署activemq artemis 集群（可外部通信）
weixin_48711696的博客
03-12 716
Apache ActiveMQ Artemis 是一个高性能的开源消息代理，它完全符合 Java Message Service (JMS) 2.0 规范，并支持多种通信协议，包括 AMQP、MQTT、STOMP 和 OpenWire 等。ActiveMQ Artemis 由 Apache Software Foundation 开发和维护，旨在提供可靠的消息传递解决方案，适用于各种异步通信场景。bin- 运行 ActiveMQ Artemis 所需的二进制文件和脚本。examples- 各种例子。
Apache ActiveMQ Artemis.pdf
04-07
19. Apache Karaf, Spring Integration, CDI Integration：描述了如何将ActiveMQ Artemis与Apache Karaf，Spring和CDI进行集成。 20. Maven插件、单元测试、嵌入式ActiveMQ Artemis：涵盖了如何使用Maven插件，如何...
spring-jms：Spring JMS教程
01-29
Spring Boot与Spring JMS的结合使得配置变得更加简单，只需几行代码即可快速启动和运行JMS应用。 ### 2. JMS基础 JMS是一种标准API，用于在分布式环境中交换消息。它定义了生产者（发送消息）和消费者（接收消息）...
mac上安装ActiveMQ Artemis
TRAVEL0101的博客
01-03 644
mac上安装ActiveMQ Artemis 缘由 我在看《spring实战》这本书的第8章异步发送消息的JMS部分时，添加好pom文件的依赖后，书上说了自己安装artemis，他就不赘述了。我想这应该不难，然后我就在网上搜了下“如何在mac上安装artemis“，然后就出现了一堆”在windows上安装artemis““mac如何在docker上安装artemis”“mac上安装ActiveMQ”。。。就是没有出现我想要的东西。然后我就尝试这用windows的方式在mac上安装artemis,最后就慢慢摸
ActiveMQ-Artemis .pdf
08-08
18. **嵌入式代理和集成技术**：提供了如何将ActiveMQ Artemis嵌入到不同的应用程序服务器和框架中，以及如何使用CDI、Spring等集成技术。 19. **操作拦截、数据工具和Maven插件**：介绍了操作拦截以及如何使用数据...
activemq-artemis：Apache ActiveMQ Artemis的镜像
02-03
ActiveMQ阿耳s弥斯 该文件描述了一些最低的“需要了解的东西”，以开始在该项目中进行编码。 资源 有关修改代码，构建项目，运行测试，IDE集成等的详细信息，请参见《 。 建立状态 建立状态： 建立ASYNC IO库 ActiveMQ Artemis提供了两种日志持久性类型：NIO（使用Java NIO库）和ASYNCIO，与Linux内核libaio库进行交互。 应尽可能使用ASYNCIO日志类型，因为它在性能方面要优越得多。 ActiveMQ Artemis在源代码发行版中不附带Artemis Native ASYNCIO库。 需要在运行“ mvn install”之前构建它们，以确
spring使用activeMQ
01-08
9. **Spring Boot 集成**：在 Spring Boot 项目中，可以使用 starter-jms 或 starter-artemis（ActiveMQ Artemis 版本）依赖，简化配置，自动配置 JMS 相关组件。 在提供的文件名 "consumer" 和 "producer" 中，...
activemq Artemis笔记
ywb201314的专栏
02-20 777
Queue 是和Address关联的,Address对Queue是一对多的关系，当对应于一个Address的消息到来时，消息讲发送给Address的一个或多个Queue(取决于Routing Types的配置),Queue同时可以配置成自动创建和删除。消息{1,2,3,4,5}依次发送到address.foo的Q1,Consumer 1 & Consumer 2 共同消息Q1的一部分消息,Consumer 1 & Consumer 2之间的负载取决于Artemis的负责策略。
ActiveMQ Artemis 系列| High Availability 主备模式（消息复制） 版本2.19.1
weixin_48711696的博客
03-27 1082
Apache ActiveMQ Artemis 是一个高性能的开源消息代理，它完全符合 Java Message Service (JMS) 2.0 规范，并支持多种通信协议，包括 AMQP、MQTT、STOMP 和 OpenWire 等。ActiveMQ Artemis 由 Apache Software Foundation 开发和维护，旨在提供可靠的消息传递解决方案，适用于各种异步通信场景。共享存储。
ActiveMq与Artemis
f2634825250的博客
11-18 3360
文章目录一. 配置 一. 配置 ActiveMq的spring application.yml配置
新一代ActiveMQ —— Apache ActiveMQ Artemis
weixin_30794851的博客
07-26 2109
资料： .net demo : https://github.com/apache/activemq-artemis/tree/master/examples/protocols/amqp/dotnet AMQP 1.0 .NET Library:https://github.com/Azure/amqpnetlite,https://github.com/Azure/amqpnetlit...
ActiveMQ Artemis-点对点模式
不务正业的猿
10-11 343
ActiveMQ Artemis-点对点模式
CentOS8安装ActiveMQ Artemis
rwzhang的博客
05-21 709
1、下载安装包https://activemq.apache.org/components/artemis/download/，选择tar.gz格式的安装包apache-artemis-2.17.0-bin.tar.gz 2、解压文件：tar -zvxf apache-artemis-2.17.0-bin.tar.gz 3、新建一个broker目录（尽量不要和artemis应用放在一起），进入该目录准备创建broker 4、执行命令创建broker：/artemis的解压目录/bin/artemis
jms工厂是spring的还是activemq的
06-03
JMS工厂（JMS Connection Factory）是JMS规范中的概念，它是用来创建JMS Connection（即JMS连接）的工厂类。在使用JMS时，我们需要先创建一个JMS连接，然后使用这个连接来创建JMS会话（JMS Session），最后使用JMS会话来发送和接收JMS消息。 针对不同的JMS消息中间件，我们需要使用不同的JMS Connection Factory。在使用ActiveMQ时，我们可以使用ActiveMQ提供的ActiveMQConnectionFactory来创建JMS连接。 而在Spring JMS框架中，我们可以使用Spring提供的ConnectionFactory来创建JMS Connection Factory。Spring提供了多个ConnectionFactory的实现类，例如： - ActiveMQConnectionFactory：用于创建ActiveMQ的JMS Connection Factory。 - CachingConnectionFactory：用于创建基于缓存的JMS Connection Factory。 - SingleConnectionFactory：用于创建单例的JMS Connection Factory。 在Spring Boot中，我们可以通过配置文件来配置JMS Connection Factory，例如： ``` spring.activemq.broker-url=tcp://localhost:61616 spring.jms.pub-sub-domain=false spring.jms.template.default-destination=example.queue ``` 在上面的配置中，我们指定了ActiveMQ的地址和端口号，以及默认的JMS目的地（即消息队列或主题）。 总之，JMS Connection Factory是JMS规范中的概念，用于创建JMS连接。在使用ActiveMQ时，我们可以使用ActiveMQ提供的ActiveMQConnectionFactory来创建JMS Connection Factory。在Spring JMS框架中，我们可以使用Spring提供的ConnectionFactory来创建JMS Connection Factory，也可以使用其他第三方提供的JMS Connection Factory。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值