在 Spring 系列 的第 4 期也是最后一期中，我将介绍 Spring JMS（Java 消息服务）框架的特性。JMS PG 定义了 Java 应用程序通过面向消息的中间件（MOM）创建和交换消息的标准途径。

就像在这个系列前面的文章中一样，我将使用一个简单的示例来演示 Spring JMS 的特性。您将随我一道开发一个点对点的（P2P）基于消息的系统，使用 Spring JMS 框架通过 JMS 接口与 IBM 的 WebSphere MQ 集成。完成练习后，将可以通过这个系统发送和接收简单的文本消息。

在开始之前，请 下载文章的源代码。请参阅 参考资料 访问 Spring 框架和 IBM WebSphere MQ 5.3。还需要 Apache Ant 来运行示例应用程序。

Spring JMS

Spring 的 JMS 抽象框架简化了 JMS API 的使用，并与 JMS 提供者（比如 IBM 的 WebSphere MQ 5.3）平滑地集成。org.springframework.jms.core 包提供了在 Spring 中使用 JMS 的核心功能。它的模板类处理资源的创建和释放，简化了 JMS 的使用。

像其他大多数 Spring 模板类一样，JMS 模板类提供了执行公共操作的 helper 方法。在需要更复杂应用的情况下，类把处理任务的核心委托给用户实现的回调接口。JMS 类提供了方便的方法，用来发送消息、同步地使用消息以及向用户公开 JMS 会话和消息的制作者。

以下 JMS 包和 org.springframework.jms.core 一起构成了 Spring JMS 的功能：

org.springframework.jms.support

提供转换 JMSException 的功能。转换代码把检测到的 JMSException 层次结构转换成未检测到异常的镜像层次结构。

org.springframework.jms.support.converter

提供 MessageConverter 抽象，以在 Java 对象和 JMS 消息之间进行转换。

org.springframework.jms.support.destination

提供管理 JMS 目标的不同策略，比如针对 JNDI 中保存的目标的服务定位器。

org.springframework.jms.connection

提供适合在独立应用程序中使用的 ConnectionFactory 实现。connection 还包含针对 JMS 的 Spring PlatformTransactionManager 实现。它允许把 JMS 作为事务性资源集成到 Spring 的事务管理机制中。

回页首

IBM WebSphere MQ

就像前面提到的，示例应用程序会用 Spring 的 JMS 框架通过 JMS 接口与 IBM 的 WebSphere MQ 集成。通过在应用程序和 Web 服务之间传递消息，WebSphere MQ 提供了可靠的、有恢复能力的应用程序集成。它使用队列和事务性工具帮助保持消息跨网络的完整性。WebSphere MQ 降低了信息丢失的风险和调和通信 IT 系统的需要。

WebSphere MQ 在它所支持的所有平台上提供了一致的应用程序编程接口，这有助于让集成的程序可移植。除了标准接口外，WebSphere MQ 还完整实现了JMS 接口，包括对发布-订阅消息传递的支持。WebSphere MQ Explorer 工具可以远程地管理和配置整个 MQ 网络。管理和配置工具基于开放源码的 Eclipse 框架，而且是可扩展的。

回页首

Spring JMS 模板

Spring 框架提供了 JmsTemplate 的两个实现。JmsTemplate 类使用 JMS 1.1 API，子类 JmsTemplate102 则使用 JMS 1.0.2 API。我的示例应用程序使用的是 JmsTemplate102。

JMS 模板被用来发送和接收 JMS 消息。Spring 采用回调机制对 JMS 信息传递进行协调。MessageCreator 回调接口用 JmsTemplate 中的调用代码提供的 Session 创建消息。为了支持 JMS API 更复杂的应用，回调 SessionCallback 向用户提供了 JMS 会话，而 callback ProducerCallback 则公开了 Session 和 MessageProducer 组合。

清单 1 显示了示例应用程序使用的 JMS 模板的配置。清单摘自 spring-mqseries-jms.xml 文件（请参阅 下载）。

				
  <!-- JMS Queue Template -->
  <bean id="jmsQueueTemplate" 
          class="org.springframework.jms.core.JmsTemplate102">
    <property name="connectionFactory">
      <ref bean="jmsQueueConnectionFactory"/>
    </property>
    <property name="destinationResolver">
      <ref bean="jmsDestinationResolver"/>
    </property>
    <property name="pubSubDomain">
      <value>false</value>
    </property>
    <property name="receiveTimeout">
      <value>20000</value>
    </property>
  </bean>

