`
chentianliang
  • 浏览: 15470 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Spring集成ActiveMQ配置

    博客分类：
  • java
阅读更多

1.       集成环境

Spring采用2.5.6版本，ActiveMQ使用的是5.4.2，从apache站点可以下载。本文是将Spring集成ActiveMQ来发送和接收JMS消息。

2.       集成步骤

将下载的ActiveMQ解压缩后文件夹如下

 activemq-all-5.4.2.jar是activemq的所有的类jar包。lib下面是模块分解后的jar包。将lib下面的

Java代码 复制代码 收藏代码
  1. /lib/activation-1.1.jar   
  2. /lib/activemq-camel-5.4.2.jar   
  3. /lib/activemq-console-5.4.2.jar   
  4. /lib/activemq-core-5.4.2.jar   
  5. /lib/activemq-jaas-5.4.2.jar   
  6. /lib/activemq-pool-5.4.2.jar   
  7. /lib/activemq-protobuf-1.1.jar   
  8. /lib/activemq-spring-5.4.2.jar   
  9. /lib/activemq-web-5.4.2.jar  
[java] view plaincopyprint?
  1. /lib/activation-1.1.jar  
  2. /lib/activemq-camel-5.4.2.jar  
  3. /lib/activemq-console-5.4.2.jar  
  4. /lib/activemq-core-5.4.2.jar  
  5. /lib/activemq-jaas-5.4.2.jar  
  6. /lib/activemq-pool-5.4.2.jar  
  7. /lib/activemq-protobuf-1.1.jar  
  8. /lib/activemq-spring-5.4.2.jar  
  9. /lib/activemq-web-5.4.2.jar   
/lib/activation-1.1.jar
/lib/activemq-camel-5.4.2.jar
/lib/activemq-console-5.4.2.jar
/lib/activemq-core-5.4.2.jar
/lib/activemq-jaas-5.4.2.jar
/lib/activemq-pool-5.4.2.jar
/lib/activemq-protobuf-1.1.jar
/lib/activemq-spring-5.4.2.jar
/lib/activemq-web-5.4.2.jar

文件全部拷贝到项目中。

而Spring项目所需要的jar包如下 

Java代码 复制代码 收藏代码
  1. /lib/spring-beans-2.5.6.jar   
  2. /lib/spring-context-2.5.6.jar   
  3. /lib/spring-context-support-2.5.6.jar   
  4. /lib/spring-core-2.5.6.jar   
  5. /lib/spring-jms-2.5.6.jar   
  6. /lib/spring-tx.jar  
[java] view plaincopyprint?
  1. /lib/spring-beans-2.5.6.jar  
  2. /lib/spring-context-2.5.6.jar  
  3. /lib/spring-context-support-2.5.6.jar  
  4. /lib/spring-core-2.5.6.jar  
  5. /lib/spring-jms-2.5.6.jar  
  6. /lib/spring-tx.jar  
/lib/spring-beans-2.5.6.jar
/lib/spring-context-2.5.6.jar
/lib/spring-context-support-2.5.6.jar
/lib/spring-core-2.5.6.jar
/lib/spring-jms-2.5.6.jar
/lib/spring-tx.jar

当然还需要一些其他的jar文件

Java代码 复制代码 收藏代码
  1. /lib/geronimo-j2ee-management_1.1_spec-1.0.1.jar   
  2. /lib/jms-1.1.jar   
  3. /lib/log4j-1.2.15.jar   
  4. /lib/slf4j-api-1.6.1.jar   
  5. /lib/slf4j-nop-1.6.1.jar  
[java] view plaincopyprint?
  1. /lib/geronimo-j2ee-management_1.1_spec-1.0.1.jar  
  2. /lib/jms-1.1.jar  
  3. /lib/log4j-1.2.15.jar  
  4. /lib/slf4j-api-1.6.1.jar  
  5. /lib/slf4j-nop-1.6.1.jar   
/lib/geronimo-j2ee-management_1.1_spec-1.0.1.jar
/lib/jms-1.1.jar
/lib/log4j-1.2.15.jar
/lib/slf4j-api-1.6.1.jar
/lib/slf4j-nop-1.6.1.jar

项目的依赖jar都准备好后就可以写配置文件了。

 Spring配置文件

配置文件内容如下

Java代码 复制代码 收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans    
  5.         http://www.springframework.org/schema/beans/spring-beans-2.5.xsd    
  6.         http://www.springframework.org/schema/context    
  7.         http://www.springframework.org/schema/context/spring-context-2.5.xsd"   
  8.     default-autowire="byName">   
  9.   
  10.   
  11.     <!-- 配置connectionFactory -->   
  12.     <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"  
  13.         destroy-method="stop">   
  14.         <property name="connectionFactory">   
  15.             <bean class="org.apache.activemq.ActiveMQConnectionFactory">   
  16.                 <property name="brokerURL">   
  17.                     <value>tcp://127.0.0.1:61616</value>   
  18.                 </property>   
  19.             </bean>   
  20.         </property>   
  21.         <property name="maxConnections" value="100"></property>   
  22.     </bean>   
  23.   
  24.     <!-- Spring JMS Template -->   
  25.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">   
  26.         <property name="connectionFactory">   
  27.             <ref local="jmsFactory" />   
  28.         </property>   
  29.         <property name="defaultDestinationName" value="subject" />   
  30.         <!-- 区别它采用的模式为false是p2p为true是订阅 -->   
  31.         <property name="pubSubDomain" value="true" />   
  32.     </bean>   
  33.   
  34.     <!-- 发送消息的目的地（一个队列） -->   
  35.     <bean id="destination" class="org.apache.activemq.command.ActiveMQTopic">   
  36.         <!-- 设置消息队列的名字 -->   
  37.         <constructor-arg index="0" value="subject" />   
  38.     </bean>   
  39.   
  40.     <!-- 消息监听     -->   
  41.     <bean id="listenerContainer"  
  42.         class="org.springframework.jms.listener.DefaultMessageListenerContainer">   
  43.         <property name="concurrentConsumers" value="10" />   
  44.         <property name="connectionFactory" ref="jmsFactory" />   
  45.         <property name="destinationName" value="subject" />   
  46.         <property name="messageListener" ref="messageReceiver" />   
  47.         <property name="pubSubNoLocal" value="false"></property>   
  48.     </bean>   
  49.   
  50.     <bean id="messageReceiver"  
  51.         class="com.liuyan.jms.consumer.ProxyJMSConsumer">   
  52.         <property name="jmsTemplate" ref="jmsTemplate"></property>   
  53.     </bean>   
  54. </beans>  
[java] view plaincopyprint?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans    
  5.         http://www.springframework.org/schema/beans/spring-beans-2.5.xsd    
  6.         http://www.springframework.org/schema/context    
  7.         http://www.springframework.org/schema/context/spring-context-2.5.xsd"   
  8.     default-autowire="byName">  
  9.   
  10.   
  11.     <!-- 配置connectionFactory -->  
  12.     <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"  
  13.         destroy-method="stop">  
  14.         <property name="connectionFactory">  
  15.             <bean class="org.apache.activemq.ActiveMQConnectionFactory">  
  16.                 <property name="brokerURL">  
  17.                     <value>tcp://127.0.0.1:61616</value>   
  18.                 </property>  
  19.             </bean>  
  20.         </property>  
  21.         <property name="maxConnections" value="100"></property>  
  22.     </bean>  
  23.   
  24.     <!-- Spring JMS Template -->  
  25.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
  26.         <property name="connectionFactory">  
  27.             <ref local="jmsFactory" />  
  28.         </property>  
  29.         <property name="defaultDestinationName" value="subject" />  
  30.         <!-- 区别它采用的模式为false是p2p为true是订阅 -->  
  31.         <property name="pubSubDomain" value="true" />  
  32.     </bean>  
  33.   
  34.     <!-- 发送消息的目的地（一个队列） -->  
  35.     <bean id="destination" class="org.apache.activemq.command.ActiveMQTopic">  
  36.         <!-- 设置消息队列的名字 -->  
  37.         <constructor-arg index="0" value="subject" />  
  38.     </bean>  
  39.   
  40.     <!-- 消息监听     -->  
  41.     <bean id="listenerContainer"  
  42.         class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
  43.         <property name="concurrentConsumers" value="10" />  
  44.         <property name="connectionFactory" ref="jmsFactory" />  
  45.         <property name="destinationName" value="subject" />  
  46.         <property name="messageListener" ref="messageReceiver" />  
  47.         <property name="pubSubNoLocal" value="false"></property>  
  48.     </bean>  
  49.   
  50.     <bean id="messageReceiver"  
  51.         class="com.liuyan.jms.consumer.ProxyJMSConsumer">  
  52.         <property name="jmsTemplate" ref="jmsTemplate"></property>  
  53.     </bean>  
  54. </beans>  
<?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:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-2.5.xsd"
	default-autowire="byName">


	<!-- 配置connectionFactory -->
	<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://127.0.0.1:61616</value>
				</property>
			</bean>
		</property>
		<property name="maxConnections" value="100"></property>
	</bean>

	<!-- Spring JMS Template -->
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory">
			<ref local="jmsFactory" />
		</property>
		<property name="defaultDestinationName" value="subject" />
		<!-- 区别它采用的模式为false是p2p为true是订阅 -->
		<property name="pubSubDomain" value="true" />
	</bean>

	<!-- 发送消息的目的地（一个队列） -->
	<bean id="destination" class="org.apache.activemq.command.ActiveMQTopic">
		<!-- 设置消息队列的名字 -->
		<constructor-arg index="0" value="subject" />
	</bean>

	<!-- 消息监听     -->
	<bean id="listenerContainer"
		class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="concurrentConsumers" value="10" />
		<property name="connectionFactory" ref="jmsFactory" />
		<property name="destinationName" value="subject" />
		<property name="messageListener" ref="messageReceiver" />
		<property name="pubSubNoLocal" value="false"></property>
	</bean>

	<bean id="messageReceiver"
		class="com.liuyan.jms.consumer.ProxyJMSConsumer">
		<property name="jmsTemplate" ref="jmsTemplate"></property>
	</bean>
</beans>

编写代码

消息发送者：这里面消息生产者并没有在Spring配置文件中进行配置，这里仅仅使用了Spring中的JMS模板和消息目的而已。 

Java代码 复制代码 收藏代码
  1. public class HelloSender {   
  2.   
  3.     /**  
  4.      * @param args  
  5.      */  
  6.     public static void main(String[] args) {   
  7.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext(   
  8.                 new String[] { "classpath:/spring/applicationContext-jms.xml" });   
  9.            
  10.         JmsTemplate template = (JmsTemplate) applicationContext   
  11.                 .getBean("jmsTemplate");   
  12.            
  13.         Destination destination = (Destination) applicationContext   
  14.                 .getBean("destination");   
  15.   
  16.         template.send(destination, new MessageCreator() {   
  17.             public Message createMessage(Session session) throws JMSException {   
  18.                 return session   
  19.                         .createTextMessage("发送消息：Hello ActiveMQ Text Message！");   
  20.             }   
  21.         });   
  22.         System.out.println("成功发送了一条JMS消息");   
  23.   
  24.     }   
  25.   
  26. }  
[java] view plaincopyprint?
  1. public class HelloSender {  
  2.   
  3.     /** 
  4.      * @param args 
  5.      */  
  6.     public static void main(String[] args) {  
  7.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext(  
  8.                 new String[] { "classpath:/spring/applicationContext-jms.xml" });  
  9.           
  10.         JmsTemplate template = (JmsTemplate) applicationContext  
  11.                 .getBean("jmsTemplate");  
  12.           
  13.         Destination destination = (Destination) applicationContext  
  14.                 .getBean("destination");  
  15.   
  16.         template.send(destination, new MessageCreator() {  
  17.             public Message createMessage(Session session) throws JMSException {  
  18.                 return session  
  19.                         .createTextMessage("发送消息：Hello ActiveMQ Text Message！");  
  20.             }  
  21.         });  
  22.         System.out.println("成功发送了一条JMS消息");  
  23.   
  24.     }  
  25.   
  26. }  
public class HelloSender {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
				new String[] { "classpath:/spring/applicationContext-jms.xml" });
		
		JmsTemplate template = (JmsTemplate) applicationContext
				.getBean("jmsTemplate");
		
		Destination destination = (Destination) applicationContext
				.getBean("destination");

		template.send(destination, new MessageCreator() {
			public Message createMessage(Session session) throws JMSException {
				return session
						.createTextMessage("发送消息：Hello ActiveMQ Text Message！");
			}
		});
		System.out.println("成功发送了一条JMS消息");

	}

}

消息接收

Java代码 复制代码 收藏代码
  1. /**  
  2.  * JMS消费者  
  3.  *   
  4.  *   
  5.  * <p>  
  6.  * 消息题的内容定义  
  7.  * <p>  
  8.  * 消息对象 接收消息对象后： 接收到的消息体* <p>   
  9.  */  
  10. public class ProxyJMSConsumer {   
  11.   
  12.     public ProxyJMSConsumer() {   
  13.   
  14.     }   
  15.   
  16.     private JmsTemplate jmsTemplate;   
  17.   
  18.     public JmsTemplate getJmsTemplate() {   
  19.         return jmsTemplate;   
  20.     }   
  21.   
  22.     public void setJmsTemplate(JmsTemplate jmsTemplate) {   
  23.         this.jmsTemplate = jmsTemplate;   
  24.     }   
  25.   
  26.     /**  
  27.      * 监听到消息目的有消息后自动调用onMessage(Message message)方法  
  28.      */  
  29.     public void recive() {   
  30.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext(   
  31.                 new String[] { "classpath:/spring/applicationContext-jms.xml" });   
  32.   
  33.         Destination destination = (Destination) applicationContext   
  34.                 .getBean("destination");   
  35.   
  36.         while (true) {   
  37.   
  38.             try {   
  39.                 TextMessage txtmsg = (TextMessage) jmsTemplate   
  40.                         .receive(destination);   
  41.                 if (null != txtmsg) {   
  42.                     System.out.println("[DB Proxy] " + txtmsg);   
  43.                     System.out.println("[DB Proxy] 收到消息内容为: "  
  44.                             + txtmsg.getText());   
  45.                 } else  
  46.                     break;   
  47.             } catch (Exception e) {   
  48.                 e.printStackTrace();   
  49.             }   
  50.   
  51.         }   
  52.     }   
  53.   
  54. }  
[java] view plaincopyprint?
  1. /** 
  2.  * JMS消费者 
  3.  *  
  4.  *  
  5.  * <p> 
  6.  * 消息题的内容定义 
  7.  * <p> 
  8.  * 消息对象 接收消息对象后： 接收到的消息体* <p>  
  9.  */  
  10. public class ProxyJMSConsumer {  
  11.   
  12.     public ProxyJMSConsumer() {  
  13.   
  14.     }  
  15.   
  16.     private JmsTemplate jmsTemplate;  
  17.   
  18.     public JmsTemplate getJmsTemplate() {  
  19.         return jmsTemplate;  
  20.     }  
  21.   
  22.     public void setJmsTemplate(JmsTemplate jmsTemplate) {  
  23.         this.jmsTemplate = jmsTemplate;  
  24.     }  
  25.   
  26.     /** 
  27.      * 监听到消息目的有消息后自动调用onMessage(Message message)方法 
  28.      */  
  29.     public void recive() {  
  30.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext(  
  31.                 new String[] { "classpath:/spring/applicationContext-jms.xml" });  
  32.   
  33.         Destination destination = (Destination) applicationContext  
  34.                 .getBean("destination");  
  35.   
  36.         while (true) {  
  37.   
  38.             try {  
  39.                 TextMessage txtmsg = (TextMessage) jmsTemplate  
  40.                         .receive(destination);  
  41.                 if (null != txtmsg) {  
  42.                     System.out.println("[DB Proxy] " + txtmsg);  
  43.                     System.out.println("[DB Proxy] 收到消息内容为: "  
  44.                             + txtmsg.getText());  
  45.                 } else  
  46.                     break;  
  47.             } catch (Exception e) {  
  48.                 e.printStackTrace();  
  49.             }  
  50.   
  51.         }  
  52.     }  
  53.   
  54. }  
/**
 * JMS消费者
 * 
 * 
 * <p>
 * 消息题的内容定义
 * <p>
 * 消息对象 接收消息对象后： 接收到的消息体* <p> 
 */
public class ProxyJMSConsumer {

	public ProxyJMSConsumer() {

	}

	private JmsTemplate jmsTemplate;

	public JmsTemplate getJmsTemplate() {
		return jmsTemplate;
	}

	public void setJmsTemplate(JmsTemplate jmsTemplate) {
		this.jmsTemplate = jmsTemplate;
	}

	/**
	 * 监听到消息目的有消息后自动调用onMessage(Message message)方法
	 */
	public void recive() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
				new String[] { "classpath:/spring/applicationContext-jms.xml" });

		Destination destination = (Destination) applicationContext
				.getBean("destination");

		while (true) {

			try {
				TextMessage txtmsg = (TextMessage) jmsTemplate
						.receive(destination);
				if (null != txtmsg) {
					System.out.println("[DB Proxy] " + txtmsg);
					System.out.println("[DB Proxy] 收到消息内容为: "
							+ txtmsg.getText());
				} else
					break;
			} catch (Exception e) {
				e.printStackTrace();
			}

		}
	}

}

这里边也是并不是直接使用Spring来初始化建立消息消费者实例，而是在此消费者注入了JMS模板而已。

写一个main入口，初始化消息消费者  

Java代码 复制代码 收藏代码
  1. public class JMSTest {   
  2.   
  3.     /**  
  4.      * @param args  
  5.      */  
  6.     public static void main(String[] args) {   
  7.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext(   
  8.                 new String[] { "classpath:/spring/applicationContext-jms.xml" });   
  9.            
  10.         ProxyJMSConsumer proxyJMSConsumer = (ProxyJMSConsumer) applicationContext   
  11.                 .getBean("messageReceiver");   
  12.            
  13.         System.out.println("初始化消息消费者");   
  14.     }   
  15.   
  16. }  
[java] view plaincopyprint?
  1. public class JMSTest {  
  2.   
  3.     /** 
  4.      * @param args 
  5.      */  
  6.     public static void main(String[] args) {  
  7.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext(  
  8.                 new String[] { "classpath:/spring/applicationContext-jms.xml" });  
  9.           
  10.         ProxyJMSConsumer proxyJMSConsumer = (ProxyJMSConsumer) applicationContext  
  11.                 .getBean("messageReceiver");  
  12.           
  13.         System.out.println("初始化消息消费者");  
  14.     }  
  15.   
  16. }  
public class JMSTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
				new String[] { "classpath:/spring/applicationContext-jms.xml" });
		
		ProxyJMSConsumer proxyJMSConsumer = (ProxyJMSConsumer) applicationContext
				.getBean("messageReceiver");
		
		System.out.println("初始化消息消费者");
	}

}

使用的时候先开启ActiveMQ服务，默认是占用了61616端口。之后开启测试程序，开启2个消息消费者监听。之后再运行消息生产者的代码后，消息就可以被消息消费者接收到了。 

分享到：
| 用maven构建项目
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring集成ActiveMQ配置.docx

    Spring 集成 ActiveMQ 配置 Spring 集成 ActiveMQ 配置是指将 Spring 框架与 ActiveMQ 消息队列集成，以实现基于 JMS（Java Message Service）的消息传递。ActiveMQ 是 Apache 软件基金会的一个开源的消息队列系统...

    spring集成activemq例子demo

    在Spring框架中集成ActiveMQ，我们可以创建一个高效的、可扩展的系统，利用消息队列来解耦生产者和消费者，提高系统的响应速度和可靠性。以下将详细介绍如何进行Spring与ActiveMQ的集成，并提供一些关键知识点。 1....

    spring配置activemq详解

    - 结合Spring Boot的自动配置能力，可以极大地简化ActiveMQ的集成过程，只需少量配置就能快速启动和运行。 7. **监控和管理**： - ActiveMQ提供了Web控制台，可以通过浏览器进行监控和管理，查看队列状态、消息...

    ActiveMQ+spring配置方案详解

    当我们需要在Spring应用中集成ActiveMQ时，就需要进行相应的配置。本文将深入讲解ActiveMQ与Spring的整合配置方案。 首先，我们需要在项目中引入ActiveMQ的相关依赖。这通常通过在`pom.xml`文件中添加Maven依赖来...

    spring集成activemq演示queue和topic 持久化

    以上就是Spring集成ActiveMQ的基本流程，涉及Queue和Topic的创建、持久化到MySQL以及消息的发送与接收。这个测试Demo涵盖了消息中间件的核心功能，可以帮助你理解并实践消息传递系统在实际项目中的应用。

    Spring整合activemq

    在Spring框架中，我们可以通过使用Spring的JMS模块来配置ActiveMQ。这个过程涉及到以下几个关键点： 1. **JMS配置**：在Spring的配置文件中，我们需要定义一个`ConnectionFactory`，它是与消息代理（如ActiveMQ）...

    spring+activeMQ集成

    spring集成activeMQ框架 配置方式（内含三种常见的消息接受监听方式的配置）JMS 配置测试等等

    spring使用activeMQ实现消息发送

    Spring提供了`spring-jms`模块，它包含了一组丰富的API和配置选项，使得在Spring应用中集成ActiveMQ变得简单。通过使用`JmsTemplate`类，我们可以方便地发送和接收消息。 1. **配置ActiveMQ**：在开始之前，我们...

    Spring集成ActiveMQ

    在Spring集成ActiveMQ时，通常会采用Spring的配置文件形式来配置消息工厂（ConnectionFactory）、消息队列目的地（Destination）、消息监听容器（MessageListenerContainer）等。这样的配置方式可以让Spring管理...

    spring activeMQ-demo 配置

    本篇将深入讲解如何在Spring环境中配置和使用ActiveMQ。 首先，我们需要了解Spring与ActiveMQ集成的基本概念。Spring框架提供了一套完整的JMS（Java Message Service）支持，可以方便地与各种消息队列进行整合，...

    Spring-ActiveMQ.rar_Spring Activemq_activemq_activemq spring

    本篇将深入探讨Spring与ActiveMQ的集成及其配置过程。 首先，理解Spring与ActiveMQ集成的基本概念至关重要。Spring的`Spring Integration`模块提供了与多种消息中间件集成的API，其中包括ActiveMQ。通过这些API，...

    spring整合Activemq源码

    Spring作为Java领域的主流框架，与ActiveMQ的集成使得这种消息中间件的使用更加便捷。本文将详细探讨Spring与ActiveMQ的整合过程，以及相关的知识点。 1. **Spring框架**：Spring是Java开发中的一个全功能框架，...

    spring boot 集成activemq Datajpa Ehcache

    在Spring Boot中集成ActiveMQ，我们可以利用Spring的`@EnableJms`注解来启用JMS支持，并通过配置ActiveMQ服务器的URL、用户名和密码等信息，实现消息的发送和接收。这将极大地提升系统的异步处理能力和可扩展性。 ...

    SpringBoot集成ActiveMQ实例详解.docx

    在Spring Boot中集成ActiveMQ非常简便，因为Spring Boot提供了`spring-boot-starter-activemq`启动器，该启动器包含了自动配置的支持。首先，我们需要在项目中添加相应的依赖： ```xml &lt;groupId&gt;org.spring...

    spring+activemq

    接下来，**Spring与ActiveMQ的集成**：在Spring应用中配置ActiveMQ，通常需要在Spring配置文件中定义`JmsTemplate`和`DefaultMessageListenerContainer`。`JmsTemplate`用于发送消息，而`...

    Spring与ActiveMQ整合完整案例

    - ` applicationContext.xml`：Spring的配置文件，配置ActiveMQ的相关组件。 - `MessageProducer`：生产消息的类，通常会使用JMS Template发送消息到队列或主题。 - `MessageConsumer`：消费消息的类，通过实现...

Magicbox
Global site tag (gtag.js) - Google Analytics