Spring framework(10)：集成 JMS 异步消息队列（ActiveMQ）

最新推荐文章于 2022-01-19 00:13:19 发布
最新推荐文章于 2022-01-19 00:13:19 发布
阅读量689 收藏
点赞数
分类专栏： Spring4 Spring / Spring MVC 学习小结 文章标签： spring JMS activemq topic 订阅持久化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/al_assad/article/details/79247513
版权

JMS 和 Apache-ActiveMQ 简介


JMS（Java Message Service，Java 消息服务）是一个 Java 面向消息中间件（MOM）的 API，用于 Java 应用程序或分布式系统之间发送信息，异步通信；

JMS 具有以下优势

  • 通信的异步性，客户端获取信息不需要主动发送请求，由 JMS 中间件自动推送信息；
  • 消息发送的准确性，JMS 中间件可以保证信息只会发送一次，不会发送重复信息；

JMS 的消息传输模型有以下 2 种
1）点对点模型（P2P，queue）

P2P 模型中，应用程序有消息队列（queue），消息发送者，消息接收者组成，每一个消息发送给一个中间件队列，再由队列发送给单个接收者。具有以下的性质：
  • 每一个消息只有一个接收者（当多个接收者使用同一个消息队列时，接收消息是竞争式的）；
  • 发布者和接收者没有时间依赖，当消息发送者发送消息时，即使但是接收者不运行，当只要接收者上线，就可以接收到信息；
  • 当接收者接收到消息时，会发送确认通知；

2）发布/订阅模型（topic）


分布/订阅模型，应 用程序有主题（topic），消息发送者，一系列的消息接收者组成，topic 用于保存和传递消息，并且会一直保存到被传递到客户端。具有以下特性：
  • 一个消息可以传递给多个消息接收者（当多个接收者接收到同一个消息时，每一个接收者都会接收到一份该消息的拷贝）；
  • 发布者和接收者有时间依赖，只有当客户端创建订阅后，才可以开始接收到消息（而且是当前开始消息发送者发布的消息），同时订阅者需要一直保持活动状态才可以接收消息；
  • JMS 允许发布订阅者创建一个可持久化的订阅，这样即使订阅者没有上线，也可以在上线后接收到消息；

JMS 这是一个平台无关的 Java API，由 MOM 提供商对其进行支持，这里介绍其中比较轻量化，高效的 Apache-ActiveMQ；
ActiveMQ 项目官网： http://activemq.apache.org

ActiveMQ的安装和部署


由于 JMS 消息中间是独立于客户端，服务端程序的，在运行程序前要先部署好 JMS 服务程序；
Active-MQ 下载地址： http://activemq.apache.org/download.html

选择合适的系统版本下载，解压后，window 版本X64运行 apache-activemq/bin/win64/activemq.bat， Unix 版本运行   apache-activemq/bin/activemq.sh，即可启动 ActiveMQ； 

ActiveMQ 提供了一个基于内嵌 Jetty 的管理程序，可以在启动 acgtivemq 后访问服务器的 http://127.0.0.1:8161/admin 访问该管理页面（默认密码：admin，admin）

如果要增加、修改 ActiveMQ 的程序用户认证，可以在 apache-activemq/conf/activemq.xml 文件中的<broker>节点下添加：
  
<broker>
    ....
     <!--增加用户认证-->
        <plugins>
            <simpleAuthenticationPlugin>
                <users>
                    <authenticationUser username="assad" password="assad123" groups="admins" />
                </users>
            </simpleAuthenticationPlugin>
        </plugins>
</broker>
要增加、修改程序访问的 openwire 路由端口，可以修改<transportConnectors >中相关的<transportConnector>节点：
  
   <transportConnectors>
            <!-- DOS protection, limit concurrent connections to 1000 and frame size to 100MB -->
            <transportConnector name="openwire" uri="tcp://127.0.0.1:23333?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
        ......
  </transportConnectors>

ActiveMQ 支持 3 种类型的数据传输对象：
  • TextMessager：传输文本对象；
  • MapMessager：传输 Map 类型对象；
  • ObjectMessager：传输其他 Object，调用该 Object 的序列化方法序列化为二进制字节传输；

