spring+activemq整合学习

最新推荐文章于 2025-07-26 14:30:58 发布
转载 最新推荐文章于 2025-07-26 14:30:58 发布 · 654 阅读 · 0

本文介绍如何使用Spring框架整合ActiveMQ实现消息队列功能，包括消息生产者、消费者的配置与代码实现，以及发布/订阅模式的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转：http://elim.iteye.com/blog/1893038
pom.xml 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.test</groupId>
	<artifactId>SpringMQproducer</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<activemq.version>5.14.3</activemq.version>
		<springframework>4.3.2.RELEASE</springframework>
		<slf4j.version>1.7.7</slf4j.version>
		<log4j.version>1.2.17</log4j.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${springframework}</version>
		</dependency>
		<!-- 集成JMS -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jms</artifactId>
			<version>${springframework}</version>
		</dependency>

		<!--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>


		<!-- Log -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j.version}</version>
		</dependency>
	</dependencies>
</project>


消息队列

消息生产者

spring配置文件 
<?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:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	
	<!-- 配置要扫描的包 -->
	<context:component-scan base-package="com.test.activemq" />

	<!-- 读入配置属性文件 -->
	<context:property-placeholder location="classpath:mq.properties" />

	<import resource="spring-mq.xml" />
</beans>

spring-mq.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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-4.0.xsd">


	<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
		<!-- ActiveMQ服务地址 -->
		<property name="brokerURL" value="${mq.brokerURL}" />
		<property name="userName" value="${mq.userName}"></property>
		<property name="password" value="${mq.password}"></property>
		<!-- <property name="trustAllPackages" value="true" /> -->
	</bean>

	<!-- ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory 
		可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗。 要依赖于 activemq-pool包 -->
	<bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
		<property name="connectionFactory" ref="targetConnectionFactory" />
		<property name="maxConnections" value="${mq.pool.maxConnections}" />
	</bean>

	<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
	<bean id="connectionFactory"
		class="org.springframework.jms.connection.SingleConnectionFactory">
		<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
		<property name="targetConnectionFactory" ref="pooledConnectionFactory" />
	</bean>

	<!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
	<!-- 队列模板 -->
	<bean id="activeMqJmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="defaultDestinationName" value="${queueName}"></property><!-- 
			配置默认的defaultDestination -->
	</bean>

	<!--指定队列目的地，点对点的 -->
	<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg>
			<value>${queueName}</value>
		</constructor-arg>
	</bean>

</beans>


mq.properties 
## MQ
mq.brokerURL=tcp\://127.0.0.1\:61616
mq.userName=admin
mq.password=admin
mq.pool.maxConnections=10
#queueName
queueName=FirstQueue1
java 代码 
package com.test.activemq;

import java.io.Serializable;

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

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.stereotype.Component;

/**
 * @描述: MQ消息生产者 .
 * 
 */
@Component("mqProducer")
public class MQProducer {

	@Autowired
	@Qualifier("activeMqJmsTemplate")
	private JmsTemplate jmsTemplate;

	@Autowired
	@Qualifier("queueDestination")
	private Destination destination;

	/**
	 * 使用默认的defaultDestination发送消息.
	 * 
	 */
	public void sendMessage(final String message) {
		jmsTemplate.send(new MessageCreator() {
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage(message);
			}
		});
	}

	/**
	 * 使用默认的defaultDestination发送序列化对象
	 */
	public void sendMessage(final Serializable obj) {
		jmsTemplate.send(new MessageCreator() {
			public Message createMessage(Session session) throws JMSException {
				return session.createObjectMessage(obj);
			}
		});
	}

	/**
	 * 指定destination发送消息.
	 * 
	 */
	public void sendMessageByDestination(final String message) {
		jmsTemplate.send(destination, new MessageCreator() {
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage(message);
			}
		});
	}

	/**
	 * 指定destination发送序列化对象
	 */
	public void sendMessageByDestination(final Serializable obj) {
		jmsTemplate.send(destination, new MessageCreator() {
			public Message createMessage(Session session) throws JMSException {
				return session.createObjectMessage(obj);
			}
		});
	}

}



