ActiveMQ, java, Spring, SpringMVC 12月 8,2017

ActiveMQ整合Spring（3）

第一篇是ActiveMQ的helloworld代码。

第二篇使用ActiveMQ整合Spring，非springmvc。（ActiveMQ整合SpringMVC的代码放在下一篇）

第三篇使用ActiveMQ整合SpringMVC。

JDK8+Comcat8+spring4.1.3+ActiveMQ5.15.2

项目文件：这些是ActiveMQ整合SpringMVC的所有文件，java+xml文件一共14个，下载地址在最文章下面（包括依赖的jar包）。

下面把这14个文件的代码全部贴出来。

AMQController.java

package controller; 

import java.text.SimpleDateFormat;
import java.util.*;

import javax.annotation.Resource;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.TextMessage;
import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import service.ConsumerService;
import service.ProducerService;


/** 
* @author 朱宏亮
* @version 创建时间：2017年12月4日 下午5:04:40 
* 类说明 
*/
@Controller
public class AMQController {
    
    //队列名:朱宏亮队列
    @Resource(name="QueueDestination")
    private Destination QueueDestination;
    
    //订阅名:朱宏亮订阅
    @Resource(name="TopicDestination")
    private Destination TopicDestination;
    

    //队列消息生产者
    @Resource(name="producerService")
    private ProducerService producer;
    
    //队列消息消费者
    @Resource(name="consumerService")
    private ConsumerService consumer;
    
    @RequestMapping({"","index"})
    public String index(HttpServletRequest request){
        return "index"; 
    }
    
    @RequestMapping(value="/producer",method=RequestMethod.GET)
    public String producer(Model model){
        System.out.println("------------打开Queue发送页面");
        
        Date now = new Date(); 
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = dateFormat.format( now );    
        
        model.addAttribute("time", time);
        
        return "producer";
    }
    
    @RequestMapping(value="/topicProducer",method=RequestMethod.GET)
    public String producer2(Model model){
        System.out.println("------------打开Topic发送页面");
        
        Date now = new Date(); 
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = dateFormat.format( now ); 
        
        model.addAttribute("time", time);
        
        return "topicProducer";
    }
    
    @RequestMapping(value="/onsend",method=RequestMethod.POST)
    public String producer(@RequestParam("message") String message, Model model) {
        
        System.out.println("------------正在发送 Queue");
        
        producer.sendMessage(QueueDestination, message);
        
        return "index";
    }
    
    @RequestMapping(value="/onTopicSend",method=RequestMethod.POST)
    public String producer2(@RequestParam("message") String message, Model model) {
        
        System.out.println("------------正在发送 Topic");
        
        producer.sendTopicMessage(TopicDestination, message);
        
        return "index";
    }
    
    @RequestMapping(value="/receive",method=RequestMethod.GET)
    public String queue_receive(Model model) throws JMSException {
        System.out.println("------------接收消息");
        
        TextMessage tm = consumer.receive(QueueDestination);
        model.addAttribute("textMessage", tm.getText());
 
        return "receive";
    }
}

ProducerService.java

package service;

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

import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Service;

/** 
* @author 朱宏亮
* @version 创建时间：2017年12月4日 下午4:52:47 
* 类说明 
*/
@Service
public class ProducerService {

    @Resource(name="jmsTemplate")
    private JmsTemplate jmsTemplate;
       
    @Resource(name="jmsTemplate2")
    private JmsTemplate jmsTemplate2;
      /**
       * 向指定队列发送消息
       */
      public void sendMessage(Destination destination, final String msg) {
        System.out.println("------------向队列" + destination.toString() + "发送了消息:" + msg);
        jmsTemplate.send(destination, new MessageCreator() {
          public Message createMessage(Session session) throws JMSException {
            return session.createTextMessage(msg);
          }
        });
        System.out.println("------------向队列" + destination.toString() + "发送消息结束------------" );
      }
     

      
      /**
       * 发送订阅消息
       */
        public void sendTopicMessage(Destination destination, final String msg) {
            System.out.println("------------向Topic" + destination.toString() + "发送了消息:" + msg);
            jmsTemplate2.send(destination, new MessageCreator() {
                public Message createMessage(Session session) throws JMSException {
                  return session.createTextMessage(msg);
                }
            });
            System.out.println("------------向Topic" + destination.toString() + "发送消息结束------------" );
        }
      
      
      
}

ConsumerService.java

package service; 

import javax.annotation.Resource;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.TextMessage;

import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Service;
/** 
* @author 朱宏亮
* @version 创建时间：2017年12月4日 下午4:56:13 
* 类说明 
*/

@Service
public class ConsumerService {

    @Resource(name="jmsTemplate")
    private JmsTemplate jmsTemplate;
     
