JAVA ActiveMQ 详解

我不是女神ヾ 2022-05-23 02:20 200阅读 0赞

一、

1.  JMS是java的消息服务，JMS的客户端之间可以通过JMS服务进行异步的消息传输。
2.  消息模型
    
        ○ Point-to-Point(P2P)
        ○ Publish/Subscribe(Pub/Sub)
    
    即点对点和发布订阅模型
3.  P2P
    
    1.  P2P模式图   
        ![这里写图片描述][20150630220509535]
    2.  涉及到的概念   
        
        
        1.  消息队列（Queue）
        2.  发送者(Sender)
        3.  接收者(Receiver)
        4.  每个消息都被发送到一个特定的队列，接收者从队列中获取消息。队列保留着消息，直到他们被消费或超时。
    3.  P2P的特点
        
        1.  每个消息只有一个消费者（Consumer）(即一旦被消费，消息就不再在消息队列中)
        2.  发送者和接收者之间在时间上没有依赖性，也就是说当发送者发送了消息之后，不管接收者有没有正在运行，它不会影响到消息被发送到队列
        3.  接收者在成功接收消息之后需向队列应答成功
        
        如果你希望发送的每个消息都应该被成功处理的话，那么你需要P2P模式。
4.  Pub/Sub
    
    1.  Pub/Sub模式图   
        ![这里写图片描述][20150630221227522]
    2.  涉及到的概念   
        
        
        1.  主题（Topic）
        2.  发布者（Publisher）
        3.  订阅者（Subscriber）   
            客户端将消息发送到主题。多个发布者将消息发送到Topic,系统将这些消息传递给多个订阅者。
    3.  Pub/Sub的特点
        
        1.  每个消息可以有多个消费者
        2.  发布者和订阅者之间有时间上的依赖性。针对某个主题（Topic）的订阅者，它必须创建一个订阅者之后，才能消费发布者的消息，而且为了消费消息，订阅者必须保持运行的状态。
        3.  为了缓和这样严格的时间相关性，JMS允许订阅者创建一个可持久化的订阅。这样，即使订阅者没有被激活（运行），它也能接收到发布者的消息。
        
        如果你希望发送的消息可以不被做任何处理、或者被一个消息者处理、或者可以被多个消费者处理的话，那么可以采用Pub/Sub模型
5.  消息的消费   
    在JMS中，消息的产生和消息是异步的。对于消费来说，JMS的消息者可以通过两种方式来消费消息。   
    ○ 同步   
    订阅者或接收者调用receive方法来接收消息，receive方法在能够接收到消息之前（或超时之前）将一直阻塞   
    ○ 异步   
    订阅者或接收者可以注册为一个消息监听器。当消息到达之后，系统自动调用监听器的onMessage方法。
6.  JMS编程模型
    
    (1) ConnectionFactory
    
    创建Connection对象的工厂，针对两种不同的jms消息模型，分别有QueueConnectionFactory和TopicConnectionFactory两种。可以通过JNDI来查找ConnectionFactory对象。
    
    (2) Destination
    
    Destination的意思是消息生产者的消息发送目标或者说消息消费者的消息来源。对于消息生产者来说，它的Destination是某个队列（Queue）或某个主题（Topic）;对于消息消费者来说，它的Destination也是某个队列或主题（即消息来源）。
    
    所以，Destination实际上就是两种类型的对象：Queue、Topic可以通过JNDI来查找Destination。
    
    (3) Connection
    
    Connection表示在客户端和JMS系统之间建立的链接（对TCP/IP socket的包装）。Connection可以产生一个或多个Session。跟ConnectionFactory一样，Connection也有两种类型：QueueConnection和TopicConnection。
    
    (4) Session
    
    Session是我们操作消息的接口。可以通过session创建生产者、消费者、消息等。Session提供了事务的功能。当我们需要使用session发送/接收多个消息时，可以将这些发送/接收动作放到一个事务中。同样，也分QueueSession和TopicSession。
    
    (5) 消息的生产者
    
    消息生产者由Session创建，并用于将消息发送到Destination。同样，消息生产者分两种类型：QueueSender和TopicPublisher。可以调用消息生产者的方法（send或publish方法）发送消息。
    
    (6) 消息消费者
    
    消息消费者由Session创建，用于接收被发送到Destination的消息。两种类型：QueueReceiver和TopicSubscriber。可分别通过session的createReceiver(Queue)或createSubscriber(Topic)来创建。当然，也可以session的creatDurableSubscriber方法来创建持久化的订阅者。
    
    (7) MessageListener
    
    消息监听器。如果注册了消息监听器，一旦消息到达，将自动调用监听器的onMessage方法。EJB中的MDB（Message-Driven Bean）就是一种MessageListener。