启动消息生产者 代码 
package com.test.activemq;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.test.activemq.bean.Email;

public class MQProducerTest {
	private static final int SENDNUM = 10;// 发送的消息数量
	private static final Log log = LogFactory.getLog(MQProducerTest.class);

	public static void main(String[] args) {
		try {
			ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
					"classpath:spring/spring-context.xml");

			context.start();

			MQProducer mqProducer = (MQProducer) context.getBean("mqProducer");

			for (int i = 0; i < MQProducerTest.SENDNUM; i++) {
				Email email = new Email("receiver" + i, "title" + i, "content" + i);
				mqProducer.sendMessageByDestination(email);
				mqProducer.sendMessage("MQ发送文本消息-"+i);
				System.out.println(email);

			}
			context.stop();
		} catch (Exception e) {
			log.error("==>MQ context start error:", e);
			System.exit(0);
		} finally {
			log.info("===>System.exit");
			System.exit(0);
		}
	}
}

Email 
package com.test.activemq.bean;

import java.io.Serializable;

public class Email implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 3374150870949603919L;

	private String receiver;
	private String title;
	private String content;

	public Email() {
	}

	public Email(String receiver, String title, String content) {
		super();
		this.receiver = receiver;
		this.title = title;
		this.content = content;
	}

	public String getReceiver() {
		return receiver;
	}

	public void setReceiver(String receiver) {
		this.receiver = receiver;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	@Override
	public String toString() {
		return "Email [receiver=" + receiver + ", title=" + title + ", content=" + content + "]";
	}

}




消息消费者
spring配置文件 
<?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:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-4.0.xsd">


	<!-- 配置要扫描的包 -->
	<context:component-scan base-package="com.test.activemq" />

	<!-- 读入配置属性文件 -->
	<context:property-placeholder location="classpath:mq.properties" />
	<import resource="spring-mq.xml" />

</beans>

spring-mq.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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-4.0.xsd">

	<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
		<!-- ActiveMQ服务地址 -->
		<property name="brokerURL" value="${mq.brokerURL}" />
		<property name="userName" value="${mq.userName}"></property>
		<property name="password" value="${mq.password}"></property>
		<property name="trustAllPackages" value="true" />
	</bean>

	<!-- ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory 
		可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗。 要依赖于 activemq-pool包 -->
	<bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
		<property name="connectionFactory" ref="targetConnectionFactory" />
		<property name="maxConnections" value="${mq.pool.maxConnections}" />
	</bean>

	<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
	<bean id="connectionFactory"
		class="org.springframework.jms.connection.SingleConnectionFactory">
		<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
		<property name="targetConnectionFactory" ref="pooledConnectionFactory" />
	</bean>

	<!--这个是队列目的地 -->
	<bean id="sessionAwareQueue" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg>
			<value>${queueName}</value>
		</constructor-arg>
	</bean>

	<!-- 可以获取session的MessageListener消息监听器 -->
<!-- 	<bean id="consumerSessionAwareMessageListener"
		class="com.test.activemq.listener.ConsumerSessionAwareMessageListener"></bean> -->

	<!-- 消息监听器 -->
	<bean id="consumerMessageListener" class="com.test.activemq.listener.ConsumerMessageListener" />

	<!-- 消息监听容器 -->
	<bean id="jmsContainer"
		class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="destination" ref="sessionAwareQueue" />
		<property name="messageListener" ref="consumerMessageListener" />
	</bean>

</beans>



mq.properties 与消息生产者一样






 


 
 

 


 监听器

 


 
package com.test.activemq.listener;

import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import javax.jms.TextMessage;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.test.activemq.bean.Email;

public class ConsumerMessageListener implements MessageListener {

	private static final Log log = LogFactory.getLog(ConsumerMessageListener.class);