    /**
     * 接收消息
     */
    public TextMessage receive(Destination destination) {
        TextMessage tm = (TextMessage) jmsTemplate.receive(destination);
        try {
           
            System.out.println("\n从队列" + destination.toString() + "收到了消息：\t" + tm.getText()+"\n");
     
        } catch (JMSException e) {
            //e.printStackTrace();
            System.out.println("\n暂无消息\n");
        }
       
        
        return tm;
        
    }
 
}

AMQMessageListener.java

package service; 

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

/** 
* @author 朱宏亮
* @version 创建时间：2017年12月5日 下午5:15:02 
* 类说明 
*/
public class AMQMessageListener  implements MessageListener {  
    public void onMessage(Message arg) {  
        try {  
            String message = ((TextMessage) arg).getText();  
            System.out.println("MessageListener获得信息:" + message);  
        } catch (JMSException e) {  
            e.printStackTrace();  
        }  
    }  
}

Consumer1.java

package service;

import org.springframework.stereotype.Component;

/** 
* @author 朱宏亮
* @version 创建时间：2017年12月6日 上午11:39:07 
* 类说明 
*/
@Component("Consumer1")
public class Consumer1 {

    public void receiveTopicMessage(String message) {
        System.out.println("订阅者1接收消息:"+message);
    }
 
}

Consumer2.java

package service;

import org.springframework.stereotype.Component;

/** 
* @author 朱宏亮
* @version 创建时间：2017年12月5日 下午5:01:07 
* 类说明 
*/
@Component("Consumer2")
public class Consumer2 {