7.  企业消息系统的好处

我们先来看看下图，应用程序A将Message发送到服务器上，然后应用程序B从服务器中接收A发来的消息，通过这个图我们一起来分析一下JMS的好处：   
![这里写图片描述][20150630221818616]

1.  提供消息灵活性
2.  松散耦合
3.  异步性

二、

### 消息中间件 ###

我们简单的介绍一下消息中间件，对它有一个基本认识就好，消息中间件（MOM：Message Orient middleware）。

消息中间件有很多的用途和优点：   
1. 将数据从一个应用程序传送到另一个应用程序，或者从软件的一个模块传送到另外一个模块；   
2. 负责建立网络通信的通道，进行数据的可靠传送。   
3. 保证数据不重发，不丢失   
4. 能够实现跨平台操作，能够为不同[操作系统][Link 1]上的软件集成技工数据传送服务

### MQ ###

首先简单的介绍一下MQ，MQ英文名MessageQueue，中文名也就是大家用的消息队列，干嘛用的呢，说白了就是一个消息的接受和转发的容器，可用于消息推送。

下面进入我们今天的主题，为大家介绍ActiveMQ：

### ActiveMQ ###

#### 简要概述ActiveMQ ####

Apache ActiveMQ ™ is the most popular and powerful open source messaging and Integration Patterns server.
    Apache ActiveMQ is fast, supports many Cross Language Clients and Protocols, comes with easy to use Enterprise Integration Patterns and many advanced features while fully supporting JMS 1.1 and J2EE 1.4.

ActiveMQ是由Apache出品的，一款最流行的，能力强劲的开源消息总线。ActiveMQ是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现，它非常快速，支持多种语言的客户端和协议，而且可以非常容易的嵌入到企业的应用环境中，并有许多高级功能。

下面我们下载一个版本，玩一玩。

#### 下载ActiveMQ ####