jmsQueueTemplate bean 与 JMS 连接工厂和 JMS 目标解析器绑定在一起，用于解析 JMS 客户机通过 JNDI 提供的目标队列名。connectionFactory 属性指定了如何获得到 JMS 提供者的连接。在本例中，清单 2 显示了如何从 JNDI 检索连接工厂。

				
 <!-- JMS Queue Connection Factory -->
  <bean id="internalJmsQueueConnectionFactory"
          class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiTemplate">
      <ref bean="jndiTemplate"/>
    </property>
    <property name="jndiName">
      <value>MQ_JMS_MANAGER</value>
    </property>
  </bean>

可以看到，JndiObjectFactoryBean 被绑定到 internalJmsQueueConnectionFactory。JndiObjectFactoryBean 用 JndiTemplate 属性进行 JNDI 查询。Spring 将用 JndiTemplate 中指定的环境属性和初始上下文在 JNDI 中查询连接工厂。清单 3 显示了 JndiTemplate 配置 bean 的配置。

				
<bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
    <property name="environment">
      <props>
        <prop key="java.naming.factory.initial">
            com.sun.jndi.fscontext.RefFSContextFactory
        </prop>
        <prop key="java.naming.provider.url">
            file:/C:/JNDI-Directory
        </prop>
      </props>
    </property>
  </bean>

以上配置进行 JNDI 查询时用 com.sun.jndi.fscontext.RefFSContextFactory 指定初始上下文工厂，用基于文件的 file:/C:/JNDI-Directory 作为提供者 URL。根据示例应用程序的意图，JNDI 访问会采用基于文件的 FSContext 版本（请参阅 参考资料）的配置把 MQ 队列绑定到 JNDI。

有了定义好的 JMS 模板，下一步就是把它绑定到示例应用程序中，然后就可以用它发送和接收消息了。

回页首

Spring JMS 实现

JMS 模板可以绑定到应用程序中，以发送和接收 JMS 消息。在清单 4 中可以看出我如何把 清单 1 中的 JMS 模板绑定到示例应用程序中。

				
  <bean id="jmsSender" 
          class="springexample.client.JMSSender">
    <property name="jmsTemplate102">
      <ref bean="jmsQueueTemplate"/>
    </property>
    </bean>
    <bean id="jmsReceiver" 
          class="springexample.client.JMSReceiver">
    <property name="jmsTemplate102">
        <ref bean="jmsQueueTemplate"/>
      </property>
    </bean>