    public void receiveTopicMessage(String message) {
        System.out.println("订阅者2接收消息:"+message);
    }

}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
 

    <servlet>
        <servlet-name>ActiveMQ</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:conf/*.xml</param-value><!-- ,classpath*:conf/ActiveMQ.xml -->
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>ActiveMQ</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    <listener>
        <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
    </listener>
  
  <!-- 处理编码格式 -->
    <filter>  
        <filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>
</web-app>

spring-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc" 
    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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

	<!-- 自动扫描该包，使SpringMVC认为包下用了 @Controller @Server @Component注解的类是控制器 -->
    <context:component-scan base-package="controller" />
    <context:component-scan base-package="service" />
    <mvc:annotation-driven />

     
	<!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 -->  
	<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />  
          
		  <!-- 定义跳转的文件的前后缀 ，视图模式配置 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/" />
        <property name="suffix" value=".jsp" />
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
    </bean>
        
</beans>

ActiveMQ.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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core.xsd">


    
    <amq:connectionFactory id="amqConnectionFactory" 
        brokerURL="tcp://127.0.0.1:61616" 
        userName="admin" 
        password="admin" />
    
    <!-- 配置JMS连接工厂 -->
    <bean id="connectionFactory"
        class="org.springframework.jms.connection.CachingConnectionFactory">
        <constructor-arg ref="amqConnectionFactory" />
        <property name="sessionCacheSize" value="100" />
    </bean>
    
    <!-- 定义消息队列（Queue） -->
    <bean id="QueueDestination" class="org.apache.activemq.command.ActiveMQQueue">
        <!-- 设置消息队列的名字 -->
        <constructor-arg>
            <value>朱宏亮队列</value>
        </constructor-arg>
    </bean>
    
    <!-- topic目的地配置，其实不管是topic还是queue则他们的底层实现不同但是通过封装api就差不多了，而在spring中更是简单 -->  
    <bean id="TopicDestination" class="org.apache.activemq.command.ActiveMQTopic">  
        <constructor-arg index="0" value="朱宏亮订阅" />  
    </bean>  
    
    <!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
    
        <property name="connectionFactory" ref="connectionFactory" />
        
        <property name="defaultDestination" ref="QueueDestination" />
        
        <!-- 内部的consumer在receive方法中阻塞的时间。默认为1秒。 -->
        <property name="receiveTimeout" value="10000" />
        <!-- true是topic，false是queue，默认是false，此处显示写出false -->
        <property name="pubSubDomain" value="false" /> 
        
    </bean>
    
    <!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
    <bean id="jmsTemplate2" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="defaultDestination" ref="TopicDestination"></property>  
        <!-- 进行持久化 -->  
        <property name="deliveryMode" value="2" />  
        <!-- 开启订阅模式 -->  
        <property name="pubSubDomain" value="true" />  
    </bean>

</beans>

ActiveMQListener.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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core.xsd">
        

 		<!-- 声明连接工厂 -->
		<amq:connectionFactory id="amqConnectionFactory2" 
	        brokerURL="tcp://127.0.0.1:61616" 
	        userName="admin" 
	        password="admin" />
    
		<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
        <bean id="connectionFactory2" class="org.springframework.jms.connection.SingleConnectionFactory">
            <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
            <property name="targetConnectionFactory" ref="amqConnectionFactory2"/>
            <property name="clientId" value="ClientId222"/>

        </bean>

   
        
		<jms:listener-container connection-factory="connectionFactory2" destination-type="durableTopic"  >
            <jms:listener destination="朱宏亮订阅"  subscription="订阅者二号" id="112" ref="Consumer2" method="receiveTopicMessage"/>
          
        </jms:listener-container>
  
 
        
        <jms:listener-container connection-factory="connectionFactory2" destination-type="durableTopic" >
            <jms:listener destination="朱宏亮订阅" subscription="订阅者一号" id="111" ref="Consumer1" method="receiveTopicMessage" />
        </jms:listener-container>
        
        
        
         
	    <bean id="messageListener" class="service.AMQMessageListener" />
	    <!-- Queue消息监听 -->
	    <!-- and this is the message listener container -->
	   <!--  <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
	        <property name="connectionFactory" ref="connectionFactory"/>
	        <property name="destination" ref="QueueDestination"/>
	        <property name="messageListener" ref="messageListener" />
	    </bean> -->
    
    
</beans>

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"  pageEncoding="UTF-8"%>

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>welcome</title>
</head>
<body>

    <h1>Welcome!!!</h1>
    <h2><a href="producer">去发队列消息</a></h2>
    <h2><a href="topicProducer">发送订阅消息</a></h2>
    <h2><a href="receive">从队列中取一个消息</a></h2>


</body>
</html>

producer.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JMS-Producer</title>
</head>
<body>
    <h1>JMS-Producer!!!</h1>
    <form action="onsend" method="post">
        
        MessageText:<textarea name="message">${time }</textarea>
        
        <input type="submit" value="提交" />
    </form>
    <h2><a href="index">返回主页</a></h2>
</body>
</html>

receive.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Receive</title>
</head>
<body>
    <h1>${textMessage }</h1>
    <h2><a href="index">返回主页</a></h2>
</body>
</html>

topicProducer.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JMS-TopicProducer</title>
</head>
<body>
    <h1>JMS-TopicProducer!!!</h1>
    <form action="onTopicSend" method="post">
        
        MessageText:<textarea name="message">${time }</textarea>
        
        <input type="submit" value="提交" />
    </form>
    <h2><a href="index">返回主页</a></h2>
</body>
</html>

以上是所有代码，下面启动项目运行一下。

使用浏览器访问：http://localhost:8080/ActiveMQStudy/

点击第一个按钮，去发队列消息。

然后看eclipse的控制台。

------------打开Queue发送页面

点击提交，页面跳转回了首页，eclipse控制台输出：

------------正在发送 Queue
------------向队列queue://朱宏亮队列发送了消息:2017-12-08 15:29:56
------------向队列queue://朱宏亮队列发送消息结束------------

在网页上点击第三个按钮，从队列中取一个消息。

看Eclipse控制台输出：

------------接收消息

从队列queue://朱宏亮队列收到了消息： 2017-12-08 15:29:56

回到主页，点击第二个按钮，发送订阅消息。

看Eclipse控制台输出：

------------打开Topic发送页面

点击提交按钮之后会返回主页，查看Eclipse控制台消息：

------------正在发送 Topic
------------向Topictopic://朱宏亮订阅发送了消息:2017-12-08 15:36:02
------------向Topictopic://朱宏亮订阅发送消息结束------------
订阅者2接收消息:2017-12-08 15:36:02
订阅者1接收消息:2017-12-08 15:36:02

这就是一个基本的ActiveMQ整合SpringMVC的功能介绍，我使用ActiveMQ.xml配置了Queue消息队列的发送和接收，在ActiveMQListener.xml文件中配置了两个Topic消息的监听。所以在上面最后一步点击发送Topic消息之后，在Eclipse的控制台自动打印了被发送的消息。

接下来，我们将Queue消息也改为自动监听打印的。

打开ActiveMQListen.xml文件，将最下面被我注释掉的代码取消注释，然后重启项目。

            <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
	        <property name="connectionFactory" ref="connectionFactory"/>
	        <property name="destination" ref="QueueDestination"/>
	        <property name="messageListener" ref="messageListener" />
	    </bean>

重启项目之后，打开主页，点击第一个按钮去发队列消息，在新打开的页面中点击提交，这时查看Eclipse的控制台输出信息：

------------打开Queue发送页面
------------正在发送 Queue
------------向队列queue://朱宏亮队列发送了消息:2017-12-08 15:45:15
MessageListener获得信息:2017-12-08 15:45:15
------------向队列queue://朱宏亮队列发送消息结束------------

程序运行的非常完美，就是这么简单。

所有源代码下载地址：https://gitee.com/zhuhongliang/ActiveMQStudy

作者朱宏亮

ActiveMQ, java, Spring 12月 7,2017

ActiveMQ整合Spring（2）

第一篇是ActiveMQ的helloworld代码。

第二篇使用ActiveMQ整合Spring，非springmvc。（ActiveMQ整合SpringMVC的代码放在下一篇）

第三篇使用ActiveMQ整合SpringMVC。

JDK8+spring4.1.3+ActiveMQ5.15.2

文件：一共14个文件，其中8个java文件，6个xml配置文件。源代码下载地址在最下面↓↓↓

3.ActiveMQ+Spring，点对点信息发布与接收（Queue）

先看下发布者的代码和xml文件：
ProducerQueue.java

package spring; 
import javax.jms.JMSException;  
import javax.jms.Message;  
import javax.jms.Session;  
import javax.jms.TextMessage;  
  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
import org.springframework.jms.core.JmsTemplate;  
import org.springframework.jms.core.MessageCreator; 
/** 
* @author 朱宏亮
* @version 创建时间：2017年12月5日 下午4:59:03 
* 类说明 
* 生产
*/
public class ProducerQueue {
 // 负责消息的发送和接收可以理解为MessageProducer 和MessageConsummer的组合。  
  
