第一部分：Spring 框架简介
Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。
在这篇由三部分组成的 Spring 系列 的第 1 部分中，我将介绍 Spring 框架。我先从框架底层模型的角度描述该框架的功能，然后将讨论两个最有趣的模块：Spring 面向方面编程（AOP）和控制反转 （IOC） 容器。接着将使用几个示例演示 IOC 容器在典型应用程序用例场景中的应用情况。这些示例还将成为本系列后面部分进行的展开式讨论的基础，在本文的后面部分，将介绍 Spring 框架通过 Spring AOP 实现 AOP 构造的方式。
请参阅 下载，下载 Spring 框架和 Apache Ant，运行本系列的示例应用程序需要它们。
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。
图 1. Spring 框架的 7 个模块
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
- 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是
BeanFactory，它是工厂模式的实现。BeanFactory使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。 - Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
- Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
- Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
- Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
- Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
- Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。
Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。
控制反转模式（也称作依赖性介入）的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器 （在 Spring 框架中是 IOC 容器） 负责将这些联系在一起。
在典型的 IOC 场景中，容器创建了所有对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。下表列出了 IOC 的一个实现模式。
| 类型 1 | 服务需要实现专门的接口，通过接口，由对象提供这些服务，可以从对象查询依赖性（例如，需要的附加服务） |
| 类型 2 | 通过 JavaBean 的属性（例如 setter 方法）分配依赖性 |
| 类型 3 | 依赖性以构造函数的形式提供，不以 JavaBean 属性的形式公开 |
Spring 框架的 IOC 容器采用类型 2 和类型3 实现。
面向方面的编程，即 AOP，是一种编程技术，它允许程序员对横切关注点或横切典型的职责分界线的行为（例如日志和事务管理）进行模块化。AOP 的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中。
AOP 和 IOC 是补充性的技术，它们都运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象开发方式中，可能要将日志记录语句放在所有方法和 Java 类中才能实现日志功能。在 AOP 方式中，可以反过来将日志服务模块化，并以声明的方式将它们应用到需要日志的组件上。当然，优势就是 Java 类不需要知道日志服务的存在，也不需要考虑相关的代码。所以，用 Spring AOP 编写的应用程序代码是松散耦合的。
AOP 的功能完全集成到了 Spring 事务管理、日志和其他各种特性的上下文中。
Spring 设计的核心是 org.springframework.beans 包，它的设计目标是与 JavaBean 组件一起使用。这个包通常不是由用户直接使用，而是由服务器将其用作其他多数功能的底层中介。下一个最高级抽象是 BeanFactory 接口，它是工厂设计模式的实现，允许通过名称创建和检索对象。BeanFactory 也可以管理对象之间的关系。
BeanFactory 支持两个对象模型。
- 单态 模型提供了具有特定名称的对象的共享实例，可以在查询时对其进行检索。Singleton 是默认的也是最常用的对象模型。对于无状态服务对象很理想。
- 原型 模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时，原型模型最适合。
bean 工厂的概念是 Spring 作为 IOC 容器的基础。IOC 将处理事情的责任从应用程序代码转移到框架。正如我将在下一个示例中演示的那样，Spring 框架使用 JavaBean 属性和配置数据来指出必须设置的依赖关系。
因为 org.springframework.beans.factory.BeanFactory 是一个简单接口，所以可以针对各种底层存储方法实现。最常用的BeanFactory 定义是 XmlBeanFactory，它根据 XML 文件中的定义装入 bean，如清单 1 所示。
清单 1. XmlBeanFactory
BeanFactory factory = new XMLBeanFactory(new FileInputSteam("mybean.xml")); |
在 XML 文件中定义的 Bean 是被消极加载的，这意味在需要 bean 之前，bean 本身不会被初始化。要从 BeanFactory 检索 bean，只需调用 getBean() 方法，传入将要检索的 bean 的名称即可，如清单 2 所示。
清单 2. getBean()
MyBean mybean = (MyBean) factory.getBean("mybean"); |
每个 bean 的定义都可以是 POJO （用类名和 JavaBean 初始化属性定义） 或 FactoryBean。FactoryBean 接口为使用 Spring 框架构建的应用程序添加了一个间接的级别。
理解控制反转最简单的方式就是看它的实际应用。在对由三部分组成的 Spring 系列 的第 1 部分进行总结时，我使用了一个示例，演示了如何通过 Spring IOC 容器注入应用程序的依赖关系（而不是将它们构建进来）。
我用开启在线信用帐户的用例作为起点。对于该实现，开启信用帐户要求用户与以下服务进行交互：
- 信用级别评定服务，查询用户的信用历史信息。
- 远程信息链接服务，插入客户信息，将客户信息与信用卡和银行信息连接起来，以进行自动借记（如果需要的话）。
- 电子邮件服务，向用户发送有关信用卡状态的电子邮件。
对于这个示例，我假设服务已经存在，理想的情况是用松散耦合的方式把它们集成在一起。以下清单显示了三个服务的应用程序接口。
清单 3. CreditRatingInterface
public interface CreditRatingInterface { public boolean getUserCreditHistoryInformation(ICustomer iCustomer); } |
清单 3 所示的信用级别评定接口提供了信用历史信息。它需要一个包含客户信息的 Customer 对象。该接口的实现是由 CreditRating类提供的。
清单 4. CreditLinkingInterface
public interface CreditLinkingInterface { public String getUrl(); public void setUrl(String url); public void linkCreditBankAccount() throws Exception ; } |
信用链接接口将信用历史信息与银行信息（如果需要的话）连接在一起，并插入用户的信用卡信息。信用链接接口是一个远程服务，它的查询是通过 getUrl() 方法进行的。URL 由 Spring 框架的 bean 配置机制设置，我稍后会讨论它。该接口的实现是由CreditLinking 类提供的。
清单 5. EmailInterface
public interface EmailInterface { public void sendEmail(ICustomer iCustomer); public String getFromEmail(); public void setFromEmail(String fromEmail) ; public String getPassword(); public void setPassword(String password) ; public String getSmtpHost() ; public void setSmtpHost(String smtpHost); public String getUserId() ; public void setUserId(String userId); } |
EmailInterface 负责向客户发送关于客户信用卡状态的电子邮件。邮件配置参数（例如 SMPT 主机、用户名、口令）由前面提到的 bean 配置机制设置。Email 类提供了该接口的实现。
这些接口就位之后，接下来要考虑的就是如何用松散耦合方式将它们集成在一起。在 清单 6 中可以看到信用卡帐户用例的实现。
注意，所有的 setter 方法都是由 Spring 的配置 bean 实现的。所有的依赖关系 （也就是三个接口）都可以由 Spring 框架用这些 bean 注入。createCreditCardAccount() 方法会用服务去执行其余实现。在 清单 7 中可以看到 Spring 的配置文件。我用箭头突出了这些定义。
要运行示例应用程序，首先必须 下载 Spring 框架 及其所有依赖文件。接下来，将框架释放到（比如说）磁盘 c:\，这会创建C:\spring-framework-1.2-rc2 （适用于当前发行版本） 这样的文件夹。在继续后面的操作之前，还必须下载和释放 Apache Ant。
接下来，将源代码释放到文件夹，例如 c:\ 盘，然后创建 SpringProject。将 Spring 库（即 C:\spring-framework-1.2-rc2\dist 下的spring.jar 和 C:\spring-framework-1.2-rc2\lib\jakarta-commons 下的 commons-logging.jar）复制到 SpringProject\lib 文件夹中。完成这些工作之后，就有了必需的构建依赖关系集。
打开命令提示符，将当前目录切换到 SpringProject，在命令提示符中输入以下命令：build。
这会构建并运行 CreateCreditAccountClient 类，类的运行将创建 Customer 类对象并填充它，还会调用 CreateCreditCardAccount类创建并链接信用卡帐户。CreateCreditAccountClient 还会通过 ClassPathXmlApplicationContext 装入 Spring 配置文件。装入 bean 之后，就可以通过 getBean() 方法访问它们了，如清单 8 所示。
ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] { "springexample-creditaccount.xml" }); CreateCreditCardAccountInterface creditCardAccount = (CreateCreditCardAccountInterface) appContext.getBean("createCreditCard"); |
在这篇由三部分组成的 Spring 系列 的第一篇文章中，我介绍了 Spring 框架的基础。我从讨论组成 Spring 分层架构的 7 个模块开始，然后深入介绍了其中两个模块：Spring AOP 和 IOC 容器。
由于学习的最佳方法是实践，所以我用一个工作示例介绍了 IOC 模式 （像 Spring 的 IOC 容器实现的那样）如何用松散耦合的方式将分散的系统集成在一起。在这个示例中可以看到，将依赖关系或服务注入工作中的信用卡帐户应用程序，要比从头开始构建它们容易得多。
请继续关注这一系列的下一篇文章，我将在这里学习的知识基础上，介绍 Spring AOP 模块如何在企业应用程序中提供持久支持，并让您开始了解 Spring MVC 模块和相关插件。
第 2 部分: 当 Hibernate 遇上 Spring
在这个系列的 前一期中，我介绍了 Spring 框架的 7 个模块，包括 Spring AOP 和控制反转（IOC）容器。然后我用一个简单的示例演示了 IOC 模式（由 Spring IOC 容器实现）如何用松散耦合的方式集成分散的系统。
现在，我从我上次结束的地方开始，采用与上次类似的示例，演示 Spring AOP 和 Spring Hibernate 持久性支持的声明性事务处理，所以我首先从对这两项技术的深入研究开始。
下载这篇文章的源代码。请参阅 参考资料 访问 Spring 框架和 Apache Ant，运行这篇文章的示例应用程序需要它们。
软件系统通常由多个组件构成，每个组件负责一个特定的功能领域。但是，这些组件也经常承担它们的核心功能之外的额外责任。系统服务（例如日志、事务管理和安全性）经常发现自己跑到了别的组件的领域里，而这些组件的核心职责是其他事情。结果就是所谓的“代码纠缠”，或者更简单点儿说“一团糟”。面向方面编程是一种试图解决这个问题的编程技术，它把关注点的隔离提升为核心的编程概念。
使用 AOP 时，仍然是在一个地方定义系统的公共功能，但是可以声明性地定义 如何 和 在哪里 应用这个功能。如果对横切关注点（例如日志和事务管理）进行了模块化，那么不用修改每个单独的类，就可以向代码中添加新特性。这类模块化的关注点称作 方面。
以一个企业应用程序为例。这类应用程序通常要求类似于安全性和事务支持的服务。显然，可以把这些服务的支持直接编写到要求服务的每个类当中，但是更希望能够不必为大量事务性上下文编写同样的事务处理代码。如果使用 Spring AOP 进行事务处理，那么可以声明性地安排适当的方法调用，而不必逐个安排。
Spring AOP 提供了几个方面，可以为 JavaBean 声明事务。例如，TransactionProxyFactoryBean 是个方便的代理类，能够拦截对现有类的方法调用，并把事务上下文应用到事务 bean。在下面的示例中会看到这个类的实际应用。
Spring 框架提供了对 Hibernate、JDO 和 iBATIS SQL Maps 的集成支持。Spring 对 Hibernate 的支持是第一级的，整合了许多 IOC 的方便特性，解决了许多典型的 Hibernate 集成问题。框架对 Hibernate 的支持符合 Spring 通用的事务和数据访问对象（DAO）异常层次结构。
Spring 为使用选择的 OR 映射层来创建数据访问应用程序提供了支持。因为所有东西都设计成一组可重用 JavaBean，所以不管选择什么技术，都能以库的格式访问大多数 Spring 的 OR 映射支持。 ApplicationContext 或 BeanFactory 内部的 OR 映射的好处是简化了配置和部署。
Hibernate 是 Java 平台上一个功能全面的、开源的 OR 映射框架。Hibernate 支持开发符合常规 Java 理念的持久性类 —— 包括关联、继承、多态、复合以及 Java 集合框架。Hibernate 查询语言（HQL）被设计成 SQL 的一个微型面向对象扩展，它是对象和关系世界之间的桥梁。Hibernate 也支持用原始 SQL 或基于 Java 的标准和示例查询表达查询。Hibernate 使用 XML（*.hbm.xml） 文件把 Java 类映射到表，把 JavaBean 属性映射到数据库表。
通过 JDBC 技术，支持所有的 SQL 数据库管理系统。Hibernate 与所有流行的 J2EE 应用程序服务器和 Web 容器都很好地集成。
一个银行应用程序示例可以让您自己看到 Spring AOP 和 Hibernate 一起工作有多么好。银行帐户用例允许用户 （Customer） 在一个事务中打开一个或多个银行帐户。用户可以申请多个银行帐户，可以选择是支票帐户类型或者是储蓄帐户类型。
应用程序数据库（Cloudscape™）容纳所有客户和帐户信息。在这个例子中，假设在 Customer 和 Account 类之间存在 1:N 的关联。在实际生活场景中，关联可能需要按 m:n 建模，才能支持联合帐户。
由于用户必须可以在一个事务中申请多个帐户，所以首先要为数据库交互实现一个 DOA 模式。然后要设置 Spring AOP 的TransactionProxyFactoryBean，让它拦截方法调用并声明性地把事务上下文应用到 DOA。
在 Spring 框架中，像 JDBC DataSource 或 Hibernate SessionFactory 这样的资源，在应用程序上下文中可以用 bean 实现。需要访问资源的应用程序对象只需通过 bean 引用得到这类预先定义好的实例的引用即可（这方面的更多内容在 下一节中）。在清单 1 中，可以看到示例银行应用程序的一段摘录：XML 应用程序上下文定义显示了如何设置 JDBC DataSource，并在上面放一个 HibernateSessionFactory。
清单 1. JDBC DataSource 和 HibernateSessionFactory 连接
<!-- DataSource Property -->
<bean id="exampleDataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName">
<value>org.apache.derby.jdbc.EmbeddedDriver</value>
</property>
<property name="url">
<value>jdbc:derby:springexample;create=true</value>
</property>
</bean>
<!-- Database Property -->
<bean id="exampleHibernateProperties"
class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="properties">
<props>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop
key="hibernate.dialect">net.sf.hibernate.dialect.DerbyDialect</prop>
<prop
key="hibernate.query.substitutions">true 'T', false 'F'</prop>
<prop key="hibernate.show_sql">false</prop>
<prop key="hibernate.c3p0.minPoolSize">5</prop>
<prop key="hibernate.c3p0.maxPoolSize">20</prop>
<prop key="hibernate.c3p0.timeout">600</prop>
<prop key="hibernate.c3p0.max_statement">50</prop>
<prop
key="hibernate.c3p0.testConnectionOnCheckout">false</prop>
</props>
</property>
</bean>
<!-- Hibernate SessionFactory -->
<bean id="exampleSessionFactory"
class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
<property name="dataSource">
<ref local="exampleDataSource"/>
</property>
<property name="hibernateProperties">
<ref bean="exampleHibernateProperties" />
</property>
<!-- OR mapping files. -->
<property name="mappingResources">
<list>
<value>Customer.hbm.xml</value>
<value>Account.hbm.xml</value>
</list>
</property>
</bean>
|
清单 1 显示了如何为示例应用程序数据库（是 Cloudscape）配置数据源 bean （exampleDataSource）。exampleDatasource 被连接到 Spring Hibernate 的 SessionFactory。请注意 *.hbm.xml 指定了示例应用程序的 OR 映射文件。
数据源和会话工厂设置好之后，下一步就是在 DAO 中连接，在 CustomerDAOImpl 示例中，要使用 SessionFactory。接下来，插入 Spring 的 TransactionProxyFactoryBean，它会拦截对应用程序的 CustomerDAOImpl 对象的方法调用，并声明性地在它上面应用事务。
在 清单 2 的这个示例中，CustomerDAOImpl 类的 addCustomer 方法是作为事务的一部分执行的，有一个事务属性PROPAGATION_REQUIRED。这个属性等价于 EJB 容器的 TX_REQUIRED。如果想让这个方法一直在事务中运行，可以使用PROPAGATION_REQUIRED。如果事务已经在运行，那么 bean 方法会加入事务，否则 Spring 的轻量级事务管理器会启动一个事务。如果想在调用组件服务时总是启动新事务，可以使用 PROPAGATION_REQUIRES_NEW 属性。
应用程序的连接完成之后，现在来进一步查看源代码。
如果以前没这么做过，那么请 下载这篇文章的源代码。把源 zip 文件释放到计算机中的任何位置上，例如 c:\。会创建一个叫作SpringProjectPart2 的文件夹。src\spring 文件夹包含示例应用程序的 Hibernate 映射文件和 Spring 配置文件。src\springexample\hibernate 文件包含应用程序的源代码。
在这里会发现两个类，即 Customer 和 Account，它们用 Hibernate 映射文件映射到两个表。Customer 类代表客户信息，Account 代表客户的帐户信息。正如前面提到的，我把这两个类按照 1: N 关系进行建模，即一个 Customer 可以拥有多个 Account。清单 3 显示了Customer 对象的 Hibernate 映射文件。
清单 3. Customer 对象的 Hibernate 映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
<class
name="springexample.hibernate.Customer"
table="TBL_CUSTOMER"
dynamic-update="false"
dynamic-insert="false">
<id
name="id"
column="CUSTOMER_ID"
type="java.lang.Long"
unsaved-value="-1"
>
<generator class="native">
</generator>
</id>
<set name ="accounts"
inverse = "true"
cascade="all-delete-orphan">
<key column ="CUSTOMER_ID"/>
<one-to-many class="springexample.hibernate.Account"/>
</set>
<property
name="email"
type="string"
update="false"
insert="true"
column="CUSTOMER_EMAIL"
length="82"
not-null="true"
/>
<property
name="password"
type="string"
update="false"
insert="true"
column="CUSTOMER_PASSWORD"
length="10"
not-null="true"
/>
<property
name="userId"
type="string"
update="false"
insert="true"
column="CUSTOMER_USERID"
length="12"
not-null="true"
unique="true"
/>
<property
name="firstName"
type="string"
update="false"
insert="true"
column="CUSTOMER_FIRSTNAME"
length="25"
not-null="true"
/>
<property
name="lastName"
type="string"
update="false"
insert="true"
column="CUSTOMER_LASTTNAME"
length="25"
not-null="true"
/>
</class>
</hibernate-mapping>
|
set name="accounts" 和一对多类标签指定了 Customer 和 Account 之间的关系。我还在 Account.hbm.xml 文件中定义了 Account 对象的映射。
CustomerDAOImpl.java 代表应用程序的 DAO，它在应用程序数据库中插入客户和帐户信息。CustomerDAOImpl 扩展了 Spring 的HibernateDaoSupport，它用 Spring HibernateTemplate 简化了会话管理。这样，可以通过 getHibernateTemplate() 方法保存或检索数据。下面显示的 getCustomerAccountInfo() 对 Customer 进行 查找，通过 getHibernateTemplate().find 方法用 HQL 得到客户的帐户信息，如清单 4 所示。
清单 4. DAO 实现
public class CustomerDAOImpl extends HibernateDaoSupport
implements CustomerDAO{
public void addCustomer(Customer customer) {
getHibernateTemplate().save(customer);
// TODO Auto-generated method stub
}
public Customer getCustomerAccountInfo(Customer customer) {
Customer cust = null;
List list = getHibernateTemplate().find("from Customer customer " +
"where customer.userId = ?" ,
customer.getUserId(),Hibernate.STRING);
if(list.size() > 0){
cust = (Customer) list.get(0);
}
return cust;
}
|
所有这些都应当很容易掌握。现在来看代码的实际应用!
要运行示例应用程序，必须首先 下载 Spring 框架 和它的全部依赖文件。接下来，释放框架到某一位置（比如 c:\ ），这会创建文件夹 C:\spring-framework-1.2-rc2（针对当前发行版）。在继续之前还必须下载和释放 Apache Ant 和 Cloudscape。下载 Cloudscape 之后，把它释放到 c:\ ，这会创建文件夹 C:\Cloudscape_10.0。
接下来，释放源代码到 c:\ ，这会创建 SpringProject2 文件夹。接下来修改 build.xml 文件的入口，用实际安装 Spring 的位置代替C:\spring-framework-1.2-rc2，用实际安装 Cloudscape 的位置代替 C:\Program Files\IBM\Cloudscape_10.0。
打开命令行提示符，进入 SpringProject 目录，在命令行提示符下输入以下命令：build.
这会构建并运行 CreateBankCustomerClient 类，它会创建 Customer 类对象，用数据填充它，创建 Account 对象，填充它，并把它添加到 Customer 对象。
然后 CreateBankCustomerClient 会调用 CustomerDAOImpl.addCustomer 类，添加客户和帐户信息。一旦插入完成，CreateBankCustomerClient 会调用 CustomerDAOImpl.getCustomerAccountInfo 方法，根据 userid 得到客户和帐户信息。如果CreateBankCustomerClient 执行成功，会在控制台上看到打印出 userid。也可以查询 Cloudscape 数据库检索客户和帐户信息。
在三部分的 Spring 系列 的第 2 部分中，我介绍了如何集成 Spring Hibernate 和 Spring AOP。结果是一个强健的持久性框架，支持声明性的实现事务。
在这个系列的下一篇，也是最后一篇文章中，我将介绍 Spring 的 MVC 模块，介绍如何用它来简化基于 Web 的应用程序的创建。
第 3 部分: 进入 Spring MVC
在 Spring 系列 的第 3 部分中，我介绍 Spring MVC 框架。就像在以前的文章中一样，我用银行示例介绍如何建模和构建简单的应用程序。示例应用程序包含了已经学过的一些技术（例如依赖注入），但是主要演示 Spring MVC 的特性。
在开始之前，请 下载这篇文章的源代码。请参阅 参考资料 访问 Spring 框架和 Tomcat 5.0，运行示例需要它们。
Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，可以选择是使用内置的 Spring Web 框架还是 Struts 这样的 Web 框架。通过策略接口，Spring 框架是高度可配置的，而且包含多种视图技术，例如 JavaServer Pages（JSP）技术、Velocity、Tiles、iText 和 POI。Spring MVC 框架并不知道使用的视图，所以不会强迫您只使用 JSP 技术。Spring MVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。
Spring 的 Web MVC 框架是围绕 DispatcherServlet 设计的，它把请求分派给处理程序，同时带有可配置的处理程序映射、视图解析、本地语言、主题解析以及上载文件支持。默认的处理程序是非常简单的 Controller 接口，只有一个方法 ModelAndView handleRequest(request, response)。Spring 提供了一个控制器层次结构，可以派生子类。如果应用程序需要处理用户输入表单，那么可以继承 AbstractFormController。如果需要把多页输入处理到一个表单，那么可以继承 AbstractWizardFormController。
示例应用程序有助于直观地学习这些特性。银行应用程序允许用户检索他们的帐户信息。在构建银行应用程序的过程中，可以学到如何配置 Spring MVC 框架和实现框架的视图层，视图层包括 JSTL 标记（用于显示输出的数据）和JavaServer Pages 技术。
要开始构建示例应用程序，请配置 Spring MVC 的 DispatcherServlet。请在 web.xml 文件中注册所有配置。清单 1 显示了如何配置sampleBankingServlet。
清单 1. 配置 Spring MVC DispatcherServlet
<servlet>
<servlet-name>sampleBankingServlet</servlet-name>
<servlet-class>
org.springframework.we.servlet.DispatcherServlet
<servlet-class>
<load-on-startup>1<load-on-startup>
<servlet>
|
DispatcherServlet 从一个 XML 文件装入 Spring 应用程序上下文，XML 文件的名称是 servlet 的名称后面加上 -servlet 。在这个示例中，DispatcherServlet 会从 sampleBankingServlet-servlet.xml 文件装入应用程序上下文。
下一步是配置想让 sampleBankingServlet 处理的 URL。同样，还是要在 web.xml 中注册所有这些信息。
清单 2. 配置想要处理的 URL
<servlet-mapping> <servlet-name> sampleBankingServlet<servlet-name> <url-pattern>*.jsp</url-pattern> </servlet-mapping> |
下面，装入配置文件。为了做到这点，请为 Servlet 2.3 规范注册 ContextLoaderListener 或为 Servlet 2.2 及以下的容器注册ContextLoaderServlet。为了保障后向兼容性，请用 ContextLoaderServlet。在启动 Web 应用程序时，ContextLoaderServlet 会装入 Spring 配置文件。清单 3 注册了 ContextLoaderServlet。
清单 3. 注册 ContextLoaderServlet
<servlet>
<servlet-name>context>servlet-name>
<servlet-class>
org.springframework.web.context.ContextLoaderServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
|
contextConfigLocation 参数定义了要装入的 Spring 配置文件，如下面的 servlet 上下文所示。
<context-param> <param-value>contextConfigLocation</param-value> <param-value>/WEB-INF/sampleBanking-services.xml</param-value> </context-param> |
sampleBanking-services.xml 文件代表示例银行应用程序服务的配置和 bean 配置。如果想装入多个配置文件，可以在 <param-value> 标记中用逗号作分隔符。
示例银行应用程序允许用户根据惟一的 ID 和口令查看帐户信息。虽然 Spring MVC 提供了其他选项，但是我将采用 JSP 技术作为视图页面。这个简单的应用程序包含一个视图页用于用户输入（ID 和口令），另一页显示用户的帐户信息。
我从 LoginBankController 开始，它扩展了 Spring MVC 的 SimpleFormController。SimpleFormContoller 提供了显示从 HTTP GET 请求接收到的表单的功能，以及处理从 HTTP POST 接收到的相同表单数据的功能。LoginBankController 用 AuthenticationService 和AccountServices 服务进行验证，并执行帐户活动。“ 配置视图属性 ”一节中的 清单 5 描述了如何把 AuthenticationService 和AccountServices 连接到 LoginBankController。 清单 4 显示了 LoginBankController 的代码。
下面，我必须注册在接收到 HTTP GET 请求时显示的页面。我在 Spring 配置中用 formView 属性注册这个页面，如清单 5 所示。sucessView 属性代表表单数据提交而且 doSubmitAction() 方法中的逻辑成功执行之后显示的页面。formView 和 sucessView 属性都代表被定义的视图的逻辑名称，逻辑名称映射到实际的视图页面。
清单 5. 注册 LoginBankController
<bean id="loginBankController"
class="springexample.controller.LoginBankController">
<property name="sessionForm"><value>true</value></property>
<property name="commandName"><value>loginCommand</value></property>
<property name="commandClass">
<value>springexample.commands.LoginCommand</value>
</property>
<property name="authenticationService">
<ref bean="authenticationService" />
</property>
<property name="accountServices">
<ref bean="accountServices" />
</property>
<property name="formView">
<value>login</value>
</property>
<property name="successView">
<value>accountdetail</value>
</property>
</bean>
|
commandClass 和 commandName 标记决定将在视图页面中活动的 bean。例如，可以通过 login.jsp 页面访问 loginCommand bean，这个页面是应用程序的登录页面。一旦用户提交了登录页面，应用程序就可以从 LoginBankController 的 onSubmit() 方法中的命令对象检索出表单数据。
Spring MVC 的 视图解析器 把每个逻辑名称解析成实际的资源，即包含帐户信息的 JSP 文件。我用的是 Spring 的InternalResourceViewResolver，如 清单 6 所示。
因为我在 JSP 页面中使用了 JSTL 标记，所以用户的登录名称解析成资源 /jsp/login.jsp，而 viewClass 成为 JstlView。
就像前面提到的，LoginBankController 内部连接了 Spring 的 AccountServices 和AuthenticationService。AuthenticationService 类处理银行应用程序的验证。AccountServices 类处理典型的银行服务，例如查找交易和电汇。清单 7 显示了银行应用程序的验证和帐户服务的配置。
清单 7. 配置验证和帐户服务
<beans>
<bean id="accountServices"
class="springexample.services.AccountServices">
</bean>
<bean id="authenticationService"
class="springexample.services.AuthenticationService">
</bean>
</beans>
|
以上服务在 sampleBanking-services.xml 中注册，然后装入 web.xml 文件中，就像 前面讨论的那样。控制器和服务配置好后，这个简单的应用程序就完成了。现在我们来看看部署和测试它时会发生什么!
我把示例应用程序部署在 Tomcat servlet 容器中。Tomcat 是 Java Servlet 和 Java ServerPagest 技术的官方参考实现中使用的 servlet 容器。如果以前没这么做过，请 下载 jakarta-tomcat-5.0.28.exe 并运行它把 Tomcat 安装到自己喜欢的任何位置，例如c:\tomcat5.0。
接下来，下载示例代码 并释放到驱动器（例如 c:\ ）上。创建了 Spring 项目的文件夹之后，打开它并把 spring-banking 子文件夹拷贝到 c:\tomvat5.0\webapps。spring-banking 文件夹是一个 Web 档案，里面包含 Spring MVC 示例应用程序。lib 文件夹包含应用程序需要的 Spring 框架、与Spring 相关的 MVC 库以及 JSTL 标记库和 jar 文件。
要启动 Tomcat 服务器，请使用以下命令：
cd bin C:\Tomcat 5.0\bin> catalina.bat start
Tomcat 应当启动并部署 Spring MVC 示例应用程序。
要测试应用程序，请打开 Web 浏览器，指向 http://localhost:tomcatport/springbanking 并用 Tomcat 服务器实际运行的端口替换tomcatport。应当看到图 1 所示的登录屏幕。输入用户 ID “admin”和口令“password”，并按下登录按钮。其他用户 ID 或口令会造成来自验证服务的错误。
图 1. Spring MVC 示例登录屏幕
登录成功之后，会看到图 2 所示的帐户细节页面。
图 2. Spring MVC 示例帐户细节页面
在三部分的 Spring 系列 的第三篇文章中，我介绍了 Spring MVC 框架的特性。我演示了如何配置和开发 Spring MVC 应用程序、如何配置 Spring MVC 控制器和向其中插入依赖项、如何用 JavaServer Pages 技术开发应用程序视图，以及如何把自己的页面与 Spring MVC 的视图层集成。总结这篇文章时，我演示了如何在 Tomcat servlet 容器中部署应用程序以及如何在浏览器中测试它。
请继续关注 Spring 系列 的下一篇文章。在下一篇文章中，我将介绍如何把基于 JMS 的应用程序与 Spring 框架集成。同时，请参阅参考资料 学习更多有关 Spring 框架和 Spring MVC 的内容。
第 4 部分: Spring JMS 消息处理 1-2-3
在 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 抽象框架简化了 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 的 SpringPlatformTransactionManager实现。它允许把 JMS 作为事务性资源集成到 Spring 的事务管理机制中。
就像前面提到的，示例应用程序会用 Spring 的 JMS 框架通过 JMS 接口与 IBM 的 WebSphere MQ 集成。通过在应用程序和 Web 服务之间传递消息，WebSphere MQ 提供了可靠的、有恢复能力的应用程序集成。它使用队列和事务性工具帮助保持消息跨网络的完整性。WebSphere MQ 降低了信息丢失的风险和调和通信 IT 系统的需要。
WebSphere MQ 在它所支持的所有平台上提供了一致的应用程序编程接口，这有助于让集成的程序可移植。除了标准接口外，WebSphere MQ 还完整实现了JMS 接口，包括对发布-订阅消息传递的支持。WebSphere MQ Explorer 工具可以远程地管理和配置整个 MQ 网络。管理和配置工具基于开放源码的 Eclipse 框架，而且是可扩展的。
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 文件（请参阅 下载）。
清单 1. JMS 模板配置
<!-- 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 检索连接工厂。
清单 2. 通过 JNDI 配置 JMS 连接工厂
<!-- 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 的配置。
清单 3. JNDI 查询的 JNDI 模板配置
<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 模板，下一步就是把它绑定到示例应用程序中，然后就可以用它发送和接收消息了。
JMS 模板可以绑定到应用程序中，以发送和接收 JMS 消息。在清单 4 中可以看出我如何把 清单 1 中的 JMS 模板绑定到示例应用程序中。
清单 4. 把 JmsTemplate 绑定到应用程序中
<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 类有关的代码。
清单 5. 用 JmsTemplate 发送 JMS 消息的 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 的代码。
清单 6. 用 JmsTemplate 检索 JMS 消息的 JMSReceiver
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 显示出示例应用程序 QueueManager MQJMS.QManager 已经创建并正在运行。
图 1. WebSphere MQ 的 QueueManager 配置
请在应用程序屏幕左侧面板上点击 MQJMS.QManager 下的 Queues 文件夹。应当看到已经创建了一个队列 RequestResponseQueue，如图 2 所示。
图 2. WebSphere MQ 的请求/响应队列配置
这就完成了队列的设置。
设置 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) |
现在已经把 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）。
清单 7. 装入示例应用程序的 Spring 配置
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 的内容。
转自：