	@Override
	public synchronized void onMessage(Message message) {
		try {
			if (message instanceof ObjectMessage) {
				ObjectMessage objectMessage = (ObjectMessage) message;

				Object object = objectMessage.getObject();
				Email email = (Email) object;
				log.info("==>receive message:" + email.toString());

			} else if (message instanceof TextMessage) {
				TextMessage msg = (TextMessage) message;
				final String ms = msg.getText();
				log.info("==>receive message:" + ms);

			}
		} catch (Exception e) {
			log.error("==>", e);
		}
	}

}


 
 
 
 

 


 
 启动测试 消息消费者

 


 
package com.me.activemq.mqtest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 *  ActiveMQ测试启动类  .
 */
public class MQConsumer {
	private static final Log log = LogFactory.getLog(MQConsumer.class);

	public static void main(String[] args) {
		try {
			ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-context.xml");
			context.start();
		} catch (Exception e) {
			log.error("==>MQ context start error:", e);
			System.exit(0);
		}
	}
}


 
 
 

  订阅/发布
 
 
 

  消息生产者-消息发布者：（先启动订阅者，再发布消息，否则订阅者接收不到消息生产者发布的消息，和订阅报纸一样的道理...）
 
 

 


 spring配置文件

 


 
<?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:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	
	<!-- 配置要扫描的包 -->
	<context:component-scan base-package="com.me.activemq" />

	<!-- 读入配置属性文件 -->
	<context:property-placeholder location="classpath:mq.properties" />

	<import resource="spring-mq.xml" />
</beans>
spring-mq.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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	

	<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
		<!-- ActiveMQ服务地址 -->
        <property name="brokerURL" value="${mq.brokerURL}" />
        <property name="userName" value="${mq.userName}"></property>
        <property name="password" value="${mq.password}"></property> 
	</bean>

    <!-- 
    	ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory
    	可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗。
    	要依赖于 activemq-pool包
     -->
	<bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
		<property name="connectionFactory" ref="targetConnectionFactory" />
		<property name="maxConnections" value="${mq.pool.maxConnections}" />
	</bean>

	<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
		<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
		<property name="targetConnectionFactory" ref="pooledConnectionFactory" />
	</bean>
	
	<!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
	<!-- 队列模板 -->
	<bean id="activeMqJmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
	    <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
	    <property name="connectionFactory" ref="connectionFactory"/>  
	    <property name="defaultDestinationName" value="${TopicName}"></property>
	     <!-- 开启订阅模式 -->
        <property name="pubSubDomain" value="true"/>
	</bean> 

</beans>
mq.properties

 


 
## MQ
mq.brokerURL=tcp\://127.0.0.1\:61616
mq.userName=admin
mq.password=admin
mq.pool.maxConnections=10
#TopicName
TopicName=FirstTopic1
 
 

  
 
 
 java代码

 


 
package com.me.activemq;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Service;

/**
 * @描述: MQ消息生产者 .
 * 
 */
@Service("mqProducer")
public class MQProducer {

	@Autowired
	private JmsTemplate activeMqJmsTemplate;

	/**
	 * 发送消息.
	 * 
	 */
	public void sendMessage(final String message) {
		activeMqJmsTemplate.send(new MessageCreator() {
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage(message);
			}
		});

	}

}


 
 发布消息
 
package com.me.activemq.test;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.me.activemq.MQProducer;

public class MQProducerTest {
	private static final int SENDNUM = 10;// 发送的消息数量
	private static final Log log = LogFactory.getLog(MQProducerTest.class);
	public static void main(String[] args) {
		try {
			ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-context.xml");
			
			context.start();
			
			MQProducer mqProducer = (MQProducer) context.getBean("mqProducer");
			
			for (int i = 0; i < MQProducerTest.SENDNUM; i++) {
				String message ="ActiveMQ 发送的消息"+i;
				mqProducer.sendMessage(message);
				System.out.println(message);
				
			}
	        context.stop();
		} catch (Exception e) {
			log.error("==>MQ context start error:", e);
			System.exit(0);
		} finally {
			log.info("===>System.exit");
			System.exit(0);
		}
	}
}


 
 消息消费者---订阅者

 


 spring配置文件

 


 