    public static void main(String[] args) {  
        System.out.println("发送消息 开始!");  
        ApplicationContext ctx = new ClassPathXmlApplicationContext( "spring/ProducerQueue.xml");  
        JmsTemplate jt = null;  
        // 获取JmsTemplate对象  
        jt = (JmsTemplate) ctx.getBean("jmsTemplate");  
        // 调用方法，发送消息  

        jt.send(new MessageCreator() {  
            // 消息的产生，返回消息发送消息  
            public Message createMessage(Session s) throws JMSException {  
                TextMessage msg = s.createTextMessage("Spring 发送消息 ----> 你好 ActiveMQ");  
                return msg;  
            }  
        });  
        
        System.out.println("发送消息 结束!");  
        System.exit(0);//因与ActiveMQ的连接没结束，手动结束程序
    }  
}

ProducerQueue.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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core.xsd">


    
    <amq:connectionFactory id="amqConnectionFactory" 
        brokerURL="tcp://127.0.0.1:61616" 
        userName="admin" 
        password="admin" />
    
    <!-- 配置JMS连接工厂 -->
    <bean id="connectionFactory"
        class="org.springframework.jms.connection.CachingConnectionFactory">
        <constructor-arg ref="amqConnectionFactory" />
        <property name="sessionCacheSize" value="100" />
 
    </bean>
    
    <!-- 定义消息队列（Queue） -->
    <bean id="QueueDestination" class="org.apache.activemq.command.ActiveMQQueue">
        <!-- 设置消息队列的名字 -->
        <constructor-arg>
            <value>queue朱宏亮队列</value>
        </constructor-arg>
    </bean>
    
    <!-- topic目的地配置，其实不管是topic还是queue则他们的底层实现不同但是通过封装api就差不多了，而在spring中更是简单 -->  
    <!-- <bean id="TopicDestination" class="org.apache.activemq.command.ActiveMQTopic">  
        <constructor-arg index="0" value="朱宏亮订阅" />  
    </bean>   -->
    
    <!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
    
        <property name="connectionFactory" ref="connectionFactory" />
        
        <property name="defaultDestination" ref="QueueDestination" />
        
        <!-- 内部的consumer在receive方法中阻塞的时间。默认为1秒。 -->
        <property name="receiveTimeout" value="10000" />
        <!-- true是topic，false是queue，默认是false，此处显示写出false -->
        <property name="pubSubDomain" value="false" /> 
        
    </bean>
    
    <!-- 在不试用自动监听的时候 下面所有的代码全部注释 -->
        
	<bean id="messageListener" class="spring.ConsumerListener1" />
	
	<!-- and this is the message listener container -->
	<!-- <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
	    <property name="connectionFactory" ref="connectionFactory"/>
	    <property name="destination" ref="QueueDestination"/>
	    <property name="messageListener" ref="messageListener" />
	</bean> -->
<!-- 	
	<bean id="messageListener2" class="spring.ConsumerListener2" />
    <jms:listener-container connection-factory="connectionFactory" destination-type="queue"  >
        <jms:listener destination="queue朱宏亮队列"  subscription="订阅者一号" id="bb" ref="messageListener2" method="receiveMessage"/>    
    </jms:listener-container>  -->
    
</beans>

下面看一下订阅者的代码和xml文件：
ConsumerQueue.java

package spring;

import javax.jms.Destination;
import javax.jms.TextMessage;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;