关于使用 Java  编写基于 ActiveMQ 的 JMS 基本程序，可以参考： https://www.cnblogs.com/jaycekon/p/6225058.html
但由于直接用 Java 直接编写步骤比较繁琐，可以使用 Spring 的集成，相对简单很多，详见下面：



Spring 集成 JMS（ActiveMQ）


Spring 提供的 org.springframework:spring-jms 包对 JMS 进行了封装，使用 Spring 风格的 JmsTemplate 封装了 Adminstred Object（管理对象）、ConnectionFactory（连接工厂）、Session（会话）、Destination（目的地）等的配置；

以下示例完整代码地址： https://gitee.com/assad/jms-spring-sample

异步模型快速示例（queue/topic）

示例代码位于以上地址的 basic_sample 路径下；
需要导入的相关依赖包：
  
//spring_sample 核心依赖
compile 'org.springframework:spring-core:4.3.11.RELEASE'
compile 'org.springframework:spring-beans:4.3.11.RELEASE'
​
//Apache-ActiveMQ ( JMS API 的一种思想) 依赖，Spring 相关支持依赖
compile 'org.apache.activemq:activemq-all:5.15.3'
compile 'org.apache.activemq:activemq-pool:5.15.3'
compile 'org.springframework:spring-jms:4.3.11.RELEASE'

服务端

在 spring 上下文配置文件中进行 ActiveMQ 相关的配置： basic_sample/appContext-server.xml
  
    <!--ActiveMQ 相关配置-->
​
    <!--第三方工厂-->
    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory"
          p:brokerURL="tcp://127.0.0.1:23333"
          p:userName="assad"
          p:password="assad123"
          p:trustAllPackages="true"
          p:useAsyncSend="true"/>
    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory" destroy-method="stop"
          p:connectionFactory-ref="targetConnectionFactory"
          p:maxConnections="100" />
    <!--spring 管理真正 ConnectionFactory 的连接工厂，使用PooledConnectionFactory 封装过的 targetConnectionFactory -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory"
          p:targetConnectionFactory-ref="pooledConnectionFactory"/>
​
    <!--目的地配置: queue(point-to-point模式) -->
    <bean id="destinationQueue" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg index="0" value="spring-queue" />
    </bean>
​
    <!--目的地配置：Topic（发布/订阅模式）-->
    <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg index="0" value="spring-topic" />
    </bean>
​
    <!--配置 Spring jsmTemplate 模板，用于发送和接收消息 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"
          p:connectionFactory-ref="connectionFactory">
        <!--配置默认目的地（queue 或 topic）-->
        <property name="defaultDestination" ref="destinationQueue" />
        <!--使用spring提供的默认消息转换器，也可以装载自己实现的消息转化器-->
        <property name="messageConverter">
            <bean class="org.springframework.jms.support.converter.SimpleMessageConverter" />
        </property>
    </bean>
要上配置文件配置使用 P2P 模型作为目的地，如果要更改为 Topic 模型，只需要丢该 jmsTemplate bean 节点 defaultDestination-ref 属性为之前配置好的 "destinationTpoic " 即可，同样可以在服务端发送消息代码中手动指定目的地；

服务端程序 sample/MessageProducer  ：
  