<?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:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-4.0.xsd">


	<!-- 配置要扫描的包 -->
	<context:component-scan base-package="com.me.activemq" />
	<!-- 读入配置属性文件 -->
	<context:property-placeholder location="classpath:mq.properties" />
	<import resource="spring-mq.xml" />
</beans>
spring-mq.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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-4.0.xsd">

	<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
		<!-- ActiveMQ服务地址 -->
        <property name="brokerURL" value="${mq.brokerURL}" />
        <property name="userName" value="${mq.userName}"></property>
        <property name="password" value="${mq.password}"></property> 
	</bean>

    <!-- 
    	ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory
    	可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗。
    	要依赖于 activemq-pool包
     -->
	<bean id="pooledConnectionFactory" class="org.apache.activemq.pool.PooledConnectionFactory">
		<property name="connectionFactory" ref="targetConnectionFactory" />
		<property name="maxConnections" value="${mq.pool.maxConnections}" />
	</bean>

	<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
		<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
		<property name="targetConnectionFactory" ref="pooledConnectionFactory" />
	</bean>
	
	<!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
	
	<!-- 队列模板 -->
	<bean id="activeMqJmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
	    <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
	    <property name="connectionFactory" ref="connectionFactory"/>  
	    <property name="defaultDestinationName" value="${TopicName}"></property>
	    <property name="receiveTimeout" value="100000" />
	</bean> 
	
	<!--这个是sessionAwareQueue目的地 -->
	<bean id="sessionAwareTopic" class="org.apache.activemq.command.ActiveMQTopic">
		<constructor-arg>
			<value>${TopicName}</value>
		</constructor-arg>
	</bean>


	<!-- 可以获取session的MessageListener -->
	<bean id="consumerSessionAwareMessageListener" class="com.me.activemq.listener.ConsumerSessionAwareMessageListener"></bean>

	 <!-- 消息订阅客户端1 -->
    <bean id="consumerListenerClient1" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory" />
        <!-- 开启订阅模式 -->
        <property name="pubSubDomain" value="true"/>
        <property name="destination" ref="sessionAwareTopic" />
        <property name="messageListener" ref="consumerSessionAwareMessageListener" />
    </bean>
    
    	<!-- 可以获取session的MessageListener -->
	<bean id="consumerSessionAwareMessageListener2" class="com.me.activemq.listener.ConsumerSessionAwareMessageListener2"></bean>

	 <!-- 消息订阅客户端2 -->
    <bean id="consumerListenerClient2" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory" />
        <!-- 开启订阅模式 -->
        <property name="pubSubDomain" value="true"/>
        <property name="destination" ref="sessionAwareTopic" />
        <property name="messageListener" ref="consumerSessionAwareMessageListener2" />
    </bean>
    


</beans>

 
 mq.properties 与消息生产者一样

 


 监听器

 


 
package com.me.activemq.listener;

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

import org.apache.activemq.command.ActiveMQTextMessage;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.jms.listener.SessionAwareMessageListener;
import org.springframework.stereotype.Component;

/**
 * 监听器 .
 * 
 */
@Component
public class ConsumerSessionAwareMessageListener implements SessionAwareMessageListener<Message> {

	private static final Log log = LogFactory.getLog(ConsumerSessionAwareMessageListener.class);

	
	public synchronized void onMessage(Message message, Session session) {
		try {
			ActiveMQTextMessage msg = (ActiveMQTextMessage) message;
			final String ms = msg.getText();
			log.info("==>订阅者一 ----》receive message:" +ms);
	
		} catch (Exception e) {
			log.error("==>", e);
		}
	}
}


 
 
 
package com.me.activemq.listener;

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