/** 
* @author 朱宏亮
* @version 创建时间：2017年12月7日 上午10:30:31 
* 类说明 
*/
public class ConsumerQueue {
    public static void main(String[] args) {  
        
        ApplicationContext ctx = new ClassPathXmlApplicationContext( "spring/ConsumerQueue.xml");  

        // 获取JmsTemplate对象  
        JmsTemplate jt = (JmsTemplate) ctx.getBean("jmsTemplate2");  
        
        Destination destination =  (Destination) ctx.getBean("QueueDestination2");  

        
        while(true){
            TextMessage tm = (TextMessage) jt.receive(destination);
            try {
                
                System.out.println("从队列" + destination.toString() + "收到了消息：\t" + tm.getText());
         
            } catch (Exception e) {
                //e.printStackTrace();
                System.out.println("暂无消息");
                break;
            }
        }
        
        System.out.println("end!");  
        System.exit(0);//因与ActiveMQ的连接没结束，手动结束程序
  
    }  
}

ConsumerQueue.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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core.xsd">
        
             
        <amq:connectionFactory id="amqConnectionFactory2" 
            brokerURL="tcp://127.0.0.1:61616" 
            userName="admin" 
            password="admin" />
            
        <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
        <bean id="connectionFactory2" class="org.springframework.jms.connection.SingleConnectionFactory">
            <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
            <property name="targetConnectionFactory" ref="amqConnectionFactory2"/>
            <property name="clientId" value="c1"/>
            
        </bean>
        
	    <!-- 定义消息队列（Queue） -->
	    <bean id="QueueDestination2" class="org.apache.activemq.command.ActiveMQQueue">
	        <!-- 设置消息队列的名字 -->
	        <constructor-arg>
	            <value>queue朱宏亮队列</value>
	        </constructor-arg>
	    </bean>
	    
	    <!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
	    <bean id="jmsTemplate2" class="org.springframework.jms.core.JmsTemplate">
	    
	        <property name="connectionFactory" ref="connectionFactory2" />
	        
	        <property name="defaultDestination" ref="QueueDestination2" />
	        
	        <!-- 内部的consumer在receive方法中阻塞的时间。默认为1秒。 -->
	        <property name="receiveTimeout" value="10000" />
	        <!-- true是topic，false是queue，默认是false，此处显示写出false -->
	        <property name="pubSubDomain" value="false" /> 
	        
        </bean>

</beans>

运行，ProducerQueue.java

可以在eclipse的控制台看到

发送消息 开始!
发送消息 结束!

web控制台里可以看到有一条消息已经到底服务器，还没有被消费，消费者数量为0.

然后再运行 ConsumerQueue.java

在eclipse控制台看到：

从队列queue://queue朱宏亮队列收到了消息： Spring 发送消息 ----> 你好 ActiveMQ
暂无消息
end!

再看看web控制台，刚刚发送到服务器的数据已经被消费了。

是不是很简单。

下面再看看让服务自动监听消息，当有消息队列信息发送到服务器的时候，消费者自动获取信息。
ConsumerListener1.java

package spring;

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

/** 
* @author 朱宏亮
* @version 创建时间：2017年12月7日 下午1:44:21 
* 类说明 
*/
public class ConsumerListener1 implements MessageListener {  
    
    public void onMessage(Message arg0) {  
        // TODO Auto-generated method stub  
        try {  
            String message = ((TextMessage) arg0).getText();  
            System.out.println("Listener1 消费方接收消息:" + message);  
        } catch (JMSException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
    }  

}

然后取消ProducerQueue.xml文件下面的注释

        <bean id="messageListener" class="spring.ConsumerListener1" />
	
	<!-- and this is the message listener container -->
	<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
	    <property name="connectionFactory" ref="connectionFactory"/>
	    <property name="destination" ref="QueueDestination"/>
	    <property name="messageListener" ref="messageListener" />
	</bean>

接着直接运行ProducerQueue.java文件，可以在eclipse控制台看到：

发送消息 开始!
Listener1 消费方接收消息:Spring 发送消息 ----> 你好 ActiveMQ
发送消息 结束!

除了上面这种写法之外，listener还有另外一种，还是打开ProducerQueue.xml文件，将刚刚上面的代码注释之后，取消下面这段代码的注释：

    <bean id="messageListener2" class="spring.ConsumerListener2" />
    <jms:listener-container connection-factory="connectionFactory" destination-type="queue"  >
        <jms:listener destination="queue朱宏亮队列"  subscription="订阅者一号" id="bb" ref="messageListener2" method="receiveMessage"/>    
    </jms:listener-container>

ConsumerListener2.java

package spring; 
/** 
* @author 朱宏亮
* @version 创建时间：2017年12月7日 下午1:49:41 
* 类说明 
*/
public class ConsumerListener2 {
    
    public void receiveMessage(String message) {
        System.out.println("Listener2 消费方接收消息:"+message);
    }
    
}

接着直接运行ProducerQueue.java文件，可以在eclipse控制台看到：