官方网站：[http://activemq.apache.org/][http_activemq.apache.org]   
现在ActiveMQ最新的版本是5.11.1，下载挺简单的，就不再截图了。

#### 运行ActiveMQ服务 ####

1.  下载，解压缩   
    大家现在好之后，将apache-activemq-5.11.1-bin.zip解压缩，我们可以看到它的整体目录结构：   
    ![这里写图片描述][20150730224628161]   
    从它的目录来说，还是很简单的：   
    
    
     *  bin存放的是脚本文件
     *  conf存放的是基本配置文件
     *  data存放的是日志文件
     *  docs存放的是说明文档
     *  examples存放的是简单的实例
     *  lib存放的是activemq所需jar包
     *  webapps用于存放项目的目录
2.  启动ActiveMQ   
    我们了解activemq的基本目录，下面我们运行一下activemq服务，双击bin目录下的activemq.bat脚本文件或运行自己电脑版本下的activemq.bat，就可以看下图的效果。   
    ![这里写图片描述][20150730230036054]

从上图我们可以看到activemq的存放地址，以及浏览器要访问的地址.   
3. [测试][Link 2]

ActiveMQ默认使用的TCP连接端口是61616, 通过查看该端口的信息可以测试ActiveMQ是否成功启动 netstat -an|find “61616”

C:\Documents and Settings\Administrator>netstat -an|find "61616" 
    TCP     0.0.0.0:61616     0.0.0.0:0       LISTENING

4. 监控   
ActiveMQ默认启动时，启动了内置的jetty服务器，提供一个用于监控ActiveMQ的admin应用。   
admin：[http://127.0.0.1:8161/admin/][http_127.0.0.1_8161_admin]

用户名和密码都是admin

![这里写图片描述][20150730230850497]  
5. 至此，服务端启动完毕

停止服务器，只需要按着Ctrl+Shift+C，之后输入y即可。

我们简单说说ActiveMQ特性，网上很多，只是为了保证博文的完整。

#### ActiveMQ特性列表 ####

1.  多种语言和协议编写客户端。语言: Java, C, C++, C\#, Ruby, Perl, Python, PHP。应用协议: OpenWire,Stomp REST,WS Notification,XMPP,AMQP
2.  完全支持JMS1.1和J2EE 1.4规范 (持久化,XA消息,事务)
3.  对Spring的支持,ActiveMQ可以很容易内嵌到使用Spring的系统里面去,而且也支持Spring2.0的特性
4.  通过了常见J2EE服务器(如 Geronimo,JBoss 4, GlassFish,WebLogic)的测试,其中通过JCA 1.5 resource adaptors的配置,可以让ActiveMQ可以自动的部署到任何兼容J2EE 1.4 商业服务器上
5.  支持多种传送协议:in-VM,TCP,SSL,NIO,UDP,JGroups,JXTA
6.  支持通过JDBC和journal提供高速的消息持久化
7.  从设计上保证了高性能的集群,客户端-服务器,点对点
8.  支持Ajax
9.  支持与Axis的整合
10. 可以很容易得调用内嵌JMS provider,进行测试

#### 什么情况下使用ActiveMQ? ####

1.  多个项目之间集成   
    (1) 跨平台   
    (2) 多语言   
    (3) 多项目
2.  降低系统间模块的耦合度，解耦   
    (1) 软件扩展性
3.  系统前后端隔离   
    (1) 前后端隔离，屏蔽高安全区

其实ActiveMQ的应用还有很多，大家可以上网查查，不再一一举例。

三、

### 开发环境 ###

我们使用的是ActiveMQ 5.11.1 Release的Windows版，官网最新版是ActiveMQ 5.12.0 Release，大家可以自行下载，[下载地址][Link 3]。

需要注意的是，开发时候，要将apache-activemq-5.11.1-bin.zip解压缩后里面的activemq-all-5.11.1.jar包加入到classpath下面，这个包包含了所有jms接口api的实现。

### 搭建开发环境 ###

*  建立项目   
    我们只需要建立一个java项目就可以了，导入jar包，项目截图：   
    ![这里写图片描述][20150920171843767]

点对点的消息模型，只需要一个消息生成者和消息消费者，下面我们编写代码。

*  编写生产者

package com.tgb.activemq;
    
    import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.MessageProducer;
    import javax.jms.Session;
    import javax.jms.TextMessage;
    
    import org.apache.activemq.ActiveMQConnection;
    import org.apache.activemq.ActiveMQConnectionFactory;
    /** * 消息的生产者（发送者） * @author liang * */
    public class JMSProducer { 
    
        //默认连接用户名
        private static final String USERNAME = ActiveMQConnection.DEFAULT_USER;
        //默认连接密码
        private static final String PASSWORD = ActiveMQConnection.DEFAULT_PASSWORD;
        //默认连接地址
        private static final String BROKEURL = ActiveMQConnection.DEFAULT_BROKER_URL;
        //发送的消息数量
        private static final int SENDNUM = 10;
    
        public static void main(String[] args) {
            //连接工厂
            ConnectionFactory connectionFactory;
            //连接
            Connection connection = null;
            //会话 接受或者发送消息的线程
            Session session;
            //消息的目的地
            Destination destination;
            //消息生产者
            MessageProducer messageProducer;
            //实例化连接工厂
            connectionFactory = new ActiveMQConnectionFactory(JMSProducer.USERNAME, JMSProducer.PASSWORD, JMSProducer.BROKEURL);
    
            try {
                //通过连接工厂获取连接
                connection = connectionFactory.createConnection();
                //启动连接
                connection.start();
                //创建session
                session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
                //创建一个名称为HelloWorld的消息队列
                destination = session.createQueue("HelloWorld");
                //创建消息生产者
                messageProducer = session.createProducer(destination);
                //发送消息
                sendMessage(session, messageProducer);
    
                session.commit();
    
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                if(connection != null){
                    try {
                        connection.close();
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
        /** * 发送消息 * @param session * @param messageProducer 消息生产者 * @throws Exception */
        public static void sendMessage(Session session,MessageProducer messageProducer) throws Exception{
            for (int i = 0; i < JMSProducer.SENDNUM; i++) {
                //创建一条文本消息 
                TextMessage message = session.createTextMessage("ActiveMQ 发送消息" +i);
                System.out.println("发送消息：Activemq 发送消息" + i);
                //通过消息生产者发出消息 
                messageProducer.send(message);
            }
    
        }
    }
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68
         69
         70
         71
         72
         73
         74
         75
         76
         77
         78
         79
         80
         81
         82
         83
         84
         85
         86
         87
         88
         89
         90
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68
         69
         70
         71
         72
         73
         74
         75
         76
         77
         78
         79
         80
         81
         82
         83
         84
         85
         86
         87
         88
         89
         90

*  编写消费者

package com.tgb.activemq;
    
    import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.MessageConsumer;
    import javax.jms.Session;
    import javax.jms.TextMessage;
    
    import org.apache.activemq.ActiveMQConnection;
    import org.apache.activemq.ActiveMQConnectionFactory;
    /** * 消息的消费者（接受者） * @author liang * */
    public class JMSConsumer { 
    
        private static final String USERNAME = ActiveMQConnection.DEFAULT_USER;//默认连接用户名
        private static final String PASSWORD = ActiveMQConnection.DEFAULT_PASSWORD;//默认连接密码
        private static final String BROKEURL = ActiveMQConnection.DEFAULT_BROKER_URL;//默认连接地址
    
        public static void main(String[] args) {
            ConnectionFactory connectionFactory;//连接工厂
            Connection connection = null;//连接
    
            Session session;//会话 接受或者发送消息的线程
            Destination destination;//消息的目的地
    
            MessageConsumer messageConsumer;//消息的消费者
    
            //实例化连接工厂
            connectionFactory = new ActiveMQConnectionFactory(JMSConsumer.USERNAME, JMSConsumer.PASSWORD, JMSConsumer.BROKEURL);
    
            try {
                //通过连接工厂获取连接
                connection = connectionFactory.createConnection();
                //启动连接
                connection.start();
                //创建session
                session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
                //创建一个连接HelloWorld的消息队列
                destination = session.createQueue("HelloWorld");
                //创建消息消费者
                messageConsumer = session.createConsumer(destination);
    
                while (true) {
                    TextMessage textMessage = (TextMessage) messageConsumer.receive(100000);
                    if(textMessage != null){
                        System.out.println("收到的消息:" + textMessage.getText());
                    }else {
                        break;
                    }
                }
    
            } catch (JMSException e) {
                e.printStackTrace();
            }
    
        }
    }
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64

### 运行 ###

1.  首先，启动ActiveMQ，如何启动ActiveMQ如何启动，请看第二篇博文。在浏览器中输入：[http://localhost:8161/admin/][http_localhost_8161_admin]，然后开始执行：
2.  运行发送者，eclipse控制台输出，如下图：   
    ![这里写图片描述][20150920173405956]   
    此时，我们先看一下ActiveMQ服务器，Queues内容如下：   
    ![这里写图片描述][20150920173620033]  
    我们可以看到创建了一个名称为HelloWorld的消息队列，队列中有10条消息未被消费，我们也可以通过Browse查看是哪些消息，如下图：   
    ![这里写图片描述][20150920174135335]  
    如果这些队列中的消息，被删除，消费者则无法消费。
3.  我们继续运行一下消费者，eclipse控制台打印消息，如下：   
    ![这里写图片描述][20150920174317150]   
    此时，我们先看一下ActiveMQ服务器，Queues内容如下：   
    ![这里写图片描述][20150920174417511]  
    我们可以看到HelloWorld的消息队列发生变化，多一个消息者，队列中的10条消息被消费了，点击Browse查看，已经为空了。   
    点击Active Consumers，我们可以看到这个消费者的详细信息：   
    ![这里写图片描述][20150920175100179]

我们的实例到此就结束了，大家可以自己多点ActiveMQ服务器的内容，进一步熟悉ActiveMQ。

四、

### 环境准备 ###

#### 工具 ####

1.  JDK1.6或1.7
2.  Spring4.1.0
3.  ActiveMQ5.11.1
4.  Tomcat7.x

#### 目录结构 ####

![这里写图片描述][20150926133934271]

#### 所需jar包 ####

![这里写图片描述][20150926133955808]

### 项目的配置 ###

#### 配置ConnectionFactory ####

connectionFactory是Spring用于创建到JMS服务器链接的，Spring提供了多种connectionFactory，我们介绍两个SingleConnectionFactory和CachingConnectionFactory。

SingleConnectionFactory：对于建立JMS服务器链接的请求会一直返回同一个链接，并且会忽略Connection的close方法调用。

CachingConnectionFactory：继承了SingleConnectionFactory，所以它拥有SingleConnectionFactory的所有功能，同时它还新增了缓存功能，它可以缓存Session、MessageProducer和MessageConsumer。我们使用CachingConnectionFactory来作为示例。

<bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
        </bean>
       
        
         1
         2
        
       
        
         1
         2

Spring提供的ConnectionFactory只是Spring用于管理ConnectionFactory的，真正产生到JMS服务器链接的ConnectionFactory还得是由JMS服务厂商提供，并且需要把它注入到Spring提供的ConnectionFactory中。我们这里使用的是ActiveMQ实现的JMS，所以在我们这里真正的可以产生Connection的就应该是由ActiveMQ提供的ConnectionFactory。所以定义一个ConnectionFactory的完整代码应该如下所示：

<amq:connectionFactory id="amqConnectionFactory" brokerURL="tcp://192.168.3.3:61616" userName="admin" password="admin" />
    
        
          
        <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
              
            <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
            
            
            
            <property name="sessionCacheSize" value="100" />
        </bean>
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16

#### 配置生产者 ####

配置好ConnectionFactory之后我们就需要配置生产者。生产者负责产生消息并发送到JMS服务器。但是我们要怎么进行消息发送呢？通常是利用Spring为我们提供的JmsTemplate类来实现的，所以配置生产者其实最核心的就是配置消息发送的JmsTemplate。对于消息发送者而言，它在发送消息的时候要知道自己该往哪里发，为此，我们在定义JmsTemplate的时候需要注入一个Spring提供的ConnectionFactory对象。

在利用JmsTemplate进行消息发送的时候，我们需要知道发送哪种消息类型：一个是点对点的ActiveMQQueue，另一个就是支持订阅/发布模式的ActiveMQTopic。如下所示：

<bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
              
            <constructor-arg ref="connectionFactory" />
            
            <property name="pubSubDomain" value="false" />
        </bean>
    
        
        <bean id="jmsTopicTemplate" class="org.springframework.jms.core.JmsTemplate">
               
            <constructor-arg ref="connectionFactory" />
            
            <property name="pubSubDomain" value="true" />
        </bean>
    
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19

生产者如何指定目的地和发送消息？大家看源码即可，就不再这提供了。

#### 配置消费者 ####

生产者往指定目的地Destination发送消息后，接下来就是消费者对指定目的地的消息进行消费了。那么消费者是如何知道有生产者发送消息到指定目的地Destination了呢？每个消费者对应每个目的地都需要有对应的MessageListenerContainer。对于消息监听容器而言，除了要知道监听哪个目的地之外，还需要知道到哪里去监听，也就是说它还需要知道去监听哪个JMS服务器，通过配置MessageListenerContainer的时候往里面注入一个ConnectionFactory来实现的。所以我们在配置一个MessageListenerContainer的时候有三个属性必须指定：一个是表示从哪里监听的ConnectionFactory；一个是表示监听什么的Destination；一个是接收到消息以后进行消息处理的MessageListener。

<jms:listener-container destination-type="queue" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
            <jms:listener destination="test.queue" ref="queueReceiver1"/>
            <jms:listener destination="test.queue" ref="queueReceiver2"/>
        </jms:listener-container>
    
        
        <jms:listener-container destination-type="topic" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
            <jms:listener destination="test.topic" ref="topicReceiver1"/>
            <jms:listener destination="test.topic" ref="topicReceiver2"/>
        </jms:listener-container>
    
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15

#### ActiveMQ.xml ####

此时，Spring和JMS，ActiveMQ整合的ActiveMQ.xml已经完成，下面展示所有的xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:amq="http://activemq.apache.org/schema/core" xmlns:jms="http://www.springframework.org/schema/jms" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-4.0.xsd http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core-5.8.0.xsd">
    
        
        
        
        <amq:connectionFactory id="amqConnectionFactory" brokerURL="tcp://192.168.3.3:61616" userName="admin" password="admin" />
    
        
          
        <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
              
            <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
            
            
            
            <property name="sessionCacheSize" value="100" />
        </bean>
    
        
    
        
        <bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
              
            <constructor-arg ref="connectionFactory" />
            
            <property name="pubSubDomain" value="false" />
        </bean>
    
        
        <bean id="jmsTopicTemplate" class="org.springframework.jms.core.JmsTemplate">
               
            <constructor-arg ref="connectionFactory" />
            
            <property name="pubSubDomain" value="true" />
        </bean>
    
        
    
    
        
    
        
        <jms:listener-container destination-type="queue" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
            <jms:listener destination="test.queue" ref="queueReceiver1"/>
            <jms:listener destination="test.queue" ref="queueReceiver2"/>
        </jms:listener-container>
    
        
        <jms:listener-container destination-type="topic" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
            <jms:listener destination="test.topic" ref="topicReceiver1"/>
            <jms:listener destination="test.topic" ref="topicReceiver2"/>
        </jms:listener-container>
    
        
    </beans>  
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68

鉴于博文内容较多，我们只是在粘贴web.xml的配置，就不在博文中提供Spring和SpringMVC的XML配置，其他内容，大家查看[源码][Link 4]即可。

#### web.xml ####

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
        <display-name>ActiveMQSpringDemo</display-name>
    
        
        <context-param>
            <param-name>log4jConfigLocation</param-name>
            <param-value>classpath:log4j.properties</param-value>
        </context-param>
        <context-param>
            <param-name>log4jRefreshInterval</param-name>
            <param-value>6000</param-value>
        </context-param>
        
        <listener>
            <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
        </listener>
        
    
        
        <filter>
            <filter-name>characterEncoding</filter-name>
            <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
            <init-param>
                <param-name>encoding</param-name>
                <param-value>UTF-8</param-value>
            </init-param>
            <init-param>
                <param-name>forceEncoding</param-name>
                <param-value>true</param-value>
            </init-param>
        </filter>
        <filter-mapping>
            <filter-name>characterEncoding</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
        
    
        
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:applicationContext.xml,classpath*:ActiveMQ.xml</param-value>
        </context-param>
        <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
        
    
    
        
        <servlet>
            <servlet-name>SpringMVC</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:spring-mvc.xml</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>SpringMVC</servlet-name>
            
            <url-pattern>/</url-pattern>
        </servlet-mapping>
        
    
    </web-app>
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68
         69
         70
         71
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68
         69
         70
         71

### 运行效果 ###

![这里写图片描述][20150926151836004]

![这里写图片描述][20150926151827047]

从上图可以看出队列模型和PUB/SUB模型的区别，Queue只能由一个消费者接收，其他Queue中的成员无法接受到被已消费的信息，而Topic则可以，只要是订阅了Topic的消费者，全部可以获取到生产者发布的信息。

ps：找不到转载的出处了，如果原文博主看到或者哪位同学看到请在评论处留言原文出处我会加上。

[20150630220509535]: /images/20220523/519e1962e9284a6caef4a694848598ef.png
[20150630221227522]: /images/20220523/101e11c4fe9c4ece9882d146122bf5ca.png
[20150630221818616]: /images/20220523/b786a58a4dec478d9505f08190e0cbd7.png
[Link 1]: http://lib.csdn.net/base/operatingsystem
[http_activemq.apache.org]: http://activemq.apache.org/
[20150730224628161]: /images/20220523/215840b1607a44449283ce92a2a28208.png
[20150730230036054]: /images/20220523/5d72cba3dfa841f18834e081ac46d85a.png
[Link 2]: http://lib.csdn.net/base/softwaretest
[http_127.0.0.1_8161_admin]: http://127.0.0.1:8161/admin/
[20150730230850497]: /images/20220523/8da6bff037f54672bf4a07a67139283c.png
[Link 3]: http://activemq.apache.org/download-archives.html
[20150920171843767]: /images/20220523/4fd204c159444a34a4b3fbaf4f186c68.png
[http_localhost_8161_admin]: http://localhost:8161/admin/
[20150920173405956]: /images/20220523/8634319e82c541299ef03883918a415a.png
[20150920173620033]: /images/20220523/a4d51e21c2d04136b1af6286e206ad03.png
[20150920174135335]: /images/20220523/d11f4b50b3bf49d6be1eab3af1cf58e6.png
[20150920174317150]: /images/20220523/4a12cf57d9ad45558fcb1333d117abd1.png
[20150920174417511]: /images/20220523/4b7b12be137c438a8a9827120e662357.png
[20150920175100179]: /images/20220523/9190611a749f40ba9f3518a874921bee.png
[20150926133934271]: /images/20220523/83e002b3ee5c4fbb94a636d20a265cbc.png
[20150926133955808]: /images/20220523/e57e7533ebb94ab1abe8e6af252ca764.png
[Link 4]: http://download.csdn.net/detail/jiuqiyuliang/9141139
[20150926151836004]: /images/20220523/614ec292d57b486ba7a0afa44873bd49.png
[20150926151827047]: /images/20220523/607ee350ddec4c9aa3a724a42eeba5cb.png