一、 ActiveMQ 简介
1 什么是 ActiveMQ
ActiveMQ 是 Apache 出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个 完全支持 JMS1.1 和 J2EE 1.4 规范的 JMS Provider 实现，尽管 JMS 规范出台已经是很久 的事情了，但是 JMS 在当今的 J2EE 应用中间仍然扮演着特殊的地位。
2 什么是消息
“消息”是在两台计算机间传送的数据单位。消息可以非常简单，例如只包含文本字符串； 也可以更复杂，可能包含嵌入对象。
3 什么是队列
4 什么是消息队列
“消息队列”是在消息的传输过程中保存消息的容器。
5 常用消息服务应用
5.1 ActiveMQ
ActiveMQ 是 Apache 出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完 全支持 JMS1.1 和 J2EE 1.4 规范的 JMS Provider 实现。
5.2 RabbitMQ
RabbitMQ 是一个在 AMQP 基础上完成的，可复用的企业消息系统。他遵循 Mozilla Public License 开源协议。开发语言为 Erlang。
5.3 RocketMQ
由阿里巴巴定义开发的一套消息队列应用服务。
四、 ActiveMQ 安装
1 下载资源
ActiveMQ 官网： ActiveMQ
1.1 版本说明
ActiveMQ5.10.x 以上版本必须使用 JDK1.8 才能正常使用。 ActiveMQ5.9.x 及以下版本使用 JDK1.7 即可正常使用。
2 上传至 Linux 服务器
3 解压安装文件
tar -zxf apache-activemq-5.9.0-bin.tar.gz
4 检查权限
ls -al apache-activemq-5.9.0/bin 如果权限不足,则无法执行,需要修改文件权限: chmod 755 activemq
5 复制应用至本地目录
cp -r apache-activemq-5.9.0 /usr/local/activemq
6 启动 ActiveMQ
/usr/local/activemq/bin/activemq start
7 测试 ActiveMQ
7.1 检查进程
ps aux | grep activemq 见到下述内容即代表启动成功
7.2 管理界面
使用浏览器访问 ActiveMQ 管理应用, 地址如下: http://ip:8161/admin/
用户名: admin 密码: admin
ActiveMQ 使用的是 jetty 提供 HTTP 服务.启动稍慢,建议短暂等待再访问测试. 见到如下界面代表服务启动成功
7.3 修改访问端口
修改 ActiveMQ 配置文件: /usr/local/activemq/conf/jetty.xml
配置文件修改完毕，保存并重新启动 ActiveMQ 服务。 7.4 修改用户名和密码
修改 conf/users.properties 配置文件.内容为: 用户名=密码 保存并重启 ActiveMQ 服务即可.
8 重启 ActiveMQ
/usr/local/activemq/bin/activemq restart
9 关闭 ActiveMQ
/usr/local/activemq/bin/activemq stop
10 配置文件 activemq.xml
配置文件中,配置的是 ActiveMQ 的核心配置信息. 是提供服务时使用的配置. 可以修改 启动的访问端口. 即 java 编程中访问 ActiveMQ 的访问端口. 默认端口为 61616. 使用协议是: tcp 协议. 修改端口后, 保存并重启 ActiveMQ 服务即可.
11 ActiveMQ 目录介绍
从它的目录来说,还是很简单的: * bin 存放的是脚本文件 * conf 存放的是基本配置文件 * data 存放的是日志文件 * docs 存放的是说明文档 * examples 存放的是简单的实例 * lib 存放的是 activemq 所需 jar 包 * webapps 用于存放项目的目录
五、 ActiveMQ 术语
1 Destination
目的地，JMS Provider（消息中间件）负责维护，用于对 Message 进行管理的对象。 MessageProducer 需要指定 Destination 才能发送消息，MessageReceiver 需要指定 Destination 才能接收消息。
2 Producer
消息生成者，负责发送 Message 到目的地。
3 Consumer | Receiver
消息消费者，负责从目的地中消费【处理|监听|订阅】Message。
4 Message
消息，消息封装一次通信的内容。
六、 ActiveMQ 应用
1 ActiveMQ 常用 API 简介
下述 API 都是接口类型,由定义在 javax.jms 包中. 是 JMS 标准接口定义.
1.1 ConnectionFactory
链接工厂, 用于创建链接的工厂类型.
1.2 Connection
链接. 用于建立访问 ActiveMQ 连接的类型, 由链接工厂创建.
1.3 Session
会话, 一次持久有效有状态的访问. 由链接创建.
1.4 Destination & Queue
目的地, 用于描述本次访问 ActiveMQ 的消息访问目的地. 即 ActiveMQ 服务中的具体队 列. 由会话创建. interface Queue extends Destination
1.5 MessageProducer
消息生成者, 在一次有效会话中, 用于发送消息给 ActiveMQ 服务的工具. 由会话创建.
1.6 MessageConsumer
消息消费者【消息订阅者，消息处理者】, 在一次有效会话中, 用于从 ActiveMQ 服务中 获取消息的工具. 由会话创建.
1.7 Message
消息, 通过消息生成者向 ActiveMQ 服务发送消息时使用的数据载体对象或消息消费者 从 ActiveMQ 服务中获取消息时使用的数据载体对象. 是所有消息【文本消息，对象消息等】 具体类型的顶级接口. 可以通过会话创建或通过会话从 ActiveMQ 服务中获取.
2 JMS-HelloWorld
2.1 处理文本消息
2.1.1 创建消息生产者
2.1.1.2 修改 POM 文件添加 ActiveMQ 坐标
<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.sxt</groupId><artifactId>mq-pproducer</artifactId><version>0.0.1-SNAPSHOT</version><dependencies><dependency><groupId>org.apache.activemq</groupId><artifactId>activemq-all</artifactId><version>5.9.0</version></dependency></dependencies>
</project>2.1.1.3 编写消息的生产者
package com.sxt;import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;import org.apache.activemq.ActiveMQConnectionFactory;public class HelloWorldProducer {/*** 生产消息* @param MsgTest*/public void sendHelloWorldActiveMQ(String MsgTest){//定义链接工厂ConnectionFactory connectionFactory = null;//定义链接对象Connection connection = null;//定义会话Session session = null;//定义目的地Destination destination = null;//定义消息的发送者MessageProducer producer = null;//定义消息Message message = null;try {/*** userName:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.properties文件进行修改* password:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.properties文件进行修改* brokerURL:访问ActiveMQ服务的路径地址。路径结构为:协议名://主机地址:端口号*/connectionFactory = new ActiveMQConnectionFactory("admin","admin", "tcp://192.168.44.130:61616");//创建连接对象connection = connectionFactory.createConnection();//启动连接connection.start();/*** transacted:是否使用事务 可选值为：true|false* true:使用事务 当设置次变量值。Session.SESSION_TRANSACTED* false:不适用事务,设置次变量 则acknowledgeMode参数必须设置* acknowledgeMode:* Session.AUTO_ACKNOWLEDGE:自动消息确认机制* Session.CLIENT_ACKNOWLEDGE:客户端确认机制* Session.DUPS_OK_ACKNOWLEDGE:有副本的客户端确认消息机制*/session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);//创建目的地，目的地即队列的名称。消息的消费者需要通过该名称访问对应的队列destination = session.createQueue("Helloworld-destination");//创建消息的生产者producer = session.createProducer(destination);//创建消费者对象message = session.createTextMessage(MsgTest);//发送消息producer.send(message);} catch (JMSException e) {e.printStackTrace();}finally{if(producer != null){try {producer.close();} catch (JMSException e) {e.printStackTrace();}}if(session != null){try {session.close();} catch (JMSException e) {e.printStackTrace();}}if(connection != null ){try {connection.close();} catch (JMSException e) {e.printStackTrace();}}}}}
2.1.2 创建消息消费者
2.1.2.1 创建工程
2.1.2.2 修改 POM 文件添加 ActiveMQ 坐标
<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.sxt</groupId><artifactId>mq-consumer</artifactId><version>0.0.1-SNAPSHOT</version><dependencies><!-- https://mvnrepository.com/artifact/org.apache.activemq/activemq-all --><dependency><groupId>org.apache.activemq</groupId><artifactId>activemq-all</artifactId><version>5.9.0</version></dependency></dependencies></project>2.1.2.3 编写消息的消费者
package com.sxt;import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.TextMessage;import org.apache.activemq.ActiveMQConnectionFactory;public class HelloWorldConsumer {/*** 消费消息*/public void readHelloWorldActiveMQ(){//定义链接工厂ConnectionFactory connectionFactory = null;//定义链接对象Connection connection = null;//定义会话Session session = null;//目的地Destination destination = null;//定义消息的消费者MessageConsumer consumer = null;//定义消息Message message = null;try {/*** userName:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.properties文件进行修改* password:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.properties文件进行修改* brokerURL:访问ActiveMQ服务的路径地址。路径结构为:协议名://主机地址:端口号*/connectionFactory = new ActiveMQConnectionFactory("admin", "admin", "tcp://192.168.44.130:61616");//创建连接对象connection = connectionFactory.createConnection();//启动连接connection.start();/*** transacted:是否使用事务 可选值为：true|false* true:使用事务 当设置次变量值。Session.SESSION_TRANSACTED* false:不适用事务,设置次变量 则acknowledgeMode参数必须设置* acknowledgeMode:* Session.AUTO_ACKNOWLEDGE:自动消息确认机制* Session.CLIENT_ACKNOWLEDGE:客户端确认机制* Session.DUPS_OK_ACKNOWLEDGE:有副本的客户端确认消息机制*/session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);//创建目的地，目的地名称即队列的名称。消息的消费者需要通过此名称访问对应的队列destination = session.createQueue("Helloworld-destination");//创建消息的消费者consumer = session.createConsumer(destination);//接收消息message = consumer.receive();//处理消息String msg = ((TextMessage)message).getText();System.out.println("从ActiveMQ服务中获得的消息"+msg);} catch (JMSException e) {e.printStackTrace();}finally{// 回收消息发送者资源if(consumer != null){try {consumer.close();} catch (JMSException e) {e.printStackTrace();}}if(session != null){try {session.close();} catch (JMSException e) {e.printStackTrace();}} if(connection != null ){try {connection.close();} catch (JMSException e) {e.printStackTrace();}} }}
}
2.1.3 测试
2.1.3.1 Producer
package com.sxt;public class Test {public static void main(String[] args) {System.out.println("消息发送方...");
// HelloWorldProducer hwp = new HelloWorldProducer();
// hwp.sendHelloWorldActiveMQ("HelloWorld!");/* Users user = new Users();user.setUserid(3); user.setUserName("多对的");user.setPassWord("46464");HelloWorldProducer2 producer = new HelloWorldProducer2();producer.sendHelloWorldActiveMQ(user);}*/HelloWorldProducer3 producer = new HelloWorldProducer3();producer.sendHelloWorldActiveMQ("Helloworlddsdfsdfdsf");}
}
2.1.3.2 Consumer
package com.sxt;public class Test {public static void main(String[] args) {System.out.println("消息接收方...");
// HelloWorldConsumer hc = new HelloWorldConsumer();
// hc.readHelloWorldActiveMQ();
// HelloWorldConsumer2 consumer = new HelloWorldConsumer2();
// consumer.readHelloWorldActiveMQ();HelloWorldConsumer3 consumer = new HelloWorldConsumer3();consumer.readHelloWorldActiveMQ();}
}
2.2 处理对象消息
2.2.1 定义消息对象
package com.sxt;import java.io.Serializable;public class Users implements Serializable{private static final long serialVersionUID = -1305446877847351356L;private int userid;private String userName;private String passWord;public int getUserid() {return userid;}public void setUserid(int userid) {this.userid = userid;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public String getPassWord() {return passWord;}public void setPassWord(String passWord) {this.passWord = passWord;}
}
2.2.2 创建生产者
大同小异，需要在上面的基础上修改
2.2.3 定义消息消费者
3 JMS - 实现队列服务监听
队列服务监听使用的观察者设计模式
3.1 创建消息生产者
仅只修改队列名称
3.2 消息消费者
并取消资源关闭
保持开启状态
4 Topic 模型
4.1 Publish/Subscribe 处理模式（Topic）
消息生产者（发布）将消息发布到 topic 中，同时有多个消息消费者（订阅）消费该消 息。 和点对点方式不同，发布到 topic 的消息会被所有订阅者消费。 当生产者发布消息，不管是否有消费者。都不会保存消息 一定要先有消息的消费者，后有消息的生产者。
4.2 创建生产者
原来的生产者为：
4.3 创建消费者
package com.bjsxt;import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;import org.apache.activemq.ActiveMQConnectionFactory;public class HelloWorldConsumerTopic1 implements Runnable{/*** 消费消息*/public void readHelloWorldActiveMQ() {// 定义链接工厂ConnectionFactory connectionFactory = null;// 定义链接对象Connection connection = null;// 定义会话Session session = null;// 目的地Destination destination = null;// 定义消息的发送者MessageConsumer consumer = null;// 定义消息Message message = null;try {/*** userName:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.* properties文件进行修改* password:访问ActiveMQ服务的用户名。用户密码。默认的为admin。用户名可以通过jetty-ream.* properties文件进行修改 brokerURL:访问ActiveMQ服务的路径地址。路径结构为:协议名://主机地址:端口号*/connectionFactory = new ActiveMQConnectionFactory("admin", "admin", "tcp://192.168.70.151:61616");// 创建连接对象connection = connectionFactory.createConnection();// 启动连接connection.start();/*** transacted:是否使用事务 可选值为：true|false true:使用事务* 当设置次变量值。Session.SESSION_TRANSACTED false:不适用事务,设置次变量* 则acknowledgeMode参数必须设置 acknowledgeMode:* Session.AUTO_ACKNOWLEDGE:自动消息确认机制* Session.CLIENT_ACKNOWLEDGE:客户端确认机制* Session.DUPS_OK_ACKNOWLEDGE:有副本的客户端确认消息机制*/session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);// 创建目的地，目的地名称即队列的名称。消息的消费者需要通过此名称访问对应的队列destination = session.createTopic("test-topic");// 创建消息的消费者consumer = session.createConsumer(destination);consumer.setMessageListener(new MessageListener() {//ActiveMQ 回调的方法。通过该方法将消息传递到 consumer@Overridepublic void onMessage(Message message) {//处理消息String msg=null;try {msg = ((TextMessage)message).getText();} catch (JMSException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("从ActiveMQ服务中获取的文本信息 ---topic1 "+msg);}}); } catch (Exception e) {e.printStackTrace();} }@Overridepublic void run() {this.readHelloWorldActiveMQ();}
}Spring-activemq-consumer
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><parent><groupId>com.sxt</groupId><artifactId>parent</artifactId><version>0.0.1-SNAPSHOT</version></parent><groupId>com.sxt</groupId><artifactId>spring-activemq-consumer</artifactId><version>0.0.1-SNAPSHOT</version><dependencies><!-- activemq客户端 --><dependency><groupId>org.apache.activemq</groupId><artifactId>activemq-all</artifactId></dependency><!-- spring框架对JMS标准的支持 --><dependency><groupId>org.springframework</groupId><artifactId>spring-jms</artifactId></dependency><!-- ActiveMQ和spring整合的插件 --><dependency><groupId>org.apache.xbean</groupId><artifactId>xbean-spring</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId></dependency></dependencies>
</project>myMessageListener:
package com.sxt.listener;import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;import com.sxt.pojo.Users;
import com.sxt.service.UserService;/*** 消息服务监听器* @author Administrator**/
@Component(value="myListener")
public class MyMessageListener implements MessageListener{@Autowiredprivate UserService userService;@Overridepublic void onMessage(Message message) {//处理消息ObjectMessage objectMessage = (ObjectMessage) message;Users user = null;try {user = (Users)objectMessage.getObject();} catch (JMSException e) {e.printStackTrace();}this.userService.showUser(user);}}
applicationContext-jms.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:jms="http://www.springframework.org/schema/jms" xmlns:amq="http://activemq.apache.org/schema/core"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/jmshttp://www.springframework.org/schema/jms/spring-jms.xsdhttp://activemq.apache.org/schema/corehttp://activemq.apache.org/schema/core/activemq-core.xsd"><!-- 需要创建一个连接工厂,连接ActiveMQ. ActiveMQConnectionFactory. 需要依赖ActiveMQ提供的amq标签 --><!-- amq:connectionFactory 是bean标签的子标签, 会在spring容器中创建一个bean对象.可以为对象命名. 类似: <bean id="" class="ActiveMQConnectionFactory"></bean>--><amq:connectionFactory brokerURL="tcp://192.168.44.130:61616"userName="admin" password="admin" id="amqConnectionFactory"/><!-- spring管理JMS相关代码的时候,必须依赖jms标签库. spring-jms提供的标签库. --><!-- 定义Spring-JMS中的连接工厂对象CachingConnectionFactory - spring框架提供的连接工厂对象. 不能真正的访问MOM容器.类似一个工厂的代理对象. 需要提供一个真实工厂,实现MOM容器的连接访问.--><bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory"><property name="targetConnectionFactory" ref="amqConnectionFactory"></property><property name="sessionCacheSize" value="3"></property></bean><!-- 注册监听器 --><!-- 开始注册监听. 需要的参数有:acknowledge - 消息确认机制container-type - 容器类型 default|simplesimple:SimpleMessageListenerContainer最简单的消息监听器容器，只能处理固定数量的JMS会话，且不支持事务。default:DefaultMessageListenerContainer是一个用于异步消息监听器容器 ，且支持事务 destination-type - 目的地类型. 使用队列作为目的地.connection-factory - 连接工厂, spring-jms使用的连接工厂,必须是spring自主创建的不能使用三方工具创建的工程. 如: ActiveMQConnectionFactory.--><jms:listener-container acknowledge="auto" container-type="default"destination-type="queue" connection-factory="connectionFactory" ><!-- 在监听器容器中注册某监听器对象.destination - 设置目的地命名ref - 指定监听器对象--><jms:listener destination="test-spring" ref="myListener"/></jms:listener-container></beans>spring-activemq-producer(生产者)
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><parent><groupId>com.sxt</groupId><artifactId>parent</artifactId><version>0.0.1-SNAPSHOT</version></parent><groupId>com.sxt</groupId><artifactId>spring-activemq-producer</artifactId><version>0.0.1-SNAPSHOT</version><packaging>war</packaging><dependencies><!-- ActiveMQ客户端完整jar包依赖 --><dependency><groupId>org.apache.activemq</groupId><artifactId>activemq-all</artifactId></dependency><!-- ActiveMQ和Spring整合配置文件标签处理jar包依赖 --><dependency><groupId>org.apache.xbean</groupId><artifactId>xbean-spring</artifactId></dependency><!-- Spring-JMS插件相关jar包依赖 --><dependency><groupId>org.springframework</groupId><artifactId>spring-jms</artifactId></dependency><dependency><groupId>org.apache.activemq</groupId><artifactId>activemq-pool</artifactId></dependency><dependency><groupId>org.apache.activemq</groupId><artifactId>activemq-jms-pool</artifactId></dependency><!-- 单元测试 --><dependency><groupId>junit</groupId><artifactId>junit</artifactId></dependency><!-- 日志处理 --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></dependency><!-- spring --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId></dependency><!-- JSP相关 --><dependency><groupId>jstl</groupId><artifactId>jstl</artifactId></dependency><dependency><groupId>javax.servlet</groupId><artifactId>servlet-api</artifactId><scope>provided</scope></dependency><dependency><groupId>javax.servlet</groupId><artifactId>jsp-api</artifactId><scope>provided</scope></dependency></dependencies><build><plugins><!-- 配置Tomcat插件 --><plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><configuration><path>/</path><port>8080</port></configuration></plugin></plugins></build>
</project>userServiceImpl:
package com.sxt.service.impl;import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.ObjectMessage;
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;import com.sxt.pojo.Users;
import com.sxt.service.UserService;@Service
public class UserServiceImpl implements UserService{@Autowiredprivate JmsTemplate jmsTemplate;@Overridepublic void addUser(final Users user) {//发送消息this.jmsTemplate.send(new MessageCreator() {@Overridepublic Message createMessage(Session session) throws JMSException {ObjectMessage message = session.createObjectMessage(user);return message;}});}
}applicationContext-jms.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:jms="http://www.springframework.org/schema/jms"xmlns:context="http://www.springframework.org/schema/context"xmlns:amq="http://activemq.apache.org/schema/core"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/jmshttp://www.springframework.org/schema/jms/spring-jms.xsdhttp://activemq.apache.org/schema/corehttp://activemq.apache.org/schema/core/activemq-core.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!-- 需要创建一个连接工厂,连接ActiveMQ. ActiveMQConnectionFactory. 需要依赖ActiveMQ提供的amq标签 --><!-- amq:connectionFactory 是bean标签的子标签, 会在spring容器中创建一个bean对象. 可以为对象命名. 类似: <bean id="" class="ActiveMQConnectionFactory"></bean> --><amq:connectionFactory brokerURL="tcp://192.168.44.130:61616"userName="admin" password="admin" id="amqConnectionFactory" /><!-- 配置池化的ConnectionFactory。 为连接ActiveMQ的connectionFactory提供连接池 --><bean id="pooledConnectionFactoryBean" class="org.apache.activemq.pool.PooledConnectionFactoryBean"><property name="connectionFactory" ref="amqConnectionFactory"></property><property name="maxConnections" value="10"></property></bean><!-- spring管理JMS相关代码的时候,必须依赖jms标签库. spring-jms提供的标签库. --><!-- 定义Spring-JMS中的连接工厂对象 CachingConnectionFactory - spring框架提供的连接工厂对象. 不能真正的访问MOM容器. 类似一个工厂的代理对象. 需要提供一个真实工厂,实现MOM容器的连接访问. --><!-- 配置有缓存的ConnectionFactory，session的缓存大小可定制。 --><bean id="connectionFactory"class="org.springframework.jms.connection.CachingConnectionFactory"><property name="targetConnectionFactory" ref="amqConnectionFactory"></property><property name="sessionCacheSize" value="3"></property></bean><!-- JmsTemplate配置 --><bean id="template" class="org.springframework.jms.core.JmsTemplate"><!-- 给定连接工厂, 必须是spring创建的连接工厂. --><property name="connectionFactory" ref="connectionFactory"></property><!-- 可选 - 默认目的地命名 --><property name="defaultDestinationName" value="test-spring"></property></bean>
</beans>