 发送消息 开始!
Listener2 消费方接收消息:Spring 发送消息 ----> 你好 ActiveMQ
发送消息 结束!

Queue消息队列只允许有一个消费者存在，所以在不使用的时候将他注释，或者删了代码。根据自己的业务需求来指定代码。

4.ActiveMQ+Spring，一对多发布/订阅（Topic）

在这里我使用了一个发布者和两个订阅者
还是先看一看发布者的java代码和xml代码
ProducerTopic.java

package spring;

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

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

/** 
* @author 朱宏亮
* @version 创建时间：2017年12月7日 下午2:10:02 
* 类说明 
*/
public class ProducerTopic {

    
    public static void main(String[] args) {  
        System.out.println("发送消息 开始!");  
        ApplicationContext ctx = new ClassPathXmlApplicationContext( "spring/ProducerTopic.xml");  
        JmsTemplate jt = null;  
        // 获取JmsTemplate对象  
        jt = (JmsTemplate) ctx.getBean("jmsTemplate3");  
        // 调用方法，发送消息  

        jt.send(new MessageCreator() {  
            // 消息的产生，返回消息发送消息  
            public Message createMessage(Session s) throws JMSException {  
                TextMessage msg = s.createTextMessage("Spring 发送Topic消息 ----> 你好 ActiveMQ");  
                return msg;  
            }  
        });  
        
        System.out.println("发送消息 结束!");  
        System.exit(0);//因与ActiveMQ的连接没结束，手动结束程序
    }  
}

ProducerTopic.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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core.xsd">


    
    <amq:connectionFactory id="amqConnectionFactory3" 
        brokerURL="tcp://127.0.0.1:61616" 
        userName="admin" 
        password="admin" />
    
    <!-- 配置JMS连接工厂 -->
    <bean id="connectionFactory3"
        class="org.springframework.jms.connection.CachingConnectionFactory">
        <constructor-arg ref="amqConnectionFactory3" />
        <property name="sessionCacheSize" value="100" />
      
    </bean>
    

    <!-- topic目的地配置，其实不管是topic还是queue则他们的底层实现不同但是通过封装api就差不多了，而在spring中更是简单 -->  
    <bean id="TopicDestination" class="org.apache.activemq.command.ActiveMQTopic">  
        <constructor-arg index="0" value="topic朱宏亮订阅" />  
    </bean>
    
        
    <!-- 配置JMS模板（Topic），Spring提供的JMS工具类，它发送、接收消息。 -->
    <bean id="jmsTemplate3" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory3" />
        <property name="defaultDestination" ref="TopicDestination"></property>  
        <!-- 进行持久化 -->  
        <property name="deliveryMode" value="2" />  
        <!-- 开启订阅模式 -->  
        <property name="pubSubDomain" value="true" />  
    </bean>
   
</beans>

ConsumerTopic1.java

package spring;

import javax.jms.Destination;
import javax.jms.TextMessage;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;

/** 
* @author 朱宏亮
* @version 创建时间：2017年12月7日 下午2:15:20 
* 类说明 
*/
public class ConsumerTopic1 {
    public static void main(String[] args) {  
        ApplicationContext ctx = new ClassPathXmlApplicationContext( "spring/ConsumerTopic1.xml");  

        // 获取JmsTemplate对象  
        JmsTemplate jt = (JmsTemplate) ctx.getBean("jmsTemplate4");  
        
        Destination destination =  (Destination) ctx.getBean("TopicDestination4");  
        
        
        while(true){
            TextMessage tm = (TextMessage) jt.receive(destination);
            try {
                
                System.out.println("订阅者1：：" + destination.toString() + "收到了消息：\t" + tm.getText());
         
            } catch (Exception e) {
                //e.printStackTrace();
                System.out.println("暂无消息");
               
            }
        }
    }
}

ConsumerTopic1.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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core.xsd">
        
             
        <amq:connectionFactory id="amqConnectionFactory4" 
            brokerURL="tcp://127.0.0.1:61616" 
            userName="admin" 
            password="admin" />
            
        <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
        <bean id="connectionFactory4" class="org.springframework.jms.connection.SingleConnectionFactory">
            <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
            <property name="targetConnectionFactory" ref="amqConnectionFactory4"/>
            <property name="clientId" value="clientId21"/>
          
        </bean>
        
	    <!-- topic目的地配置，其实不管是topic还是queue则他们的底层实现不同但是通过封装api就差不多了，而在spring中更是简单 -->  
	    <bean id="TopicDestination4" class="org.apache.activemq.command.ActiveMQTopic">  
	        <constructor-arg index="0" value="topic朱宏亮订阅" />  
	    </bean>