package basic_sample.server;
import bean.User;
import org.apache.xbean.spring.context.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
//演示各种类型消息的发送
​
public class MessageProducer {
​
    private static JmsTemplate jmsTemplate = null;
    private static final Logger log = LogManager.getLogger();
​
    public static void main(String[] args){
        
        //获取 JmsTemplate 对象
        jmsTemplate = new ClassPathXmlApplicationContext("basic_sample/appContext-server.xml").getBean("jmsTemplate",JmsTemplate.class);
​
        //发送文本信息
        String message = "basic_sample.server: Hello world!";
        jmsTemplate.convertAndSend(message);
        log.debug(message);
​
        //发送 Map 类型信息
        Map<String,Integer> info = new HashMap<>();
        info.put("Guangdong",64815);
        info.put("Jiangshu",62604);
        info.put("Shangdong",54868);
        info.put("Zhijiang",36958);
        jmsTemplate.convertAndSend(info);
        log.debug(info.keySet().stream().map(key -> key+":"+info.get(key)).collect(Collectors.joining(", ")));
​
        //发送 Object 类型信息（User对象）
        User user = new User();
        user.setId(20137);
        user.setName("assad");
        user.setCity("Guangzhou");
        jmsTemplate.convertAndSend(user);
        log.debug(user);
    }
}
注意在传输对象时，spring 配置文件中的 connectionFactory 的 trustAllPackages 参数需要设置为 true；

客户端

在这个示例中客户端的 Spring 上下文配置文件 basic_sample/appContext-clinet.xml 
  
    <!--ActiveMQ 相关配置-->
    <!--第三方工厂-->
    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory"
          p:brokerURL="tcp://127.0.0.1:23333"
          p:userName="assad"
          p:password="assad123"
          p:trustAllPackages="true" />
    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory" destroy-method="stop"
          p:connectionFactory-ref="targetConnectionFactory"
          p:maxConnections="100" />
    <!--spring 管理真正 ConnectionFactory 的连接工厂，使用PooledConnectionFactory 封装过的 targetConnectionFactory -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory"
          p:targetConnectionFactory-ref="pooledConnectionFactory"/>
​
    <!--目的地配置: queue(point-to-point模式) -->
    <bean id="destinationQueue" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg index="0" value="spring-queue" />
    </bean>
​
    <!--目的地配置：Topic（发布/订阅模式）-->
    <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg index="0" value="spring-topic" />
    </bean>
​
    <!--配置 Spring jsmTemplate 模板，用于发送和接收消息 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"
          p:connectionFactory-ref="connectionFactory">
        <!--配置默认目的地（queue 或 topic）-->
        <property name="defaultDestination" ref="destinationQueue" />
        <!--使用spring提供的默认消息转换器，也可以装载自己实现的消息转化器-->
        <property name="messageConverter">
            <bean class="org.springframework.jms.support.converter.SimpleMessageConverter" />
        </property>
    </bean>
​

客户端程序， basic_sample/client/MessageConsumer
  
package basic_sample.client;
​
import bean.User;
import org.apache.xbean.spring.context.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
​
//演示接收各种类型的消息
public class MessageConsumer {
​
    private static JmsTemplate jmsTemplate = null;
    private static final Logger log = LogManager.getLogger();
​
    public static void main(String[] args){
        //创建 JmsTemplate 对象
        jmsTemplate = new ClassPathXmlApplicationContext("basic_sample/appContext-client.xml").getBean("jmsTemplate",JmsTemplate.class);
​
        //接收文本对象
        String msg = (String) jmsTemplate.receiveAndConvert();
        log.debug(msg);
​
        //接收 Map 对象
        Map<String,Integer> info = (HashMap<String,Integer>) jmsTemplate.receiveAndConvert();
        log.debug(info.keySet().stream().map(key -> key+":"+info.get(key)).collect(Collectors.joining(", ")));
​
        //接收 Object 类型对象
        User user = (User) jmsTemplate.receiveAndConvert();
        log.debug(user);
    }
}

运行步骤，启动 activemq 后，分别运行客户端，服务端；客户端接收的信息如下：


关于 queue 模式和 topic 模式客户端接收信息的区别，可以分别修改  jmsTemplate 的  defaultDestination 参数，运行 basic_sample/MessageProducer2 和 basic_sample/MessageConsumer2 进行测试，结果和以上介绍 JMS 的 2 种传输模型相符合；



客户端使用监听器的方式接收信息

以上示例的客户端是使用 JmsTemplate 接收消息，如果客户端需要使用 监听器的方式 接收信息，可以如下步骤：
创建一个监听器 client/MyListener
  