import org.apache.activemq.command.ActiveMQTextMessage;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.jms.listener.SessionAwareMessageListener;
import org.springframework.stereotype.Component;



/**
 *监听器 .
 * 
 */
@Component
public class ConsumerSessionAwareMessageListener2 implements SessionAwareMessageListener<Message> {

	private static final Log log = LogFactory.getLog(ConsumerSessionAwareMessageListener2.class);

	
	public synchronized void onMessage(Message message, Session session) {
		try {
			ActiveMQTextMessage msg = (ActiveMQTextMessage) message;
			final String ms = msg.getText();
			log.info("==>订阅者二----》receive message:" +ms);
	
		} catch (Exception e) {
			log.error("==>", e);
		}
	}
}


 
 
 
 启动消息订阅者

 


 
package com.me.activemq.mqtest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 *  ActiveMQ测试启动类  .
 */
public class MQConsumer {
	private static final Log log = LogFactory.getLog(MQConsumer.class);

	public static void main(String[] args) {
		try {
			ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-context.xml");
			context.start();
		} catch (Exception e) {
			log.error("==>MQ context start error:", e);
			System.exit(0);
		}
	}
}


 
 代码：
 http://download.youkuaiyun.com/detail/u014695188/9739974
 
 
 
 
 
 

 


 
 

 


 
 
 
 


                

        

    

    
  



    



                



	

		

			

				
					
Spring整合ActiveMq

				
			

			

				

					马小果v:ma-xiaoguo的博客
				

				

					02-19
					
					945
					
				

			

		

		

			
				