        <!-- 配置JMS模板（Topic）1，Spring提供的JMS工具类，它发送、接收消息。 -->
	    <bean id="jmsTemplate4" class="org.springframework.jms.core.JmsTemplate">
	        <property name="connectionFactory" ref="connectionFactory4" />
	        <property name="defaultDestination" ref="TopicDestination4"></property>  
	        <!-- 进行持久化 -->  
	        <property name="deliveryMode" value="2" />  
	        <!-- 开启订阅模式 -->  
	        <property name="pubSubDomain" value="true" />    
	    </bean>
	    
    
</beans>

ConsumerTopic2.java

package spring;

import javax.jms.Destination;
import javax.jms.TextMessage;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;

/** 
* @author 朱宏亮
* @version 创建时间：2017年12月7日 下午2:15:20 
* 类说明 
*/
public class ConsumerTopic2 {
    public static void main(String[] args) {  
        ApplicationContext ctx = new ClassPathXmlApplicationContext( "spring/ConsumerTopic2.xml");  

        // 获取JmsTemplate对象  
        JmsTemplate jt = (JmsTemplate) ctx.getBean("jmsTemplate5");  
        
        Destination destination =  (Destination) ctx.getBean("TopicDestination5");  

        while(true){
            TextMessage tm = (TextMessage) jt.receive(destination);
            try {
                
                System.out.println("订阅者2：：" + destination.toString() + "收到了消息：\t" + tm.getText());
         
            } catch (Exception e) {
                //e.printStackTrace();
                System.out.println("暂无消息");
               
            }
        }
    }
}

ConsumerTopic2.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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core.xsd">
        
             
        <amq:connectionFactory id="amqConnectionFactory5" 
            brokerURL="tcp://127.0.0.1:61616" 
            userName="admin" 
            password="admin" />
            
        <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
        <bean id="connectionFactory5" class="org.springframework.jms.connection.SingleConnectionFactory">
            <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
            <property name="targetConnectionFactory" ref="amqConnectionFactory5"/>
            <property name="clientId" value="clientId22"/>
      
        </bean>
        
        <!-- topic目的地配置，其实不管是topic还是queue则他们的底层实现不同但是通过封装api就差不多了，而在spring中更是简单 -->  
        <bean id="TopicDestination5" class="org.apache.activemq.command.ActiveMQTopic">  
            <constructor-arg index="0" value="topic朱宏亮订阅" />  
        </bean>

        
        <!-- 配置JMS模板（Topic）2，Spring提供的JMS工具类，它发送、接收消息。 -->
        <bean id="jmsTemplate5" class="org.springframework.jms.core.JmsTemplate">
            <property name="connectionFactory" ref="connectionFactory5" />
            <property name="defaultDestination" ref="TopicDestination5"></property>  
            <!-- 进行持久化 -->  
            <property name="deliveryMode" value="2" />  
            <!-- 开启订阅模式 -->  
            <property name="pubSubDomain" value="true" />    
        </bean>
        

</beans>

上面六个文件，一个发布者java和xml，两个订阅者java和xml。

我们先运行两个订阅者的java文件：ConsumerTopic1.java 、 ConsumerTopic2.java

这两个程序执行之后会一直保持运行，直到有消息发布才会获取到消息并输出在eclipse的控制台

然后我们执行ProducerTopic.java文件,然后再eclipse控制台可以看到：

发送消息 开始!
发送消息 结束!

订阅者1：：topic://topic朱宏亮订阅收到了消息： Spring 发送Topic消息 ----> 你好 ActiveMQ

订阅者2：：topic://topic朱宏亮订阅收到了消息： Spring 发送Topic消息 ----> 你好 ActiveMQ

发布一条消息之后，同时被两个订阅者接收到消息，非常完美。

ActiveMQ web控制台的界面：

能看到有两个消费者，一条消息，被读取了两次。点击右边的按钮(Active Subscribers):

在上图中能看到两个订阅者客户端的Subscription Name为空，如果这个值为空的话是不能实现消息持久化的。在下面的代码里我会在xml文件中配置Subscription Name，实现消息持久化。

Topic模式我们也可以做Listener，看代码
ConsumerListener3.java

package spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/** 
* @author 朱宏亮
* @version 创建时间：2017年12月7日 下午3:53:45 
* 类说明 
*/
public class ConsumerListener3 {

    public static void main(String[] args) {  
        ApplicationContext ctx = new ClassPathXmlApplicationContext( "spring/ConsumerListener3.xml");  
        while(true){
            
        }
    }
        

    
    public void receiveMessage1(String message) {
        System.out.println("Listener1 订阅者接收消息:"+message);
    }
    
    
    public void receiveMessage2(String message) {
        System.out.println("Listener2 订阅者接收消息:"+message);
    }
    
}

ConsumerListener3.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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:jms="http://www.springframework.org/schema/jms"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans.xsd   
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core.xsd">


    
    <amq:connectionFactory id="amqConnectionFactory6" 
        brokerURL="tcp://127.0.0.1:61616" 
        userName="admin" 
        password="admin" />
    
    <!-- 配置JMS连接工厂 -->
    <bean id="connectionFactory6"
        class="org.springframework.jms.connection.CachingConnectionFactory">
        <constructor-arg ref="amqConnectionFactory6" />
        <property name="sessionCacheSize" value="100" />
        <property name="clientId" value="clientId23"/>
    </bean>
    

    
    <!-- 在不试用自动监听的时候 下面所有的代码全部注释 -->
    