可以看到，我把 jmsQueueTemplate 绑定到用来发送和接收消息的 JmsSender 应用程序 bean 和 JmsReceiver bean。清单 5 显示了与 JMSSender 类有关的代码。

				
 public class JMSSender {
   private JmsTemplate102 jmsTemplate102;
   public JmsTemplate102 getJmsTemplate102() {
     return jmsTemplate102;
   }
   public void setJmsTemplate102(JmsTemplate102 jmsTemplate102) {
     this.jmsTemplate102 = jmsTemplate102;
   }
   public void sendMesage(){
     jmsTemplate102.send("JMS_RequestResponseQueue", 
                  new MessageCreator() {
        public Message createMessage(Session session) 
                  throws JMSException {
          return session.createTextMessage("This is a sample message");
        }
      });
   }

JMSSender 类用 jmsTemplate102.send() 方法发送 JMS 消息。send() 方法的第一个参数是 JNDI 队列名，队列名指定了消息应当发送到哪里。（很快就会看到如何把 WebSphere MQ 的队列名绑定到 JNDI。）send() 方法的第二个参数是 MessageCreator 类。JmsTemplate 中的调用代码提供了 Session 类，这个类提供了一个创建 JMS 消息的回调接口。

下一步是用 JMS 的 Session 类创建一个简单的文本消息。在代码执行时，消息会传递给 WebSphere MQ 服务器的队列。清单 6 显示了使用 JmsTemplate 检索 JMS 消息的 JMSReceiver 应用程序 bean 的代码。

				
  public class JMSReceiver {
    private JmsTemplate102 jmsTemplate102;
    public JmsTemplate102 getJmsTemplate102() {
      return jmsTemplate102;
    }
    public void setJmsTemplate102(JmsTemplate102 jmsTemplate102) {
     this.jmsTemplate102 = jmsTemplate102;
    }
    public void processMessage(){
      Message msg = jmsTemplate102.receive("JMS_RequestResponseQueue");
      try{
        TextMessage textMessage = (TextMessage) msg;
        if( msg!=null){
        System.out.println(" Message Received -->" + 
                    textMessage.getText());
        }
      }catch(Exception e){
            e.printStackTrace();
      }
    }
}

JMSReceiver 类用 jmsTemplate102.receive() 方法同步地接收 JMS 消息。receive() 方法指定 JNDI 队列名，并从中检索消息。JMSTemplate 类的 processMessage() 方法由接收 JMS 客户机调用。JSMTemplate bean 的属性 receiveTimeout（列在 JMSTemplate 配置中）指定接收客户机同步地从队列中接收消息时要等候的时间。

现在应用程序的代码已完成！下一步就是配置 WebSphere MQ 队列并把它们绑定到 JNDI 对象。

回页首

队列管理器的设置

在运行应用程序之前，需要设置 WebSphere MQ 的队列管理器和队列，并把它们绑定到 JNDI。如果喜欢的话，可以按照这部分的示例做：只需 下载 设置 WebSphere MQ 队列的批文件和应用程序的源代码和部署描述符即可。把 zip 文件解压到驱动器 C:。

设置队列
运行 C:\SpringSeriesPart4JMS\batch 文件夹中的 mqsetup.bat 文件。这个批文件要求在 path 环境变量中设置好 MQ 安装的 bin 文件夹（例如 C:\mqseries\bin）。运行了批文件之后，应当看到消息 “All valid MQSC commands were processed”。要打开 MQ Explorer 并检查已经创建的队列管理器和队列，请选择 Start -> Programs -> IBM MQSeries -> MQSeriesExplorer。图 1 显示出示例应用程序 QueueManagerMQJMS.QManager 已经创建并正在运行。

请在应用程序屏幕左侧面板上点击 MQJMS.QManager 下的 Queues 文件夹。应当看到已经创建了一个队列 RequestResponseQueue，如图 2 所示。

这就完成了队列的设置。

设置 JMS 和 JNDI 管理

在示例应用程序中，JNDI 的访问利用了可以从 JNDI 主页得到的基于文件的 FSContext 版本（请参阅 参考资料）。FSContext.jar 文件也包含在 WebSphere MQ 的 JMS 支持当中。请添加文件夹 \MQSeriesInstallable\MQSeries\Java\lib 和 \MQSeriesInstallable\MQSeries\Java\bin 到系统的 PATH 环境变量中。而且，请把 \MQSeriesInstallable\MQSeries\Java\lib 文件夹中的所有 jar 文件添加到系统的 CLASSPATH 环境变量中。还可以运行 C:\SpringSeriesPart4JMS\batch 文件夹中的 classpath.cmd 文件，它会设置必要的 path 和 CLASSPATH 变量。要做到这点，只需要修改 classpath.cmd 文件中的 MQ_JAVA_INSTALL_PATH，把它指到 WebSphere MQ JMS 的安装目录。

接下来，修改 \MQSeriesInstallableDirectory\Java\bin 中的 JMSAdmin.config 配置文件，MQSeries JMS 管理程序用它指明应用程序要使用的上下文工厂和 JNDI 实现的地址。请取消以下行的注释：

INITIAL_CONTEXT_FACTORY=com.sun.jndi.fscontext.RefFSContextFactory

并注释掉其余两个 INITIAL_CONTEXT_FACTORY 变量。还要取消以下行的注释：

PROVIDER_URL=file:/C:/JNDI-Directory

并注释掉其余两个 PROVIDER_URL 变量。

可以在 C:\SpringSeriesPart4JMS\batch 文件夹中发现参考的示例配置文件。

为了保存 JNDI 对象，请在驱动器 C: 上创建名为 JNDI-Directory 的目录。切换到 \MQSeriesInstallableDirectory\Java\bin 目录并运行 JMSAdmin 批文件，应当看到 InitCtx 变量。

逐个输入以下内容：

def qcf(MQ_JMS_MANAGER) qmgr(MQJMS.QManager)

按回车

def q(JMS_RequestResponseQueue) qmgr(MQJMS.QManager) 
               queue(RequestResponseQueue)

按回车

现在已经把 WebSphere MQ 队列绑定到 JNDI 对象，作为应用程序客户可以通过 JNDI 查询对象。现在剩下的就是看代码的实际作用了！

回页首

运行示例

要运行示例，请从 spring sourceforge download 下载 Spring 框架和它的所有依赖文件并解压，例如解压到 c:\。会创建文件夹 C:\spring-framework-1.2-rc2（或最新版本）。

要运行 Spring 应用程序，请把本文的源代码解压到任意文件夹，例如 c:\。会创建文件夹 SpringSeriesPart4JMS。就像前面提到过的，还需要安装 Apache Ant 和它的 Spring 依赖 jar 文件。请把 Spring 库 —— 即 spring.jar（在 C:\spring-framework-1.2-rc2\dist 中）和 commons-logging.jar（在 C:\spring-framework-1.2-rc2\lib\jakarta-commons 中）拷贝到 SpringSeriesPart4JMS\lib 文件夹。还要把所有的 jar 库从 \MQSeriesInstallableDirectory\Java\lib 目录拷贝到 SpringSeriesPart4JMS\lib 文件夹。其中包含 MQseries 和 JMS 的相关库。现在就拥有了构建的依赖集。

接下来，打开命令提示符，切换到 SpringProject4 目录，并在命令提示符下输入以下命令：

> ant -f build-jmssender.xml.

这会构建并运行 SendMQSpringJMS 类，它会调用 JMSSender 类，发送消息到 WebSphere MQ RequestResponse 队列。SendMQSpringJMS 还会通过它的 ClassPathXmlApplicationContext 装入 spring 配置文件。一旦 bean 全部装载，就可以通过 Spring 的 ApplicationContext 的 getBean() 方法访问 JMSSender（请参阅清单 7）。

				
ClassPathXmlApplicationContext appContext = 
                   new ClassPathXmlApplicationContext(new String[] {
     "spring-mqseries-jms.xml"
    });
JMSSender jmsSender = (JMSSender)
        appContext.getBean("jmsSender");

消息传递到队列上之后，请运行 JMS 接收方客户机以检索消息。请打开命令提示符，切换到目录 SpringProject4，并输入：

> ant -f build-jmsreceiver.xml

这会构建并运行 ReceiveMQSpringJMS 类，该类会调用 JMSReceiver 类，以从 WebSphere MQ 的 RequestResponse 队列接收文本消息。在控制台上会打印出以下消息：

Message Received --> This is a sample message.

结束语

在 Spring 系列的最后这篇文章中，您学习了 Spring JMS 框架的基础。我首先介绍了示例应用程序的核心组件 —— Spring JMS 框架和 IBM 的 WebSphere MQ 5.3，然后介绍了如何用 Spring JMS 模板向 WebSphere MQ 队列发送消息和从中接收消息。虽然这个示例非常简单，但是可以把这里介绍的步骤应用到更复杂的应用程序。

我希望介绍 Spring 框架核心模块的这一系列对您有所帮助。请参阅 参考资料 学习更多有关 Spring 框架和 Spring JMS 的内容。

回页首

下载

	关于下载方法的信息			Get Adobe® Reader®

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文。
  
  
• “轻量级开发的成功秘诀，第 3 部分: Spring 露出水面”（Bruce Tate，developerWorks，2005 年 6 月）：Bruce Tate 介绍了 Spring 作为轻量级容器的意义。
  
  
• “Writing Java Message Service programs using WebSphere MQ V5.3”（Willy Farrell，developerWorks，2003 年 10 月）：安装和配置 WebSphere MQ 5.3 以进行 JMS 开发和测试的详细指导。
  
  
• “用 AXIS 编写 JMS 应用程序”（Naveen Balani，developerWorks，2003 年 2 月）：开发同步 JMS SOAP 应用程序。
  
  
• Web 架构专区 ：数百篇涉及基于 Web 的解决方案的文章。

• Spring 主页 ：下载 Spring 框架。
  
  
• JMS 主页 ：下载 Java 消息服务。
  
  
• JNDI 主页 ：下载 JNDI 和 FSContext。
  
  
• WebSphere MQ ：得到可信的、可靠的 JMS 提供者。
  
  

• 参与论坛讨论 。
  
  
• developerWorks blogs ：加入 developerWorks 社区。
  

　　 Spring框架则简化了使用JEE组件(包括JMS)的任务。它提供的模板机制隐藏了典型的JMS实现的细节，这样开发人员可以集中精力放在处理消息的实际工作中，而不用担心如何去创建，访问或清除JMS资源。

　　 本文将对Spring JMS API作一个概述，并通过一个运行在JBoss MQ服务器上的web例程来介绍如何使用Spring JMS API来异步处理（发送和接收）消息。我将通过传统JMS实现和Spring JMS实现两者间的比较，来展示使用Spring JMS处理消息是如何的简单和灵活。

异步消息传递和面向服务架构

　　在现实中，大多数web请求都是同步处理的。例如，当用户要登入一个网站，首先输入用户名和密码，然后服务器验证登录合法性。如果验证成功，程序将允许该用户进入网站。这里，登录请求在从客户端接收以后被即时处理了。信用卡验证是另一个同步处理的例子；只有服务器证实输入的信用卡号是有效的，同时客户在帐户上有足够的存款，客户才被允许继续操作。但是让我们思考一下在顺序处理系统上的支付结算步骤。一旦系统证实该用户信用卡的信息是准确的，并且在帐户上有足够的资金，就不必等到所有的支付细节落实、转账完成。支付结算可以异步方式进行，这样客户可以继续进行核查操作。

　　 需要比典型同步请求耗费更长时间的请求，可以使用异步处理。另一个异步处理的例子是，在本地贷款处理程序中，提交至自动承销系统（AUS）的信用请求处理过程。当借方提交贷款申请后，抵押公司会向AUS发送请求，以获取信用历史记录。由于这个请求要求得到全面而又详细的信用报告，包括借方现今和过去的帐户，最近的付款和其他财务资料，服务器需要耗费较长的时间（几小时或着有时甚至是几天）来对这些请求作出响应。客户端程序（应用）要与服务器连接并耗费如此长的时间来等待结果，这是毫无意义的。因此通信应该是异步发生的；也就是，一旦请求被提交，它就被放置在队列中，同时客户端与服务器断开连接。然后AUS服务从指定的队列中选出请求进行处理，并将处理得到的消息放置在另一个消息队列里。最后，客户端程序从这个队列中选出处理结果，紧接着处理这个信用历史数据。

JMS

　　 如果您使用过JMS代码，您会发现它与JDBC或JCA很像。它所包含的样本代码创建或JMS资源对象回溯，使得每一次您需要写一个新类来发送和接收消息时，都具有更好的代码密集性和重复性。以下序列显示了传统JMS实现所包括的步骤：

1. 创建JNDI初始上下文（context）。
2. 从JNDI上下文获取一个队列连接工厂。
3. 从队列连接工厂中获取一个Quene。
4. 创建一个Session对象。
5. 创建一个发送者（sender）或接收者（receiver）对象。
6. 使用步骤5创建的发送者或接收者对象发送或接收消息。
7. 处理完消息后，关闭所有JMS资源。

Spring JMS

　　 Spring框架提供了一个模板机制来隐藏Java APIs的细节。JEE开发人员可以使用JDBCTemplate和JNDITemplate类来分别访问后台数据库和JEE资源（数据源，连接池）。JMS也不例外。Spring提供JMSTemplate类，因此开发人员不用为一个JMS实现去编写样本代码。接下来是在开发JMS应用程序时Spring所具有一些的优势。

1. 提供JMS抽象API，简化了访问目标（队列或主题）和向指定目标发布消息时JMS的使用。
2. JEE开发人员不需要关心JMS不同版本（例如JMS 1.0.2与JMS 1.1）之间的差异。
3. 开发人员不必专门处理JMS异常，因为Spring为所有JMS异常提供了一个未经检查的异常，并在JMS代码中重新抛出。

　　 表1. Spring JMS类

　　在接下来的部分，我将详细解释表1所列的一部分类（例如JmsTemplate，DestinationResolver和MessageConverter）。

JMSTemplate

　　JmsTemplate提供了几种辅助方法，用来执行一些基本操作。要开始使用JmsTemplate前，您需要知道JMS供应商支持哪个JMS规范，JBoss AS 4.0.2和WebLogic 8.1服务器支持JMS 1.0.2规范。WebLogic Server 9.0包括了对JMS 1.1规范的支持。JMS 1.1统一了点对点（PTP）和发布/订阅（Pub/Sub）域的编程接口。这种改变的结果就是，开发人员可以创建一个事务会话，然后在这同一个JMS会话里，可以从一个Queue(PTP)中接收消息，同时发送另一个消息到一个Topic(Pub/Sub)。JMS 1.1向后兼容JMS 1.0，应此根据JMS 1.0编写的代码仍可以适用于JMS 1.1。

　　 JmsTemplate提供多种发送和接收消息的方法。表2列出了这些方法的一部分。

　　 表2. JMS template方法

　　目标可以通过JNDI上下文保存和获取。当配置Spring程序上下文（application context）时，我们可以用JndiObjectFactoryBean类取得对JMS的引用。DestinationResolver接口是用来把目标名称解析成JMS目标，当应用程序存在大量目标时，这是非常有用的。DynamicDestinationResolver(DestinationResolver的默认实现)是用来解析动态目标的。

　　 MessageConverter接口定义了将Java对象转换为JMS消息的约定。通过这个转换器，应用程序代码可以集中于处理事务对象，而不用为对象如何表示为JMS消息这样的内部细节所困饶。SimpleMessageConverter(和SimpleMessageConverter102)是MessageConverter的默认实现。可使用它们分别将String转换为JMS TextMessage，字节数组(byte[])转换为JMS BytesMessage，Map转换为JMS MapMessage，和Serializable对象转换为JMS ObjectMessage。您也可以编写自定义的MessageConverter实例，通过XML绑定框架（例如JAXB， Castor，Commons Digester，XMLBeans或XStream），来实现XML文档到TextMessage对象的转换。

示例程序

　　我将用一个贷款申请处理系统（命名为LoanProc）示例来演示如何在JMS应用程序中使用Spring。作为贷款申请的一部分，LoanProc通过发送贷款详情（贷款ID，借方名字，借方的SSN，贷款期限和贷款数额），从AUS系统获得信用历史详情。为了简便起见，我们基于两个基本参数来表示信用历史详情：信用分数（又名FICO得分）和贷款数额。让我们假设处理信用检查请求是按以下业务规则进行的：

1. 如果贷款数额等于或低于$500,000，借方必须至少有一个"好"的信用（也就是，借方的FICO得分在680到699之间）。
2. 如果贷款数额高于$500,000，借方必须至少有"很好"的信用，意味着借方的信用得分要高于700。

贷款申请使用案例

　　信用请求处理使用案例包括以下几个步骤：

1. 用户在贷款申请页面输入贷款详情并提交贷款申请。
2. 发送请求到一个名为CreditRequestSendQueue的消息队列。然后程序发送贷款详情到AUS系统，获取信用历史详情。
3. AUS系统从队列中挑出贷款详情，并使用贷款参数从它的数据库中获取信用历史信息。
4. 然后AUS将找到的借方的信用历史信息创建一个新的消息，发送到一个新的名为CreditRequestReceiveQueue的消息队列。
5. 最后，LoanProc从接收队列中选出响应消息，处理贷款申请来决定是否批准或否决申请。

　　在这个例程中，两个消息队列都配置在同一个JBoss MQ server上。使用案例用图1的序列图（SequenceDiagram）表示

图1.贷款处理程序的序列图 (单击截图来查看完整视图)

　　 下面的表3显示了在例程中我所使用的不同技术和开源框架，并按应用逻辑层排列。

　　 表3. 在JMS应用程序中使用的框架

使用Hermes设置JMS资源

　　为了异步处理消息，首先我们需要消息队列发送和接收消息。我们可以用Jboss里的配置XML文件创建一个新的消息队列，然后使用JMS控制台浏览队列的详细情况。清单1显示了配置JMS的XML配置代码片断（这个应该加入到jbossmq-destinations-service.xml文件，位于%JBOSS_HOME%\server\all\deploy-hasingleton\jm文件夹下。）

　　 清单1.JBoss MQ Server上JMS队列的配置

<!--  Credit Request Send Queue  -->
<mbean code="org.jboss.mq.server.jmx.Queue"
  name="jboss.mq.destination:service=Queue,name=CreditRequestSendQueue">
  <depends optional-attribute-name="DestinationManager">
 jboss.mq:service=DestinationManager
  </depends>
</mbean>

<!--  Credit Request Receive Queue  -->
<mbean code="org.jboss.mq.server.jmx.Queue"
  name="jboss.mq.destination:service=Queue,name=CreditRequestReceiveQueue">
  <depends optional-attribute-name="DestinationManager">
 jboss.mq:service=DestinationManager
  </depends>
</mbean>

　　现在，让我们看看如何使用一个名为Hermes的JMS工具来浏览消息队列。Hermes是一个Java Swing应用程序，它可以创建、管理和监视JMS提供商（例如JBossMQ，WebSphereMQ，ActiveMQ和Arjuna服务器）里的JMS目标。从它的网站上下载Hermes，解压缩.zip文件到本地目录（例如，c:\dev\tools\hermes）。一旦安装完成，双击文件hermes.bat（位于bin文件夹下）启动程序。

　　 要在Hermes里配置JBossMQ服务器，请参考Hermes网站上的这个演示。它有着出色的step-by-step可视化指示来配置JBoss MQ。当配置一个新的JNDI初始上下文时，请输入下面的信息。

• providerURL = jnp://localhost:1099
• initialContextFactory = org.jnp.interfaces.NamingContextFactory
• urlPkgPrefixes = org.jnp.interfaces:org.jboss.naming
• securityCredentials = admin
• securityPrincipal = admin

　　当您创建新的目标时，请输入queue/CreditRequestSendQueue和queue/CreditRequestReceiveQueue。图2显示了JMS控制台的主窗口，其中有为JMS例程创建的新的消息队列。

图 2. Hermes中所有目标的截图.（单击截图来查看完整视图）

　　 下面的图3显示了在从消息发送者类发送消息到CreditRequestSendQueue后，Hermes JMS控制台及消息队列的截图。您可以看见有5个消息在队列中，控制台显示了消息详情，例如消息ID，消息目标，时间戳和实际的消息内容。

图 3. Hermes中所有队列的截图.（单击截图来查看完整视图）

　　 在例程中使用的队列名称和其他JMS和JNDI参数见表 4。

　　 表4. Spring JMS配置参数

Spring配置

　　既然我们已经有了运行例程所需要的JMS目标，现在该了解用XML Spring配置文件（名为spring-jms.xml）来组配JMS组件的具体细节了。这些组件是根据Inversion of Controller (IOC)设计模式里的设置方式注入原则（setter injection principle），用JMS对象实例类组配的。让我们详细查看这些组件，并为每一个JMS组件演示一段XML配置代码。

　　 JNDI上下文是取得JMS资源的起始位置，因此首先我们要配置JNDI模板。清单2显示了名为jndiTemplate的Spring bean，其中列有JNDI初始上下文所必需的常用参数。

　　 清单2. JNDI上下文模板

<bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
    <property name="environment">
        <props>
            <prop key="java.naming.factory.initial">
                org.jnp.interfaces.NamingContextFactory
            </prop>
            <prop key="java.naming.provider.url">
                localhost
            </prop>
            <prop key="java.naming.factory.url.pkgs">
                org.jnp.interfaces:org.jboss.naming
            </prop>
        </props>
    </property>
</bean>

　　接着，我们配置队列连接工厂。清单3显示了队列连接工厂的配置。

　　 清单3. JMS队列连接工厂配置

<bean id="jmsQueueConnectionFactory"
      class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiTemplate">
        <ref bean="jndiTemplate"/>
    </property>
    <property name="jndiName">
        <value>UIL2ConnectionFactory</value>
    </property>
</bean>

　　我们定义2个JMS目标来发送和接收消息。详情见清单4和5。

　　 清单4. 发送队列配置

<bean id="sendDestination"
    class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiTemplate">
        <ref bean="jndiTemplate"/>
    </property>
    <property name="jndiName">
        <value>queue/CreditRequestSendQueue</value>
    </property>
</bean>

　　清单5. 接收队列配置

<bean id="receiveDestination"
    class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiTemplate">
        <ref bean="jndiTemplate"/>
    </property>
    <property name="jndiName">
        <value>queue/CreditReqeustReceiveQueue</value>
    </property>
</bean>

　　然后我们再来配置JmsTemplate组件。在例程中我们使用JmsTemplate102。同时使用defaultDestination属性来指定JMS目标。

　　 清单6. JMS模板配置

<bean id="jmsTemplate" 
      class="org.springframework.jms.core.JmsTemplate102">
    <property name="connectionFactory">
        <ref bean="jmsQueueConnectionFactory"/>
    </property>
    <property name="defaultDestination">
        <ref bean="destination"/>
    </property>
    <property name="receiveTimeout">
        <value>30000</value>
    </property>
</bean>

　　最后我们配置发送者和接收者组件。清单7和8分别是Sender 和 Receiver对象的配置。

　　 清单7. JMS Sender配置

<bean id="jmsSender" class="springexample.client.JMSSender">
    <property name="jmsTemplate">
        <ref bean="jmsTemplate"/>
    </property>
</bean>

　　清单8. JMS Receiver配置

<bean id="jmsReceiver" class="springexample.client.JMSReceiver">
    <property name="jmsTemplate">
        <ref bean="jmsTemplate"/>
    </property>
</bean>

测试及监视

　　我写了一个测试类，命名为LoanApplicationControllerTest，用来测试LoanProc程序。我们可以使用这个类来设定贷款参数以及调用信用请求服务类。

　　 让我们看一下不使用Spring JMS API而使用传统JMS开发途径的消息发送者实例。清单9显示了MessageSenderJMS类里的sendMessage方法，其中包含了使用JMS API处理消息的所有必需步骤。

　　 清单9. 传统JMS实例

public void sendMessage() {

    queueName = "queue/CreditRequestSendQueue";
    System.out.println("Queue name is " + queueName);

    /*
     * Create JNDI Initial Context
     */
    try {
        Hashtable env = new Hashtable();
        env.put("java.naming.factory.initial",
            "org.jnp.interfaces.NamingContextFactory");
        env.put("java.naming.provider.url","localhost");
        env.put("java.naming.factory.url.pkgs",
            "org.jnp.interfaces:org.jboss.naming");

        jndiContext = new InitialContext(env);
    } catch (NamingException e) {
        System.out.println("Could not create JNDI API " +
            "context: " + e.toString());
    }

    /*
     * Get queue connection factory and queue objects from JNDI context.
     */
    try {
        queueConnectionFactory = (QueueConnectionFactory)
        jndiContext.lookup("UIL2ConnectionFactory");

        queue = (Queue) jndiContext.lookup(queueName);
    } catch (NamingException e) {
        System.out.println("JNDI API lookup failed: " +
            e.toString());
    }

    /*
     * Create connection, session, sender objects.
     * Send the message.
     * Cleanup JMS connection.
     */
    try {
        queueConnection =
            queueConnectionFactory.createQueueConnection();
        queueSession = queueConnection.createQueueSession(false,
                Session.AUTO_ACKNOWLEDGE);
        queueSender = queueSession.createSender(queue);
        message = queueSession.createTextMessage();
        message.setText("This is a sample JMS message.");
        System.out.println("Sending message: " + message.getText());
        queueSender.send(message);

    } catch (JMSException e) {
        System.out.println("Exception occurred: " + e.toString());
    } finally {
        if (queueConnection != null) {
            try {
                queueConnection.close();
            } catch (JMSException e) {}
        }
    }
}

　　现在，我们来看看使用了Spring的消息发送者实例。清单10显示了MessageSenderSpringJMS类中send方法的代码。

　　 清单10. 使用Spring API的JMS实例

public void send() {
    try {
        ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] {
                "spring-jms.xml"});

        System.out.println("Classpath loaded");

        JMSSender jmsSender = (JMSSender)appContext.getBean("jmsSender");

        jmsSender.sendMesage();

        System.out.println("Message sent using Spring JMS.");
    } catch(Exception e) {
        e.printStackTrace();
    }
}

　　如您所见，通过使用配置文件，所有与管理JMS资源有关的步骤都将交由Spring容器处理。我们只需引用一个JMSSender对象，然后调用对象里的sendMessage方法。

结束语

　　在本文中，我们看到Spring框架是如何使用JMS API简化异步消息传递。Spring去掉了所有使用JMS处理消息所必需的样本代码（例如得到一个队列连接工厂，从Java代码里创建队列和会话对象，在运行时使用配置文件对它们进行组配）。我们可以动态的交换JMS资源对象，而不必修改任何Java代码，这要感谢Inversion of Control (IOC) 原则的力量。

　　既然异步消息传递是SOA框架的整体构成部分，Spring很适合纳入到SOA工具集。此外，JMS管理工具（如Hermes）使得创建、管理和监督JMS资源变得容易，特别是对于系统管理员来说。