package persistence_sample.client;
import javax.jms.*;
​
public class MyListener implements MessageListener {
    private static final Logger log = LogManager.getLogger();
    @Override
    public void onMessage(Message message) {
        try {
            //接收文本对象
            String msg = (String) jmsTemplate.receiveAndConvert();
            log.debug(msg);
            //接收 Map 对象
            Map<String,Integer> info = (HashMap<String,Integer>) jmsTemplate.receiveAndConvert();
            log.debug(info.keySet().stream().map(key -> key+":"+info.get(key)).collect(Collectors.joining(", ")));
​
            //接收 Object 类型对象
            User user = (User) jmsTemplate.receiveAndConvert();
            log.debug(user);
            
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

在 spring 上下文中配置文件 appContext-client.xml 中配置监听器：
  
    <!--ActiveMQ 相关配置-->
    <!--第三方工厂-->
    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory"
          p:brokerURL="tcp://127.0.0.1:23333"
          p:userName="assad"
          p:password="assad123"
          p:trustAllPackages="true" />
    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory" destroy-method="stop"
          p:connectionFactory-ref="targetConnectionFactory"
          p:maxConnections="100" />
    <!--spring 管理真正 ConnectionFactory 的连接工厂，使用PooledConnectionFactory 封装过的 targetConnectionFactory -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory"
          p:targetConnectionFactory-ref="pooledConnectionFactory"/>
​
    <!--目的地配置: queue(point-to-point模式) -->
    <bean id="destinationQueue" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg index="0" value="spring-queue" />
    </bean>
​
     <!--装载自定义消息监听器-->
    <bean id="myTopicListener" class="persistence_sample.client.TopicListener" />
​
    <!--消息监听容器-->
    <bean id="listenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer"
          p:connectionFactory-ref="connectionFactory"
          p:destination-ref="destinationQueue"
          p:receiveTimeout="1000"
          p:messageListener-ref="myTopicListener">
        <!--messageListener-ref 配置消息监听器-->
        <property name="messageConverter">
            <bean class="org.springframework.jms.support.converter.SimpleMessageConverter" />
        </property>
    </bean>
​
创建客户端 client/StartReciver
  
public class StartReceiver {
    public static void main(String[] args){
        ApplicationContext context = new ClassPathXmlApplicationContext("persistence_sample/appContext-client.xml");
        while(true){
        }
    }
}



Topic 消息持久化配置

topic 非持久化消息订阅会持续到订阅对象的生命周期，由于 topic 模型的实际产生场景一般会有多个订阅对象，网络 IO 开销会很大，ActiveMQ 提供了持久化实现，可以将 topic 消息储存到磁盘文件或者数据库的实现，如果持久化没有活动的订阅者，JMS 会保存该订阅消息，直到消息被订阅或过期；

以下是一个实现示例，代码模块在示例代码地址的 persistence 目录下；

服务端

spring 配置文件： persistence_sample/appContext-server.xml
  
 <!--ActiveMQ 相关配置-->
    <!--第三方工厂-->
    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory"
          p:brokerURL="tcp://127.0.0.1:23333"
          p:userName="assad"
          p:password="assad123"
          p:trustAllPackages="true" />
    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory" destroy-method="stop"
          p:connectionFactory-ref="targetConnectionFactory"
          p:maxConnections="100" />
    <!--spring 管理真正 ConnectionFactory 的连接工厂，使用PooledConnectionFactory 封装过的 targetConnectionFactory -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory"
          p:targetConnectionFactory-ref="pooledConnectionFactory"/>
​
    <!--目的地配置：queue（发布/订阅模式）-->
    <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg index="0" value="spring-topic-persistence" />
    </bean>
​
    <!--配置 Spring jsmTemplate 模板，配置为 Topic 模式 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"
          p:connectionFactory-ref="connectionFactory"
          p:defaultDestination-ref="destinationTopic"
          p:pubSubDomain="true"
          p:sessionAcknowledgeMode="1"
          p:explicitQosEnabled="true"
          p:deliveryMode="2"
          p:receiveTimeout="10000">
        <!--以上配置中，explicitQosEnabled用于生效deliveryMode配置
            deliveryMode 为发送模式，1 为非持久，2 为持久-->
        <!--使用spring提供的默认消息转换器-->
        <property name="messageConverter">
            <bean class="org.springframework.jms.support.converter.SimpleMessageConverter" />
        </property>
    </bean>
服务端程序  persistence_sample/server/MessageProducer
  
ackage persistence_sample.server;
​
import org.apache.xbean.spring.context.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
​
public class MessageProducer {
    private static JmsTemplate jmsTemplate ;
    private static final Logger log = LogManager.getLogger();
    public static void main(String[] args) throws InterruptedException {
        jmsTemplate = new ClassPathXmlApplicationContext("persistence_sample/appContext-server.xml").getBean("jmsTemplate",JmsTemplate.class);
        //发送20条信息
        for(int i=1; i<=20; i++){
            String message = String.format("Message@<%d>",i);
            jmsTemplate.convertAndSend(message);
            log.debug(message);
            Thread.sleep(900);
        }
    }
}

客户端

示例代码客户端使用监听器的方式实现获取消息；
spring 配置文件： persistence_sample/appContext-client.xml
  
    <!--ActiveMQ 相关配置-->
    <!--第三方工厂-->
    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory"
          p:brokerURL="tcp://127.0.0.1:23333"
          p:userName="assad"
          p:password="assad123"
          p:trustAllPackages="true" />
    <bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory" destroy-method="stop"
          p:connectionFactory-ref="targetConnectionFactory"
          p:maxConnections="100" />
    <!--spring 管理真正 ConnectionFactory 的连接工厂，使用PooledConnectionFactory 封装过的 targetConnectionFactory -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory"
          p:clientId="client_001"
          p:targetConnectionFactory-ref="pooledConnectionFactory"/>
​
    <!--目的地配置：Topic（发布/订阅模式）-->
    <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg index="0" value="spring-topic-persistence" />
    </bean>
​
    <!--装载自定义消息监听器-->
    <bean id="myTopicListener" class="persistence_sample.client.TopicListener" />
    <!--消息监听容器-->
    <bean id="listenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer"
          p:connectionFactory-ref="connectionFactory"
          p:destination-ref="destinationTopic"
          p:pubSubDomain="true"
          p:subscriptionDurable="true"
          p:clientId="client_001"
          p:durableSubscriptionName="client_001"
          p:receiveTimeout="1000"
          p:messageListener-ref="myTopicListener">
        <!--pubSubDomain开启订阅模式，subscriptionDurable设置允许持久化，
        clientId、durableSubscriptionName 设置接收者ID-->
        <property name="messageConverter">
            <bean class="org.springframework.jms.support.converter.SimpleMessageConverter" />
        </property>
    </bean>
消息监听器  persistence_sample/client/TopicListener
  
package persistence_sample.client;
import javax.jms.*;
public class TopicListener implements MessageListener {
    private static final Logger log = LogManager.getLogger();
    @Override
    public void onMessage(Message message) {
        try {
            String msg = ((TextMessage)message).getText();
            log.debug(msg);
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}
客户端启动程序  persistence_sample/client/StartReceiver
  
package persistence_sample.client;
import org.apache.xbean.spring.context.ClassPathXmlApplicationContext;
import org.springframework.context.ApplicationContext;
​
public class StartReceiver {
    public static void main(String[] args){
        ApplicationContext context = new ClassPathXmlApplicationContext("persistence_sample/appContext-client.xml");
        while(true){
        }
    }
}

ActiveMQ 的配置

具体持久化的实现实在 ActiveMQ 中进行配置的，ActiveMQ 支持以下几种持久化方式：
  • AMQ 文件储存；
  • KahaDB 文件储存；
  • LevelDB 储存
  • JDBC 数据库持久化；
这里演示使用  KahaDB 文件作为持久化文件储存格式，在 apache-activemq/conf/activemq.xml 中<brokler>节点下添加以下：
  
<broker>
    ....
    <!--持久化配置-->
    <persistenceAdapter>
            <kahaDB directory="${activemq.data}/kahadb"/>
        </persistenceAdapter>
    ....
</broker>

关于ActiveMQ 详细的持久化配置，参考： https://my.oschina.net/u/1455908/blog/310115





Al_assad
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java onmessage监听消息队列_详解Java消息队列-Spring整合ActiveMq
weixin_42140846的博客
02-16 1027
1、概述首先和大家一起回顾一下Java 消息服务，在我之前的博客《Java消息队列-JMS概述》中，我为大家分析了：1.消息服务：一个中间件，用于解决两个活多个程序之间的耦合，底层由Java 实现。2.优势：异步、可靠3.消息模型：点对点，发布/订阅4.JMS中的对象然后在另一篇博客《Java消息队列-ActiveMq实战》中，和大家一起从0到1的开启了一个ActiveMq 的项目，在项目开发的过...
goframe使用redis做一个消息队列
Dcy1227的博客
06-28 329
方法从名为 "message_queue" 的 Redis 列表中获取消息，当队列为空时将一直阻塞。通过以上两个例子，你可以在 GoFrame 中使用 Redis 实现一个简单的消息队列。生产者可以将消息推送到 Redis 队列中，消费者可以从队列中获取消息进行处理。安装 Redis 相关的库，可以使用 go-redis 或 redigo，具体安装方法可以参考前面的回答。创建一个消息队列的生产者，用于发送消息到 Redis 队列中。创建一个消息队列的消费者，用于从 Redis 队列中获取消息。
1、jms-frame框架学习RestResp
weixin_43472934的博客
11-06 232
一般公司后端框架设置controller返回json格式的数据，json格式中key主要分为三个，一个是错误码，一个是错误错误信息，还有一个是数据。一般公司可以自己创建，也可以借助jms-frame框架的RestResp类，也可以借助其他的类 jms-frame源码地址：https://gitee.com/longzhili2005/jsm-frame?_from=gitee_search jms-frame的maven地址： <dependency> <groupId>
Spring整合JMS
lhrimperial的专栏
08-29 185
配置ConnectionFactoryConnectionFactory是用于产生到JMS服务器的链接的，Spring为我们提供了多个ConnectionFactory，有SingleConnectionFactory和CachingConnectionFactory。SingleConnectionFactory对于建立JMS服务器链接的请求会一直返回同一个链接，并且会忽略Connection的c
(四) Spring整合ActiveMQ---超详细教程
zxg的博客
11-22 6635
Spring整合ActiveMQ环境配置Spring整合ActiveMQ之队列生产者Spring整合ActiveMQ之队列消费者三级目录 前面三节讲了ActiveMQ的安装、测试。JMS介绍以及四大组成元素，还有ActiveMQ的可靠性（持久化、事务、签收），还有Broker等等。 但是光学会还不够，我们还要把ActiveMQ应用到我们已有的框架中，如Spring和SpringBoot等等。 这一节主要学习如何在Spring中使用ActiveMQ。 环境配置 首先创建一个spring项目，在pom文件中导入
使用spring集成JMS连接ActiveMQ
qq_36407090的博客
08-01 1003
ConnectionFactory用于管理连接的连接工厂 JmsTemplate用于发送和接收消息的模板类 MessageListerner消息监听器 ConnectionFactory 一个Spring为我们提供的连接池 JmsTemplate每次发消息都会重新创建连接，会话和producer spring中提供了SingleConnectionFactory和CachingC...
activemq:这里是消息队列的activemq的简单使用
05-18
消息队列的学习项目 安装 安装环境 wget 网址 tar -xzvf 文件名 cp 文件名 /usr/local/ 测试 cd /usr/local/文件名/bin/ ./activemq start 项目默认管理地址：8161 JMS 一个Java平台中关于面向消息中间件（MOM）的...
Spring平台整合消息队列ActiveMQ实现发布订阅、生产者消费者模型（适合新手或者开发人员了解学习ActiveMQ机制）
06-27
本项目基于Spring这一平台，整合流行的开源消息队列中间件ActiveMQ,实现一个向ActiveMQ添加和读取消息的功能。并比较了两种模式：生产者-消费者模式和发布-订阅模式的区别。 包含的特性如下： 1.开启activeMQ，访问...
spring-jms：Spring JMS教程
01-29
Spring JMS教程 该存储库包含发布在上的spring-jms示例的源代码 如有疑问或评论，请在各自的博客文章中发表评论或打开GitHub问题。 谢谢！
JMS之Spring +activeMQ实现消息队列
08-12
NULL 博文链接：https://ihenu.iteye.com/blog/2270078
详解Java消息队列-Spring整合ActiveMq
08-31
本篇文章主要介绍了详解Java消息队列-Spring整合ActiveMq ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring整合ActiveMQ之监听器配置
Hern（宋兆恒）
08-09 2460
简介 在EJB世界里，JMS消息最常用的功能之一是用于实现消息驱动Bean（MDB）。Spring提供了一个方法来创建消息驱动的POJO（MDP），并且不会把用户绑定在某个EJB容器上。 通常用消息监听器容器从JMS消息队列接收消息并驱动被注射进来的MDP。消息监听器容器负责消息接收的多线程处理并分发到各MDP中。一个消息侦听容器是MDP和消息提供者之间的一个中介，用来处理消息接收的注册，事务...
Spring Boot的JMS发送和接收队列消息，基于ActiveMQ
Zhang Phil
01-19 1748
消息队列ActiveMQ是JMS的一种实现，ActiveMQ可以单独作为一个消息队列组件即插即拔，即插即用，参考下面两篇文章： 分布式MQTT消息订阅-发布框架：高可用性ActiveMQ_Zhang Phil-CSDN博客_mqtt分布式架构分布式MQTT消息订阅-发布框架：高可用性ActiveMQActiveMQ是MQTT的一种实现。ActiveMQ基于JMS。ActiveMQ开发包下载地址：http://activemq.apache.org/download.htmlActiveMQ最适合做消息推送
【Java.JMS】【springframework.jms】
王晓斌的专栏
10-14 729
..
spring-jms-3.1.1 中jms的connection模式
lonsonlee的专栏
01-30 1743
基于spring-jms-3.1.1.RELEASE分析 org.springframework.jms.connection spring使用jms 一般我们使用都是这样子 &lt;bean name="jmsTransportListener" class="org.apache.activemq.transport.DefaultTransportListener"/&gt; &lt;/...
No qualifying bean of type [org.springframework.jms.core.JmsTemplate] is defined
jia_youshzh的博客
06-10 5676
注入JmsTemplate时：    Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [org.springframework.jms.core.JmsTemplate] is defined: expected single match...
使用Spring JMS - Spring Framework reference 2.0.5 参考手册中文版
先疯盗骨
09-04 853
19.2. 使用Spring JMS 19.2.1. JmsTemplate JmsTemplate类有两个实现方式。JmsTemplate类使用JMS 1.1的API，而子类JmsTemplate102使用了JMS 1.0.2的API。 使用JmsTemplate的代码只需要实现规范中定义的回调接口。 MessageCreator回调接口通过
Spring 中自带 JMS的使用
口袋里的小龙的专栏
06-21 710
Spring 中自带 JMS的使用
Spring整合ActiveMQ教程
热门推荐
mgsky1的博客
04-21 1万+
写在前面：这篇文章会涉及二者的整合思路，为了能够更好地读懂本文，建议最好你能够在不整合其他环境的情况下使用ActiveMQ编写简单的控制台Demo，并且能够了解JMS(Java Message Service)。当然，你也可以直接略过整合思路看整合的过程。 简介 ActiveMQ是Apache出品的一个消息队列(Message Queue)软件，它可以与诸如C#、C++、PHP、J...
消息队列activemq
最新发布
08-31
ActiveMQ是一种基于Java的开源消息中间件，它实现了Java Message Service (JMS) 规范，用于在分布式系统中进行消息的异步通信。消息队列是一种存储和传递消息的方式，它可以实现消息的发布和订阅机制。当消息进入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值