    <bean id="messageListener1" class="spring.ConsumerListener3" />
    <!-- and this is the message listener container -->
    <jms:listener-container connection-factory="connectionFactory6" destination-type="durableTopic"  >
        <jms:listener destination="topic朱宏亮订阅"  subscription="订阅者一号" id="b1" ref="messageListener1" method="receiveMessage1"/>    
    </jms:listener-container> 
 
    <jms:listener-container connection-factory="connectionFactory6" destination-type="durableTopic"  >
        <jms:listener destination="topic朱宏亮订阅"  subscription="订阅者二号" id="b2" ref="messageListener1" method="receiveMessage2"/>    
    </jms:listener-container> 

        
        
</beans>

关闭刚刚已经执行的几个程序，

首先运行ConsumerListener3.java，程序启动后会保持监听，直到有消息发布会自动打印在eclipse控制台里，

接下来运行ProducerTopic.java文件，然后可以在eclipse控制台看到：

发送消息 开始!
发送消息 结束!

Listener1 订阅者接收消息:Spring 发送Topic消息 ----> 你好 ActiveMQ
Listener2 订阅者接收消息:Spring 发送Topic消息 ----> 你好 ActiveMQ

程序执行的非常完美。

在上图中能看到，我的两个订阅者使用的是同一个Client，但是我为每个订阅者配置了不同的Subscription Name。这样就可以实现消息持久化，即使在客户端没有开启的情况下，也不用担心漏掉消息，在下一次客户端启动的时候，就可以接收到离线时的信息。

源代码下载地址：https://gitee.com/zhuhongliang/ActiveMQStudy

作者朱宏亮

java, MySql, SpringMVC 12月 6,2016

简单SpringMVC DEMO实例，只有四个文件【附下载地址】

简单SpringMVC DEMO实例，只有四个文件（不包括springmvc需要的jar包）

oschina的下载地址：https://git.oschina.net/zhuhongliang/SimpleSpringMVC.git

先看一下目录结构，

%e5%9b%be%e7%89%871

一共四个文件实现简单的SpringMVC，下面看代码

第一个文件：web.xml配置文件

%e5%9b%be%e7%89%872

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" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
	<display-name>一个简单的springMVC实例</display-name>
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
	<servlet>
		<servlet-name>SpringMVC</servlet-name>
		<servlet-class>
			org.springframework.web.servlet.DispatcherServlet
		</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>	
	<servlet-mapping>
		<servlet-name>SpringMVC</servlet-name>
		<url-pattern>*.ZHL</url-pattern>
	</servlet-mapping>
</web-app>

这个是web.xml文件，注意画圈的地方，名字要写一样的，

<url-pattern>*.ZHL</url-pattern>

这个配置文件是实际访问网站时的后缀比如：

http://localhost:8080/SimpleSpringMVCTest/index.ZHL

这个链接最后的后缀。

第二个文件：springmvc配置文件

%e5%9b%be%e7%89%873

SpringMVC-servlet.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"
   xsi:schemaLocation="
   http://www.springframework.org/schema/beans     
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

	<context:component-scan base-package="com.zhl" />
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/jsp/" />
		<property name="suffix" value=".jsp" />
	</bean>
</beans>

这个是Springmvc的xml文件，这个文件名字开头xxxxx要和在web.xml里写的servlet-name一样，结尾一定要是servlet.xml结尾的。

第三个文件：jsp视图文件

%e5%9b%be%e7%89%874

天王盖地虎.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>宝塔镇河妖</h1>
</body>
</html>

Jsp文件，没什么好说的

第四个文件：springmvc控制文件

%e6%8e%a7%e5%88%b6%e6%96%87%e4%bb%b6

ZHLController.java

package com.zhl;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ZHLController {
    @RequestMapping("/鬼吹灯")
    public String index(){
        return "天王盖地虎";
    }
}

最后是控制文件，这个文件不要以Controlle.javar命名，不然你一定会后悔的。

图中标注的1，不要忘记写了，后面没有“;”符号

图中标注的2，是浏览器的访问路径，比如：

http://localhost:8080/SimpleSpringMVCTest/鬼吹灯.ZHL

当浏览器访问这个url的时候，通俗的讲法就是，这段程序会运行。

图中标注的3，是返回的视图文件，看我那个箭头，写上文件名就可以了。

那么视图文件的路径和后缀怎么修改？就在xxxxx-servlet.xml文件里修改，下图：

web

是不是很简单，就四个文件。

运行结果：

%e7%bb%93%e6%9e%9c

oschina的下载地址：https://git.oschina.net/zhuhongliang/SimpleSpringMVC.git

作者朱宏亮

Tag Springmvc