1、概述
多种语言和协议编写客户端。语言: Java, C, C++, C#, Ruby, Perl, Python, PHP。应用协议: OpenWire,Stomp REST,WS Notification,XMPP,AMQP
完全支持JMS1.1和J2EE 1.4规范 (持久化,XA消息,事务)
对Spring的支持,ActiveMQ可以很容易内嵌到使用Spring的系统里面去,而且也支持Spring2.0的特性
通过了常见J2EE服务器(如 Geronimo,JBoss 4, GlassFish,W

			
		

	



                

            
              



	

		

			

				
					
Spring+ActiveMQ整合实例代码工程

				
			

			

				

					11-23
				

			

		

		

			
				
**Spring与ActiveMQ整合详解**  在Java开发中，Spring框架是极为重要的应用基础，而ActiveMQ作为Apache出品的一款开源消息中间件，常被用于实现应用间的异步通信和解耦。本实例代码工程"Spring+ActiveMQ整合实例代码...

			
		

	



              


  
              

                


	

		

			

				
					
rabbitmq学习（Spring应用整合）

				
			

			

				

					kxq的博客
				

				

					10-31
					
					106
					
				

			

		

		

			
				
一、搭建项目
利用的是idea软件：
1.1新建项目 选择Spring Initializr
1.2依赖选择：

1.3项目目录：
将application.propertices 改成application.yml
然后配置此文件：
server:
  port: 8080
spring:
  application:
    name: producer
  rabbitmq:
    host: localhost
    port: 5672
    virtual-host: host1
    

			
		

	





	

		

			

				
					
Spring配置文件头及xsd文件版本

				
			

			

				

					weixin_34217711的博客
				

				

					08-10
					
					986
					
				

			

		

		

			
				
最初Spring配置文件的头部声明如下： Xml代码  &lt;?xml version="1.0" encoding="UTF-8"?&gt;  &lt;!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"  "http://www.springframework.org/dtd/spring-beans-2.0.dtd"&gt;  &l

			
		

	



		

			
		



	

		

			

				
					
spring配置文件中xsd引用问题

					
热门推荐

				
			

			

				

					dingqinghu的专栏
				

				

					07-04
					
					8万+
					
				

			

		

		

			
				
XML的一些概念

首先来看下xml的一些概念：

xml的schema里有namespace，可以给它起个别名。比如常见的spring的namespace：


	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/co

			
		

	





	

		

			

				
					
Spring4.0的Schema文件

				
			

			

				

					weixin_40641900的博客
				

				

					12-02
					
					894
					
				

			

		

		

			
				
Spring4.0的Schema文件
spring xml配置文件头命名空间 xsd文件配置

		  
		    Schema文件
		    说明
		  
		  
		    spring-beans-4.0.xsd
		    
		    	[说明]：Spring4.0最主要的Schema,用于配置Bean 
		    	[命名空间]：http://www.springframew...

			
		

	





	

		

			

				
					
Spring+ActiveMQ

				
			

			

				

					weixin_44929475的博客
				

				

					10-21
					
					1091
					
				

			

		

		

			
				
Spring集成ActiveMQ实现消息发送，两种消息模型和三种消息类型。

			
		

	





	

		

			

				
					
JMS+ActiveMQ+Spring 整合实践教程

				
			

			

				

					weixin_36173034的博客
				

				

					07-26
					
					865
					
				

			

		

		

			
				
Java消息服务（JMS）定义了一组API和相应的语义，以实现不同应用程序之间的异步通信。JMS提供了一种将消息发送到目的地，并从中接收消息的机制。消息通常在分布式系统的组件之间传递，这些组件可以位于不同的服务器上，甚至不同的网络中。

			
		

	





	

		

			

				
					
Spring+JMS+ActiveMq整合

				
			

			

				

					qq_35222843的博客
				

				

					02-27
					
					247
					
				

			

		

		

			
				
3.Spring整合JMS

3.1 点对点模式

3.1.1消息生产者

（1）创建工程springjms_producer，在POM文件中引入SpringJms 、activeMQ以及单元测试相关依赖






 1 <dependencies>
 2           <dependency>
 3             <groupId>org....

			
		

	





	

		

			

				
					
Spring+ActiveMQ整合Demo

				
			

			

				

					郭靖宇的个人博客
				

				

					04-26
					
					728
					
				

			

		

		

			
				
新建web工程，导入jar包到lib目录，然后buildpath。整体结构如下：创建spring.xml&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:amq="http://activemq.apache.org/sc...

			
		

	





	

		

			

				
					
spring+activemq

				
			

			

				

					02-23
				

			

		

		

			
				
在IT行业中，Spring框架与ActiveMQ的结合是构建企业级应用中常见的消息中间件解决方案。Spring框架是一个开源的Java平台，它提供了丰富的功能，包括依赖注入、AOP（面向切面编程）、数据访问、Web应用以及更多的服务...

			
		

	





	

		

			

				
					
SpringMVC+Spring+Mybatis框架整合Mqttt通信协议+ActiveMQ作为中间件进行消息的发布与订阅

				
			

			

				

					06-21
				

			

		

		

			
				
单片机部分采用MQTT协议将主题消息发布到队列中，java部分也采用MQTT协议进行处理，整合MQTT协议， 具体这个资源是干什么的,请查看博客： https://blog.youkuaiyun.com/qq_34178998/article/details/93158429

			
		

	





	

		

			

				
					
基于Spring+JMS+ActiveMQ+Tomcat的整合ActiveMQSpringDemo实例源码.zip

				
			

			

				

					05-27
				

			

		

		

			
				
基于Spring+JMS+ActiveMQ+Tomcat的整合ActiveMQSpringDemo实例源码，此实例基于Spring+JMS+ActiveMQ+Tomcat，注解的完整实例，包含jar包，可供学习及设计参考。

			
		

	





	

		

			

				
					
Maven+Spring+ActiveMQ整合

				
			

			

				

					02-23
				

			

		

		

			
				
maven spring mq整合，注意最新版的mq的jar包是集成了spring的，我用的5.11.1的。 运行之前，先要下载mq服务本地运行http://apache.fayea.com//activemq/5.14.3/apache-activemq-5.14.3-bin.zip

			
		

	





	

		

			

				
					
电动汽车数据集：2025年3K+记录-EV Electrical Vehicles Dataset

				
			

			

				

					08-19
				

			

		

		

			
				
电动汽车数据集：2025年3K+记录
真实电动汽车数据：特斯拉、宝马、日产车型，含2025年电池规格和销售数据


关于数据集
电动汽车数据集
这个合成数据集包含许多品牌和年份的电动汽车和插电式车型的记录，捕捉技术规格、性能、定价、制造来源、销售和安全相关属性。每一行代表由vehicle_ID标识的唯一车辆列表。
关键特性
覆盖范围：全球制造商和车型组合，包括纯电动汽车和插电式混合动力汽车。
范围：电池化学成分、容量、续航里程、充电标准和速度、价格、产地、自主水平、排放、安全等级、销售和保修。
时间跨度：模型跨度多年（包括传统和即将推出的）。
数据质量说明：
某些行可能缺少某些字段（空白）。
几个分类字段包含不同的、特定于供应商的值（例如，Charging_Type、Battery_Type）。
各列中的单位混合在一起；注意kWh、km、hr、USD、g/km和额定值。
列
列类型描述示例
Vehicle_ID整数每个车辆记录的唯一标识符。1
制造商分类汽车品牌或OEM。特斯拉
型号类别特定型号名称/变体。型号Y
与记录关联的年份整数模型。2024
电池_类型分类使用的电池化学/技术。磷酸铁锂
Battery_Capacity_kWh浮充电池标称容量，单位为千瓦时。75.0
Range_km整数表示充满电后的行驶里程（公里）。505
充电类型主要充电接口或功能。CCS、NACS、CHAdeMO、DCFC、V2G、V2H、V2L
Charge_Time_hr浮动充电的大致时间（小时），上下文因充电方法而异。7.5
价格_USD浮动参考车辆价格（美元）.85000.00
颜色类别主要外观颜色或饰面。午夜黑
制造国_制造类别车辆制造/组装的国家。美国
Autonomous_Level浮点自动化能力级别（例如0-5），可能包括子级别的小

			
		

	





	

		

			

				
					
基于单片机的温度监测系统设计(51+1602+18B20+BZ+KEY3) 0448

					
最新发布

				
			

			

				

					08-19
				

			

		

		

			
				
包括：源程序工程文件、Proteus仿真工程文件、电路原理图文件、配套技术手册、论文资料等
1、采用51单片机作为主控单元芯片；
2、采用DS18B20传感器检测温度；
3、采用LCD1602显示实时温度及报警上下限；
4、温度超限时，蜂鸣器将进行报警；
5、可通过按键设置报警上下限；

			
		

	





	

		

			

				
					
关于具有确定性视距路径的RIS辅助MIMO信道的遍历容量.zip

				
			

			

				

					08-19
				

			

		

		

			
				
1.版本：matlab2014a/2019b/2024b

2.附赠案例数据可直接运行。

3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。

4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。

			
		

	





	

		

			

				
					
spglib-1.16.1-3.el8.tar.gz

				
			

			

				

					08-19
				

			

		

		

			
				
# 适用操作系统：Centos8
#Step1、解压
tar -zxvf xxx.el8.tar.gz
#Step2、进入解压后的目录，执行安装
sudo rpm -ivh *.rpm

			
		

	





	

		

			

				
					
slang-2.3.2-3.el8.tar.gz

				
			

			

				

					08-19
				

			

		

		

			
				
# 适用操作系统：Centos8
#Step1、解压
tar -zxvf xxx.el8.tar.gz
#Step2、进入解压后的目录，执行安装
sudo rpm -ivh *.rpm

			
		

	





	

		

			

				
					
Spring+ActiveMQ整合教程：实例源码解析与应用

				
			

			

				

					
				

			

		

		

			
				
在深入分析Spring与ActiveMQ整合实例源码之前，我们首先要了解Spring、JMS、ActiveMQ和Tomcat的基础知识，并理解它们各自的作用及其在实际开发中是如何相互协作的。  首先，Spring框架是一个开源的Java平台，它最初...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值