`
dengwanchuan
  • 浏览: 47340 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
最近访客 更多访客>>
社区版块
存档分类
最新评论

Java中间件JMS(二)之ActiveMQ整合spring(一)

阅读更多

原文链接:http://blog.csdn.net/dwc_fly/article/details/10306805 

 

在上一章( Java中间件JMS之ActiveMQ入门http://blog.csdn.net/dengwanchuan/article/details/10241345)说到ActiveMQ能与spring进行整合,ActiveMQ与Spring进行整合有一定的好处,首先是可配置化,然后是能使用Spring的aop,tx等特性进行项目开发.

一.准备工作

我使用的是spring版本是4.0.0.M2,其他版本的也可以,只是配置不同,去Spring官网下载zip包,解开后将dist目录下的所有jar包(根据自己选择)拷贝到项目lib目录下并加入项目项目中的lib中,一般jms所需要的Spring的jar有:


二.代码开发

1.在src目录下新建applicationContext.xml文件并输入一下内容:

[html] view plaincopy
 
  1. <?xml version="1.0" encoding="GBK"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.            http://www.springframework.org/schema/beans/spring-beans.xsd">  
  6. </beans>  

 

2.引入spring,打开web.xml并将其内容修改为以下内容:

[html] view plaincopy
 
  1. <?xml version="1.0" encoding="GBK"?>  
  2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
  5.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
  6.     <context-param>  
  7.         <param-name>contextConfigLocation</param-name>  
  8.         <param-value>classpath*:applicationContext*.xml</param-value>  
  9.     </context-param>  
  10.     <servlet>  
  11.         <servlet-name>spring</servlet-name>  
  12.         <servlet-class>  
  13.             org.springframework.web.servlet.DispatcherServlet  
  14.         </servlet-class>  
  15.         <load-on-startup>1</load-on-startup>  
  16.     </servlet>  
  17.     <servlet-mapping>  
  18.         <servlet-name>spring</servlet-name>  
  19.         <url-pattern>/</url-pattern>  
  20.     </servlet-mapping>  
  21.     <welcome-file-list>  
  22.         <welcome-file>index.jsp</welcome-file>  
  23.     </welcome-file-list>  
  24. </web-app>  

3.配置JMSTemplate模板

 

类似于jdbcTemplate,首先要配置一个ConnectionFactory,之后要开始配置JmsTemplate模板了。最后是配置消息目标了。消息分为队列(Queue)和主题(Topic)两大类。在applicationContext.xml中加入如下内容:

 

[html] view plaincopy
 
  1. <!-- 配置JMS连接工厂 -->  
  2.     <bean id="connectionFactory"  
  3.         class="org.apache.activemq.ActiveMQConnectionFactory">  
  4.         <property name="brokerURL" value="tcp://localhost:61616" />  
  5.     </bean>  
  6.     <!-- 发送消息的目的地(队列) -->  
  7.     <bean id="queueDest"  
  8.         class="org.apache.activemq.command.ActiveMQQueue">  
  9.         <!-- 设置消息队列的名字 -->  
  10.         <constructor-arg index="0" value="myQueue" />  
  11.     </bean>  
  12.     <!-- 配置Jms模板  -->  
  13.     <bean id="jmsQueueTemplate"  
  14.         class="org.springframework.jms.core.JmsTemplate">  
  15.         <property name="connectionFactory" ref="connectionFactory" />  
  16.         <property name="defaultDestination" ref="queueDest" />  
  17.         <!--<property name="receiveTimeout" value="10000" />  -->  
  18.     </bean>  
  19.       
  20.     <!-- 发送消息的目的地(主题) -->  
  21.     <bean id="topicDest"  
  22.         class="org.apache.activemq.command.ActiveMQTopic">  
  23.         <!-- 设置消息队列的名字 -->  
  24.         <constructor-arg index="0" value="myTopic" />  
  25.     </bean>  
  26.     <!-- 配置TopicJms模板  -->  
  27.     <bean id="jmsTopicTemplate"  
  28.         class="org.springframework.jms.core.JmsTemplate">  
  29.         <property name="connectionFactory" ref="connectionFactory" />  
  30.         <property name="defaultDestination" ref="topicDest" />  
  31.         <!-- 配置是否为发布订阅者模式,默认为false -->  
  32.         <property name="pubSubDomain" value="true"/>  
  33.     <!--<property name="receiveTimeout" value="10000" />  -->  
  34.     </bean>  

 

receiveTimeout表示接收消息时的超时时间,设置的为10秒,因为如果不设置的话,加入接收消息时是阻塞着的,那么将一直阻塞下去。配置完成了。但是我不建议设置这个时间,如果到达设置时间之后,生产者没有运行,消费者接受到Message对象为null,测试可能会出现异常,而且消费者将停止接受消息.那么如何使用JmsTemplate发送消息呢?

spring的beanfactory得到一个jmsTemplate的实例和消息目标的实例,发送消息,够简单的吧。首先我们还从queue方式开始。下面我们就来编写具体代码。

4、编写Point-to-Point (点对点)代码

新建生产者类QueueProducerService.java,代码如下:

 

[java] view plaincopy
 
  1. package jms.mq.spring;  
  2.   
  3. import java.util.Date;  
  4.   
  5. import javax.jms.Destination;  
  6. import javax.jms.JMSException;  
  7. import javax.jms.Message;  
  8. import javax.jms.Session;  
  9. import javax.jms.TextMessage;  
  10. import org.springframework.jms.core.JmsTemplate;  
  11. import org.springframework.jms.core.MessageCreator;  
  12.   
  13. public class QueueProducerService{  
  14.     JmsTemplate jmsTemplate;  
  15.   
  16.     Destination destination;  
  17.   
  18.     public void send() {  
  19.         MessageCreator messageCreator = new MessageCreator() {  
  20.             public Message createMessage(Session session) throws JMSException {  
  21.                 TextMessage message = session.createTextMessage();  
  22.                 message.setText("QueueProducerService发送消息"+new Date());  
  23.                 return message;  
  24.             }  
  25.   
  26.         };  
  27.         jmsTemplate.send(this.destination,messageCreator);  
  28.     }  
  29.   
  30.     public void setJmsTemplate(JmsTemplate jmsTemplate) {  
  31.         this.jmsTemplate = jmsTemplate;  
  32.     }  
  33.       
  34.     public void setDestination(Destination destination) {  
  35.         this.destination = destination;  
  36.     }  
  37. }  

 

生产者编写完了,下面我们来编写消费者,上面说了,发送消息的时候,spring的beanfactory得到一个jmsTemplate的实例和消息目标的实例,然后发送,那么接受的时候肯定也是得到一个jmsTemplate的实例和消息目标的实例,然后接受,下面我们来看具体代码。

新建一个消费者类QueueConsumerService.java,具体代码如下:

 

[java] view plaincopy
 
  1. package jms.mq.spring;  
  2.   
  3. import javax.jms.Destination;  
  4. import javax.jms.JMSException;  
  5. import javax.jms.TextMessage;  
  6.   
  7. import org.springframework.jms.core.JmsTemplate;  
  8.   
  9.   
  10. public class QueueConsumerService{  
  11.   
  12.     JmsTemplate jmsTemplate;  
  13.   
  14.     Destination destination;  
  15.   
  16.     public void receive() {  
  17.         TextMessage message = (TextMessage) jmsTemplate.receive();  
  18.         try {  
  19.             System.out.println("QueueConsumerService收到消息:"+message.getText());  
  20.         } catch (JMSException e) {  
  21.             e.printStackTrace();  
  22.         }  
  23.     }  
  24.   
  25.     public void setJmsTemplate(JmsTemplate jmsTemplate) {  
  26.         this.jmsTemplate = jmsTemplate;  
  27.     }  
  28.   
  29.     public void setDestination(Destination destination) {  
  30.         this.destination = destination;  
  31.     }  
  32. }  

 

代码编写完毕,下面要进行bean的配置,在applicationContext.xml中加入如下代码实例化对象和依赖注入:

 

[html] view plaincopy
 
  1. <bean id="queueProducerService" class="jms.mq.spring.QueueProducerService">  
  2.     <property name="jmsTemplate" ref="jmsQueueTemplate" />  
  3.     <property name="destination" ref="queueDest" />  
  4. </bean>  
  5.   
  6. <bean id="queueConsumerService" class="jms.mq.spring.QueueConsumerService">  
  7.     <property name="jmsTemplate" ref="jmsQueueTemplate" />  
  8.     <property name="destination" ref="queueDest" />  
  9. </bean>  

 

需要的业务代码都已编写完毕,下面编写测试代码。新建一个生产者的测试类QueueProducerTest.java。具体代码如下:

[java] view plaincopy
 
  1. package jms.mq.spring;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class QueueProducerTest {  
  7.     private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");  
  8.   
  9.     private static void send() {  
  10.         QueueProducerService producerService = (QueueProducerService) appContext.getBean("queueProducerService");  
  11.         producerService.send();  
  12.     }  
  13.   
  14.     /** 
  15.      * @param args 
  16.      */  
  17.     public static void main(String[] args) {  
  18.         send();  
  19.     }  
  20.   
  21. }  

再建一个消费者的测试类,QueueConsumerTest.java,具体代码如下:

 

[java] view plaincopy
 
  1. package jms.mq.spring;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class QueueConsumerTest {  
  7.     private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");  
  8.   
  9.     private static void receive() {  
  10.         QueueConsumerService consumerService = (QueueConsumerService) appContext.getBean("queueConsumerService");  
  11.         consumerService.receive();  
  12.     }  
  13.   
  14.     public static void main(String[] args) {  
  15.         receive();  
  16.     }  
  17.   
  18. }  

 

 

5、运行point-point(点对点)程序

所有代码都编写完了,我们来看一下我们的劳动成果。运行生产者测试类。控制台打印出如下内容,画线标注的就是我们发送的内容:

6、编写Publisher/Subscriber(发布/订阅者)代码

新建发布者TopicPublisherService.java,内容如下:

[java] view plaincopy
 
  1. package jms.mq.spring;  
  2.   
  3. import java.util.Date;  
  4.   
  5. import javax.jms.Destination;  
  6. import javax.jms.JMSException;  
  7. import javax.jms.MapMessage;  
  8. import javax.jms.Message;  
  9. import javax.jms.Session;  
  10. import javax.jms.TextMessage;  
  11.   
  12. import org.springframework.jms.core.JmsTemplate;  
  13. import org.springframework.jms.core.MessageCreator;  
  14.   
  15. import jms.spring.QueueProducerService;  
  16.   
  17. public class TopicPublisherService{  
  18.     JmsTemplate jmsTemplate;  
  19.        
  20.     Destination destination;  
  21.  
  22.     public void send() {  
  23.         MessageCreator messageCreator = new MessageCreator() {  
  24.             public Message createMessage(Session session) throws JMSException {  
  25.                 TextMessage message = session.createTextMessage();  
  26.                 message.setText("QueueProducerService发送消息"+new Date());  
  27.                 return message;  
  28.             }  
  29.         };  
  30.         jmsTemplate.send(this.destination,messageCreator);  
  31.   
  32.     }  
  33.   
  34.     public void setJmsTemplate(JmsTemplate jmsTemplate) {  
  35.         this.jmsTemplate = jmsTemplate;  
  36.     }  
  37.   
  38.     public void setDestination(Destination destination) {  
  39.         this.destination = destination;  
  40.     }  
  41.   
  42. }  

再新建一个订阅者TopicSubscriberService.java,代码如下。

[java] view plaincopy
 
  1. package jms.mq.spring;  
  2.   
  3. import javax.jms.Destination;  
  4. import javax.jms.JMSException;  
  5. import javax.jms.TextMessage;  
  6.   
  7. import org.springframework.jms.core.JmsTemplate;  
  8.   
  9. import jms.spring.QueueConsumerService;  
  10.   
  11. public class TopicSubscriberService{  
  12.   
  13.     JmsTemplate jmsTemplate;  
  14.   
  15.     Destination destination;  
  16.   
  17.     public void receive() {  
  18.         TextMessage message = (TextMessage) jmsTemplate.receive();  
  19.         try {  
  20.             System.out.println("QueueConsumerService收到消息:"+message.getText());  
  21.         } catch (JMSException e) {  
  22.             e.printStackTrace();  
  23.         }  
  24.     }  
  25.   
  26.     public void setJmsTemplate(JmsTemplate jmsTemplate) {  
  27.         this.jmsTemplate = jmsTemplate;  
  28.     }  
  29.   
  30.     public void setDestination(Destination destination) {  
  31.         this.destination = destination;  
  32.     }  
  33. }  

在配置文件中applicationContext.xml增加如下配置:

[html] view plaincopy
 
  1. <span style="white-space:pre">  </span><bean id="topicPublisherService" class="jms.mq.spring.TopicPublisherService">  
  2.        <property name="jmsTemplate" ref="jmsTopicTemplate"/>  
  3.        <property name="destination" ref="topicDest"/>  
  4.     </bean>  
  5.    
  6.     <bean id="topicSubscriberService" class="jms.mq.spring.TopicSubscriberService">  
  7.        <property name="jmsTemplate" ref="jmsTopicTemplate"/>  
  8.        <property name="destination" ref="topicDest"/>  
  9.     </bean>  

 

编写测试程序发布者测试类,TopicPublisherTest.java

 

[java] view plaincopy
 
  1. package jms.mq.spring;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class TopicPublisherTest {  
  7.     private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");  
  8.   
  9.     private static void send() {  
  10.         TopicPublisherService topicPublisherService = (TopicPublisherService) appContext.getBean("topicPublisherService");  
  11.         topicPublisherService.send();  
  12.     }  
  13.   
  14.     public static void main(String[] args) {  
  15.         send();  
  16.     }  
  17. }  

编写测试程序订阅者测试类,TopicSubscriberTest.java

[java] view plaincopy
 
  1. package jms.mq.spring;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class TopicSubscriberTest {  
  7.     private static ApplicationContext appContext = new ClassPathXmlApplicationContext( "applicationContext.xml");  
  8.   
  9.     private static void receive() {  
  10.         TopicSubscriberService topicSubscriberService = (TopicSubscriberService) appContext.getBean("topicSubscriberService");  
  11.         topicSubscriberService.receive();  
  12.     }  
  13.   
  14.     public static void main(String[] args) {  
  15.         receive();  
  16.     }  
  17. }  

7.Publisher/Subscriber(发布/订阅者)程序

先运行订阅者,再运行发布者,可以看到订阅者能打印信息;但是反之就不行,这就是Publisher/Subscriber(发布/订阅者)的特性;

跟Point-Point(点对点)对比的话,不管运行生存者还是消费者,都会打印信息,可以阅读前一章http://blog.csdn.net/dengwanchuan/article/details/10241345了解这两种模式的区别和联系。

 

 

附加完整的applicationContext.xml配置文件

 

[html] view plaincopy
 
  1. <?xml version="1.0" encoding="GBK"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.            http://www.springframework.org/schema/beans/spring-beans.xsd">  
  6.     <!-- 配置JMS连接工厂 -->  
  7.     <bean id="connectionFactory"  
  8.         class="org.apache.activemq.ActiveMQConnectionFactory">  
  9.         <property name="brokerURL" value="tcp://localhost:61616" />  
  10.     </bean>  
  11.     <!-- 发送消息的目的地(队列) -->  
  12.     <bean id="queueDest"  
  13.         class="org.apache.activemq.command.ActiveMQQueue">  
  14.         <!-- 设置消息队列的名字 -->  
  15.         <constructor-arg index="0" value="myQueue" />  
  16.     </bean>  
  17.     <!-- 配置Jms模板  -->  
  18.     <bean id="jmsQueueTemplate"  
  19.         class="org.springframework.jms.core.JmsTemplate">  
  20.         <property name="connectionFactory" ref="connectionFactory" />  
  21.         <property name="defaultDestination" ref="queueDest" />  
  22.         <!--<property name="receiveTimeout" value="10000" />  -->  
  23.     </bean>  
  24.       
  25.     <!-- 发送消息的目的地(主题) -->  
  26.     <bean id="topicDest"  
  27.         class="org.apache.activemq.command.ActiveMQTopic">  
  28.         <!-- 设置消息队列的名字 -->  
  29.         <constructor-arg index="0" value="myTopic" />  
  30.     </bean>  
  31.     <!-- 配置TopicJms模板  -->  
  32.     <bean id="jmsTopicTemplate"  
  33.         class="org.springframework.jms.core.JmsTemplate">  
  34.         <property name="connectionFactory" ref="connectionFactory" />  
  35.         <property name="defaultDestination" ref="topicDest" />  
  36.         <!-- 配置是否为发布订阅者模式,默认为false -->  
  37.         <property name="pubSubDomain" value="true"/>  
  38.     <!--<property name="receiveTimeout" value="10000" />  -->  
  39.     </bean>  
  40.       
  41.     <bean id="queueProducerService" class="jms.mq.spring.QueueProducerService">  
  42.         <property name="jmsTemplate" ref="jmsQueueTemplate" />  
  43.         <property name="destination" ref="queueDest" />  
  44.     </bean>  
  45.   
  46.     <bean id="queueConsumerService" class="jms.mq.spring.QueueConsumerService">  
  47.         <property name="jmsTemplate" ref="jmsQueueTemplate" />  
  48.         <property name="destination" ref="queueDest" />  
  49.     </bean>  
  50.       
  51.       
  52.     <bean id="topicPublisherService" class="jms.mq.spring.TopicPublisherService">  
  53.        <property name="jmsTemplate" ref="jmsTopicTemplate"/>  
  54.        <property name="destination" ref="topicDest"/>  
  55.     </bean>  
  56.    
  57.     <bean id="topicSubscriberService" class="jms.mq.spring.TopicSubscriberService">  
  58.        <property name="jmsTemplate" ref="jmsTopicTemplate"/>  
  59.        <property name="destination" ref="topicDest"/>  
  60.     </bean>  
  61. </beans>  
分享到:
评论
2 楼 dengwanchuan 2013-09-04  
pansonphy 写道
public class TopicPublisherService implements QueueProducerService和
public class TopicSubscriberService implements QueueConsumerService
这两个是不是有问题啊

是不是应该改成

public class TopicPublisherService extends QueueProducerService和
public class TopicSubscriberService extends QueueConsumerService



是有这个问题,避免程序复杂化,把implements 去掉了。TopicPublisherService 继承QueueProducerService也不好,他们是不同的模式,但是TopicPublisherService 和QueueProducerService可以抽象成一个父类.
1 楼 pansonphy 2013-09-03  
public class TopicPublisherService implements QueueProducerService和
public class TopicSubscriberService implements QueueConsumerService
这两个是不是有问题啊

是不是应该改成

public class TopicPublisherService extends QueueProducerService和
public class TopicSubscriberService extends QueueConsumerService

相关推荐

    ActiveMQ整合spring的Demo

    ActiveMQ整合Spring的Demo是一个典型的Java企业级应用示例,它展示了如何在Spring框架中集成Apache ActiveMQ,以便实现消息队列的功能。ActiveMQ是Apache软件基金会的一个开源项目,它是一个功能丰富的Java消息服务...

    activemq与spring整合发送jms消息入门实例

    在Java世界中,ActiveMQ和Spring的整合是企业级应用中常见的消息中间件解决方案,用于实现JMS(Java Message Service)消息传递。本教程将深入探讨如何将这两个强大的工具结合在一起,以创建一个简单的发送JMS消息的...

    activemq与spring整合源代码

    Spring还提供了丰富的模块,如数据访问、Web、测试等,其中Spring JMS模块专门用于集成消息中间件,使得与ActiveMQ的整合变得简单。 三、ActiveMQ与Spring的整合 1. 添加依赖:首先,在项目中引入ActiveMQ和Spring...

    activeMq整合spring所需jar包

    1. **ActiveMQ**: ActiveMQ是Apache软件基金会开发的一款开源消息中间件,它遵循Java Message Service (JMS) 规范,提供可靠的消息传递服务,支持多种协议,如OpenWire、AMQP、STOMP等。在Spring框架中整合ActiveMQ...

    ActiveMQ整合Spring(多消费者)

    ActiveMQ是Apache软件基金会开发的一个开源消息中间件,它支持多种消息协议,如OpenWire、AMQP、STOMP等,能够很好地与Java平台以及其他语言环境集成。而Spring框架是Java应用开发的首选框架,它提供了丰富的功能,...

    activemq与spring的整合案例

    接下来,我们需要配置Spring的ApplicationContext.xml文件,声明一个ActiveMQ的ConnectionFactory和一个JMS模板(JMSTemplate)。ConnectionFactory是创建连接到消息代理的工厂,而JMSTemplate则是Spring提供的发送...

    activeMQ+spring整合

    ActiveMQ作为Apache软件基金会的一个项目,是一款开源的消息中间件,支持多种协议,如AMQP、STOMP、MQTT等,并且与Java平台紧密结合。Spring框架则是一个广泛使用的Java企业级应用开发框架,提供了一整套的解决方案...

    ActiveMQ与spring整合封装

    ActiveMQ是Apache软件基金会下的一个开源项目,是Java平台上最流行的消息中间件之一。而Spring框架则是Java企业级应用开发的事实标准,提供了丰富的功能和优秀的依赖注入机制。本篇将详细讲解如何将ActiveMQ与Spring...

    spring整合jms+activemq

    在IT行业中,Spring框架是Java领域最广泛应用的轻量级框架之一,而JMS(Java Message Service)则是一种标准接口,用于在分布式系统中进行异步消息传递。ActivemQ是Apache软件基金会的一个项目,它实现了JMS规范,...

    消息中间件ActiveMQ及Spring整合JMS.docx

    【ActiveMQ和Spring整合JMS】的文档主要介绍了消息中间件的基本概念,特别是重点讨论了ActiveMQ和JMS的相关知识。消息中间件是用于不同分布式系统之间数据交流的工具,通过消息传递机制来扩展进程间的通信。ActiveMQ...

    activemq整合spring完整实例代码(内含所有相关jar包)

    这个实例代码是将ActiveMQ与Spring进行整合的一个实际项目,可以在Tomcat服务器上运行。由于提供了所有必要的jar包,所以无需额外下载,直接解压后部署到Tomcat即可。这表明该实例考虑到了用户友好性和易用性,避免...

    java中间件之activemq

    Java中间件领域的ActiveMQ是一款由Apache开发的开源消息中间件,它为企业级应用提供高效、可扩展、稳定且安全的消息通信服务。ActiveMQ的核心目标是实现标准的、面向消息的集成,支持多语言环境,确保不同平台之间的...

    spring整合JMS-居于ActiveMQ实现

    Spring整合JMS基于ActiveMQ实现是一项常见的企业级应用开发任务,它涉及到Spring框架、Java消息服务(JMS)以及ActiveMQ消息中间件的使用。在本文中,我们将深入探讨这三个关键概念,以及如何将它们有效地结合在一起...

    ActiveMQ整合spring、SpringBoot完整源码

    首先,ActiveMQ整合Spring涉及到的是Spring的JMS(Java Message Service)模块。Spring对JMS提供了一套抽象层,简化了与消息中间件的交互。在配置中,我们需要在Spring的XML配置文件或Java配置类中定义一个...

    jms Spring+ActiveMQ 5.4.2

    标题 "jms Spring+ActiveMQ 5.4.2" 涉及的是Java消息服务(JMS)在Spring框架中的应用,以及ActiveMQ作为消息代理的使用。在这个主题下,我们将深入探讨JMS的基本概念、Spring对JMS的支持以及ActiveMQ 5.4.2版本的...

    activemq5.5.1 Spring模板

    Apache ActiveMQ作为开源社区中最受欢迎的消息中间件之一,提供了一种高效、灵活且功能丰富的消息传递平台。本文将深入探讨ActiveMQ 5.5.1版本与Spring框架的集成,以及如何利用Spring的模板模式简化ActiveMQ的使用...

    spring 与ACTIVEMQ整合

    在IT行业中,Spring框架是Java领域最常用的轻量级应用框架之一,而ActiveMQ则是Apache组织开发的一款开源消息中间件,常用于实现应用程序间的异步通信。本文将深入探讨如何将Spring与ActiveMQ进行整合,以提升系统的...

    JMS+ActiveMQ+Spring 完整样例代码

    ActiveMQ是Apache软件基金会开发的一款开源、高性能、跨语言的消息中间件,支持多种协议和JMS规范。Spring框架则提供了与JMS集成的便利,使得开发者可以轻松地在Spring应用中使用消息队列。 在这个"JMS+ActiveMQ+...

    JMS_ActiveMQ_Spring.rar

    《JMS、ActiveMQ与Spring整合的深度解析》 Java消息服务(Java Message Service,简称JMS)是Java平台中用于在分布式环境中交换异步消息的标准API。它为应用程序提供了创建、发送、接收和阅读消息的接口,允许应用...

Global site tag (gtag.js) - Google Analytics