读书笔记《advanced-java-ee-development-with-wildfly》使用Spring MVC 4.1
Spring 框架基于 Inversion of Control（IoC) 原则，其中对象定义自己的依赖关系。 依赖注入是IoC的一种形式。容器在创建 bean 时注入依赖项。依赖注入是使用 BeanFactory 和 ApplicationContext 接口实现的。 BeanFactory 接口用于管理 bean，ApplicationContext (WebApplicationContext 用于Web 应用程序）用于配置应用程序。 BeanFactory 应用 IoC 模式来分离配置和依赖规范。 ApplicationContext 接口为 BeanFactory 提供扩展（扩展）功能。
Spring MVC 框架基于 Model-View-Controller 设计模式 并使用 DispatcherServlet 实现。 DispatcherServlet 字段请求并使用 @RequestMapping 注释提供的 Web 请求 URI 映射将它们委托给请求处理程序。请求处理程序或控制器使用 ModelAndView 持有者返回 Model 和 View。在本章中，我们将在 Eclipse 中创建一个 Spring MVC 应用程序，使用 Maven 构建工具编译和打包该应用程序，并将该应用程序部署到 WildFly 8.1。随后，我们将在浏览器中运行 Spring 应用程序。在本章中，我们将介绍以下主题：
设置环境
创建一个 Spring MVC 项目
创建 MySQL 数据源
创建 JPA 配置文件
创建模型
创建数据访问对象设计模式
创建 Web 描述符
创建请求处理程序
创建视图
创建 Spring MVC 上下文
使用 Maven 部署 Spring 项目
创建部署结构和基础设施部署描述符
安装 Spring MVC Maven 项目
运行 Spring 应用程序
WildFly 8.1.0.Final：从
wildfly-8.1.0.Final.zip下载 <一个类="ulink" href="http://wildfly.org/downloads/" target="_blank">http://wildfly.org/downloads/。MySQL 5.6 数据库社区版：从 http://dev.mysql.com/downloads/mysql/。安装 MySQL 时，还要安装 Connector/J。
面向 Java EE 开发人员的 Eclipse IDE：从 https://www.eclipse.org/downloads/packages/release/Luna/SR1。
JBoss Tools (Luna) 4.2.0.Final：将此作为插件从 Eclipse Marketplace 安装到 Eclipse (http://tools.jboss.org/downloads/installation.html)。
Apache Maven：从 http://maven.apache.org/download.cgi。
Java 7：从 http://www.oracle.com/technetwork/java/javase/downloads/index.html?ssSourceSiteId=ocomcn。
设置JAVA_HOME、JBOSS_HOME、MAVEN_HOME和 MYSQL_HOME 环境变量。添加 %JAVA_HOME%/bin, %MAVEN_HOME%/bin, %JBOSS_HOME%/bin 和 %MYSQL_HOME/bin 到 PATH 环境变量。
创建一个 WildFly 8.1.0 运行时，如 第 1 章 ，EJB 3.x 入门。如 java:jboss/datasources/MySQLDS 创建 MySQL 数据源/book/application-development/9781783288908/1" linkend="ch01">第 1 章，EJB 3.x 入门 .
首先，创建一个 Spring MVC 项目。选择文件 | 新 | 其他。在 New 中，选择 JBoss Central | Spring MVC 项目，如下图所示。然后，点击下一步。
在 Spring MVC Project 向导中，选择 Target Runtime 作为 < code class="literal">WildFly8.x Runtime，如下图所示。现在，点击下一步。
指定 项目名称 (jboss- springmvc) 和 Package (org.jboss.springmvc)，如图以下屏幕截图。在此之后，单击下一步。
指定 Group Id (org. jboss.springmvc), Artifact Id (springmvc), 版本（1.0.0）和包 (org.jboss.springmvc)，如下图所示，点击Finish。
jboss-springmvc web 项目被创建，如下图所示：
在后续的部分，我们将开发Spring MVC应用并详细讨论Spring MVC应用工件； Project Explorer 选项卡中显示的应用程序是默认应用程序，将替换为 我们将开发的应用程序。
我们将在 Spring 中使用 EJB 3.0 实体 bean 进行 对象/关系映射MVC 应用程序。 jboss-springmvc项目中的springmvc\src\main\resources\META-INF\persistence.xml配置文件已创建当我们创建 Spring MVC 项目时。 persistence.xml 文件指定了一个持久性提供程序，用于实体到数据库的对象/关系映射。使用 persistence-unit 元素指定持久性单元。将 transaction-type 设置为 JTA（默认）。将持久性提供程序指定为 Hibernate 持久性提供程序 org.hibernate.ejb.HibernatePersistence。将 jta-data-source 元素值设置为我们之前创建的 java:jboss/datasources/MySQLDS 数据源。使用 hibernate.hbm2ddl.auto 属性将 DDL 生成策略设置为 create-drop。使用 create-drop 策略，创建和删除所需的表。 hibernate.show_sql 属性设置为 false，表示输出所有 SQL 语句，这是调试的另一种方法。 hibernate.dialect 文件设置为 MySQL 数据库的 org.hibernate.dialect.MySQLDialect。 persistence.xml 配置文件在以下代码中列出：
<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.0" xsi:schemaLocation=" http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
<persistence-unit name="primary" transaction-type="JTA">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<jta-data-source>java:jboss/datasources/MySQLDS</jta-data-source>
<class>org.jboss.springmvc.model.Catalog</class>
<exclude-unlisted-classes />
<properties>
<property name="jboss.entity.manager.factory.jndi.name" value="java:jboss/mysql/persistence" />
<!-- Properties for Hibernate -->
<property name="hibernate.hbm2ddl.auto" value="create-drop" />
<property name="hibernate.show_sql" value="false" />
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />
</properties>
</persistence-unit>
</persistence>
JPA 规范 不需要持久性提供程序来创建表，即使 hibernate.hbm2ddl.auto 属性也是如此 设置为 create-drop 或 create。 Hibernate 持久性提供程序支持创建表。
在此 部分中，我们将为域模型创建一个 EJB 3.0 实体 bean .创建 org.jboss.springmvc.model.Catalog 实体 bean 类，它只是一个 plain old Java object （POJO）。要创建 Java 类，请选择 File | 新 | Other，并在 New, 中选择 Java | Class，如下图所示：
在 新建 Java 类 向导中，选择 源文件夹 as jboss-springmvc/src/main/java ，指定 Package 为 org.jboss.springmvc.model，并指定class Name as Catalog，如下图所示：
org.jboss.springmvc.model.Catalog.java 类 得到 添加到项目中，如下图Project Explorer所示：
删除 Member.java 类 和其他 Member*
classes 从项目中获取目录结构，如下图所示：
使用 @Entity 注释和 @Table 注释 Catalog 实体类注解。在 @Table 注解中，将表名指定为 CATALOG 和 uniqueConstraints对 ID 列使用 @UniqueConstraint 注释。指定实体类中需要的无参数构造函数。实体类实现了 Serializable 接口，以便在持久化到数据库时将启用缓存的实体 bean 序列化到缓存中。要通过序列化运行时将版本号与可序列化类关联，请指定 serialVersionUID 变量。声明 bean 属性的变量：id、journal、publisher、< code class="literal">edition、title 和 作者。为 bean 属性添加 getter/setter 方法。 @Id 注释指定标识符属性。 @Column 注释指定与属性关联的列名。 nullable 元素设置为 false，因为主键不能为 null .
如果我们 使用 Oracle 数据库，我们将使用 @ 指定主键生成器的类型序列SequenceGenerator 注释。生成策略由 @GeneratedValue 注释指定。对于Oracle数据库，生成策略是strategy=GenerationType.SEQUENCE，但是因为MySQL数据库支持通过生成序列来自动增加主键列值，所以我们设置了GenerationType.AUTO 的生成策略。 Catalog.java 实体类在以下代码片段中列出：
package org.jboss.springmvc.model;
import java.io.Serializable;
import javax.persistence.*;
/**
* The persistent class for the CATALOG database table.
*
*/
@Entity
@Table(name = "CATALOG", uniqueConstraints = @UniqueConstraint(columnNames = "ID"))
public class Catalog implements Serializable {
private static final long serialVersionUID = 1L;
private int id;
private String journal;
private String publisher;
private String edition;
private String title;
private String author;
public Catalog() {
}
@Id
@Column(name = "ID", nullable = false)
@GeneratedValue(strategy = GenerationType.AUTO)
public int getId() {
return this.id;
}
public void setId(int id) {
this.id = id;
}
public String getJournal() {
return this.journal;
}
public void setJournal(String journal) {
this.journal = journal;
}
public String getPublisher() {
return this.publisher;
}
public void setPublisher(String publisher) {
this.publisher = publisher;
}
public String getEdition() {
return this.edition;
}
public void setEdition(String edition) {
this.edition = edition;
}
public String getTitle() {
return this.title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return this.author;
}
public void setAuthor(String author) {
this.author = author;
}
}
数据访问对象设计模式的优点，如可重用软件和解耦业务逻辑和数据库持久性逻辑，已经很成熟了。我们将在数据访问层使用 DAO 设计模式。 DAO 设计模式将为持久化 Catalog 实体实例和获取 Catalog 实体实例提供标准操作。创建一个org.jboss.springmvc.data.CatalogDao Java接口，如下图所示：
为 persist(Catalog) 方法添加方法定义以保持 Catalog 对象和 getAllCatalogs () 获取 Catalog 对象的 List。 CatalogDao 接口在以下代码中列出：
package org.jboss.springmvc.data;
import java.util.List;
import javax.persistence.TypedQuery;
import org.jboss.springmvc.model.Catalog;
public interface CatalogDao
{
public void persist(Catalog catalog);
public List<Catalog> getAllCatalogs();
}
创建一个 org.jboss.springmvc.data.CatalogDaoImpl实现类来实现org.jboss.springmvc.data.CatalogDao 接口。使用 @Component 注释类，这使该类成为使用类路径扫描自动检测到的“组件” 当我们使用基于注解的配置时。在resources/META-INF/spring/applicationContext.xml应用上下文配置文件中，自动检测org.jboss.springmvc.data 包在 <beans/><context:component/> 元素进行配置> 元素：
<context:component-scan base-package="org.jboss.springmvc.data" />
Spring MVC 自动检测 CatalogDaoImpl 类并注入一个 CatalogDaoImpl 对象，catalogDaoImpl，到任何 @Autowired 字段、方法参数或 CatalogDaoImpl 类型的构造函数参数中。基于注释的事务使用 applicationContext.xml 中的以下声明进行配置：
<tx:annotation-driven />
\\jboss-springmvc\src\main\resources\META-INF\spring\applicationContext.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:tx="http://www.springframework.org/schema/tx" 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.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd"> <context:component-scan base-package="org.jboss.springmvc.model" /> <context:component-scan base-package="org.jboss.springmvc.data" /> <tx:annotation-driven /> </beans>
使用 @Transactional 注释 persist(Catalog) 方法。使用 @PersistenceContext 注释将 EntityManager 注入 DAO 实现类。使用了EntityManager的persist()方法持久化 Catalog 实例。要 检索所有 Catalog 实例，请创建一个 TypedQuery使用 EntityManager 对象的 createQuery 方法的对象。使用 的 对象。 getResultList() 方法获取 List<Catalog> 对象作为结果TypedQueryorg.jboss.springmvc.repo.CatalogDaoImpl DAO 实现类在以下代码中列出：
package org.jboss.springmvc.data;
import org.jboss.springmvc.model.*;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
@Component
public class CatalogDaoImpl implements CatalogDao
{
// Injected database connection:
@PersistenceContext private EntityManager em;
// Stores a new catalog:
@Transactional
public void persist(Catalog catalog) {
em.persist(catalog);
}
// Retrieves all the catalogs:
public List<Catalog> getAllCatalogs() {
TypedQuery<Catalog> query = em.createQuery(
"SELECT c FROM Catalog c ORDER BY c.id", Catalog.class);
return query.getResultList();
}
}
我们需要将应用上下文配置文件添加到jboss-springmvc Web 应用程序类路径。为 org.springframework.web.context.ContextLoaderListener 类添加一个 <listener/> 标签，它会启动 Spring 的WebApplicationContext 根目录。使用 contextConfigLocation 上下文参数指定根上下文的 config 位置。 org.springframework.web.servlet.DispatcherServlet servlet 将请求分派给处理程序。指定 init 参数，contextConfigLocation，为 中的 Spring MVC 应用程序配置另一个应用程序上下文/WEB-INF/jboss-as-spring-mvc-context.xml，这将在后面的部分中讨论。指定映射 DispatcherServlet servlet 的 URL 模式的 servlet。 web.xml 文件在以下代码中列出：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="..." version="3.1">
<display-name>Java EE 7 Starter Application</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:/META-INF/spring/applicationContext.xml,
classpath:/META-INF/spring/infrastructure.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>jboss-spring</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/jboss-as-spring-mvc-context.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>jboss-spring</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
Spring MVC 中的 典型 请求处理程序基于 @Controller 和 @RequestMapping 注释。创建一个 Java 类，org.jboss.springmvc.controller.CatalogController，用 @Controller 注解进行注解，这使得类可自动检测到 Spring 的注入。在 \springmvc\src\main\webapp\WEB-INF\jboss-as-spring-mvc-context.xml 上下文文件中，本章稍后会列出和讨论，配置org.jboss.springmvc.mvc基础包的组件扫描，如下：
<context:component-scan base-package="org.jboss.springmvc.controller" />
当 CatalogController 类需要处理一个要求。处理程序类使用数据创建模型 Map 并选择要呈现的视图名称。 createAndDisplayCatalog 方法接受 DispatcherServlet 发送的 servlet 请求并返回一个 org.springframework.web .servlet.ModelAndView 对象，它是 Spring MVC 框架中 Model 和 View 的持有者。使用 @RequestMapping 注释将 servlet 请求映射到 createAndDisplayCatalog 处理程序方法。将路径映射 URI 指定为 /catalog。
使用 @AutoWire 注释将 org.jboss.springmvc.data.CatalogDao DAO 接口自动连接到 Spring 的依赖注入机制。 catalogDaoImpl bean 在启动时被注入，因为默认情况下，应用程序上下文会在启动时预先实例化所有单例（Spring 中的默认范围）bean。 createAndDisplayCatalog 方法获取请求参数值并创建一个 Catalog 对象。 Catalog 对象是使用自动装配的 DAO 对象的 persist 方法存储的。创建模型 Map 后，createAndDisplayCatalog 方法返回 org.springframework.web.servlet .ModelAndView 对象与 View 目录和 catalogDao 模型。 org.springframework.web.servlet.ModelAndView 对象返回到 DispatcherServlet 以供 servlet 呈现响应。视图 ID 使用 jboss-as-spring-mvc-context.xml 上下文文件中指定的视图解析器解析。 Map 模型可用于视图模板。控制器类在以下代码中列出：
package org.jboss.springmvc.controller;
import org.jboss.springmvc.data.*;
import org.jboss.springmvc.model.*;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class CatalogController {
@Autowired
private CatalogDao catalogDao;
@RequestMapping(value = "/catalog")
public ModelAndView createAndDisplayCatalog(HttpServletRequest request) {
// Handle a new catalog (if any):
String journal = request.getParameter("journal");
String publisher = request.getParameter("publisher");
String edition = request.getParameter("edition");
String title = request.getParameter("title");
String author = request.getParameter("author");
if (journal != null && publisher != null && edition != null
&& title != null && author != null) {
Catalog catalog = new Catalog();
catalog.setJournal(journal);
catalog.setPublisher(publisher);
catalog.setEdition(edition);
catalog.setTitle(title);
catalog.setAuthor(author);
catalogDao.persist(catalog);
}
// Prepare the result view (catalog):
return new ModelAndView("catalog", "catalogDao", catalogDao);
}
}
模型、DAO 和 控制器类显示在 Project Explorer 中以下屏幕截图：
查看解析器，在WEB中配置-INF/jboss-as-spring-mvc-context.xml Web 应用程序上下文，从 ModelAndViewView > 对象，并使用 catalog.jsp 视图模板呈现响应。在WEB-INF/views目录下创建catalog.jsp。要创建 JSP，请选择 文件 | 新 | Other，并在 New 中选择 网络 | JSP 文件 并点击下一步。在 New JSP File 向导中，选择 WEB-INF/views 文件夹，指定 文件名为catalog.jsp，然后点击接下来，如下图所示。随后点击完成。
catalog.jsp 类 和添加的其他类，其中 包括控制器类、DAO类和模型类，如下图Project Explorer所示：
请求 从 catalog.jsp 发起 视图模板，并使用 catalog.jsp 呈现响应。要向 DispatcherServlet 发送请求，<form/> 元素具有 action 属性设置为 catalog，它被映射到使用 /catalog 路径 URI CatalogController 请求处理程序类中的literal">@RequestMapping 注释。 createAndDisplayCatalog 处理程序方法在表单发布时被调用。在 catalog.jsp 中，使用范围请求从 org.jboss.springmvc.data.CatalogDao 接口实例化一个 bean。为输入字段添加 <form/> 和 <input/> 元素以创建新的 目录 对象。要呈现来自 org.jboss.springmvc.data.CatalogDao bean 的响应，请调用 getAllCatalogs() 方法 获取Catalog 对象的List。在 List 上迭代 以输出 Catalog 实例属性。
catalog.jsp 列在以下代码中：
<%@page contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@page import="org.jboss.springmvc.model.Catalog,org.jboss.springmvc.data.CatalogDao,org.jboss.springmvc.controller.CatalogController"%>
<jsp:useBean id="catalogDao" type="org.jboss.springmvc.data.CatalogDao" scope="request" />
<!--scope should be request for the bean to be found -->
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Spring MVC-JPA Catalog</title>
<head>
<meta name="generator" content="HTML Tidy for Linux/x86 (vers 25 March 2009), see www.w3.org" />
<title>
Spring MVC-JPA Catalog
</title>
</head><!-- action should be same as the mapping in the controller -->
<body>
<h2>
Catalog form
</h2>
<form method="post" action="catalog">
Journal: <input type="text" name="journal" />Publisher: <input type="text" name="publisher" />Edition: <input type="text" name="edition" />Title: <input type="text" name="title" />Author: <input type="text" name="author" />
<table>
<tr>
<td></td>
</tr>
<tr>
<td></td>
</tr>
<tr>
<td></td>
</tr>
<tr>
<td></td>
</tr>
<tr>
<td></td>
</tr>
</table>
<p>
<input type="submit" value="Add" />
</p>
</form>
<table>
<%
for (Catalog catalog : catalogDao.getAllCatalogs()) {
%>
<tr>
<td>
<%=catalog.getId()%>
</td>
<td>
<%=catalog.getJournal()%>
</td>
<td>
<%=catalog.getPublisher()%>
</td>
<td>
<%=catalog.getEdition()%>
</td>
<td>
<%=catalog.getTitle()%>
</td>
<td>
<%=catalog.getAuthor()%>
</td>
</tr><%
}
%>
</table>
</body>
</html>
Spring MVC web 应用上下文配置在 springmvc\src\main\webapp\WEB-INF\ jboss-as- spring-mvc-context.xml。除了添加 org.jboss.springmvc.controller 包进行自动检测外，还支持使用带有 @RequestMapping 注释的控制器方法处理请求 配置了 <mvc:annotation-driven /> 声明。添加对基于注解的事务管理器的支持； CatalogDao 接口的 persist 方法 用 <代码类="literal">@Transactional。为 org.springframework.web.servlet.view.InternalResourceViewResolver 类添加一个视图解析器 bean。最佳实践是在 WEB-INF 目录中添加视图模板，例如 catalog.jsp，这样只有控制器可以访问它们。添加一个带有 /WEB-INF/views 值的 bean 属性前缀来解析视图模板。 jboss-as-spring-mvc-context.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:mvc="http://www.springframework.org/schema/mvc" xmlns:tx="http://www.springframework.org/schema/tx" 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.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<context:component-scan base-package="org.jboss.springmvc.controller" />
<mvc:annotation-driven />
<!-- Add JPA support -->
<bean id="emf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="loadTimeWeaver">
<bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver" />
</property>
</bean>
<!-- Add Transaction support -->
<bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="emf" />
</bean>
<!-- Use @Transaction annotations for managing transactions -->
<tx:annotation-driven transaction-manager="txManager" />
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/" />
<property name="suffix" value=".jsp" />
</bean>
<mvc:resources mapping="/static/**" location="/" />
<mvc:default-servlet-handler />
</beans>
Spring MVC 提供了两个级别的应用程序上下文，应用程序级服务的根应用程序上下文和 servlet 级 bean 和服务的 servlet 应用程序上下文。 /META-INF/spring/applicationContext.xml文件配置在web.xml为根级应用上下文， /WEB-INF/jboss-as-spring-mvc-context.xml 是 DispatcherServlet 的上下文。 servlet 上下文配置会覆盖同名 bean 的根上下文。
接下来，使用 Maven 构建工具编译、打包和部署 Spring MVC 应用程序。 Hibernate JPA API、Hibernate Validator API 和 Hibernate Entity manager API 由 WildFly 8.1 提供。在 MySQL JDBC 连接器上添加 依赖，如下：
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.22</version> </dependency>
org.springframework 组 ID 中提供了 Spring 依赖项。 Spring版本在pom.xml中默认配置为Spring 4.1.2，如下：
<version.spring>4.1.2.RELEASE</version.spring>
Spring Web MVC 依赖也配置为 4.1.2 版本。所有必需的 Spring 框架依赖项——Spring AOP、Spring Beans、Spring Context、Spring Core、Spring JDBC、Spring ORM、Spring Tx、Log4j、AOP 联盟、Commons logging、Cglib、Spring Expression Language 和 Spring Web——都在 <代码类="literal">pom.xml。在<build/>中，配置Maven编译插件和Maven WAR插件。将 Maven War 插件的输出目录设置为 WildFly 8.1 独立安装的 C:\wildfly-8.1.0.Final\standalone\deployments 目录。
pom.xml 文件在以下代码中列出：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.jboss.springmvc</groupId>
<artifactId>jboss-springmvc</artifactId>
<packaging>war</packaging>
<version>1.0.0</version>
<name>Getting Started with Spring on JBoss</name>
<properties>
<!-- Spring version -->
<version.spring>4.1.2.RELEASE</version.spring>
<!-- Spring Third Party dependencies -->
<version.aopalliance>1.0</version.aopalliance>
<!-- Third Party dependencies -->
<version.standard.taglibs>1.1.2</version.standard.taglibs>
<version.commons.logging>1.1.1</version.commons.logging>
<!-- JBoss AS plugin for deployment -->
<version.jboss.as.maven.plugin>7.6.Final</version.jboss.as.maven.plugin>
</properties>
<repositories>
<repository>
<id>springsource-milestones</id>
<name>SpringSource Milestones Proxy</name>
<url>https://oss.sonatype.org/content/repositories/springsource-milestones</url>
</repository>
<repository>
<id>Maven</id>
<name>Maven</name>
<url>http://repo1.maven.org/maven2</url>
</repository>
</repositories>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.jboss.spec</groupId>
<artifactId>jboss-javaee-web-6.0</artifactId>
<version>3.0.0.Final</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- Spring dependencies -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${version.spring}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${version.spring}</version>
</dependency>
<!-- Third Party dependencies -->
<dependency>
<groupId>aopalliance</groupId>
<artifactId>aopalliance</artifactId>
<version>${version.aopalliance}</version>
</dependency>
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>${version.standard.taglibs}</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>${version.commons.logging}</version>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- Import the JPA API using the provided scope It is included in JBoss AS 7 / EAP 6 -->
<dependency>
<groupId>org.hibernate.javax.persistence</groupId>
<artifactId>hibernate-jpa-2.0-api</artifactId>
<scope>provided</scope>
</dependency>
<!-- JSR-303 (Bean Validation) Implementation -->
<!-- Provides portable constraints such as @Email -->
<!-- Hibernate Validator is shipped in JBoss AS 7 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>4.1.0.Final</version>
<exclusions>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- Annotation processor that raising compilation errors whenever constraint annotations are incorrectly used. -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator-annotation-processor</artifactId>
<version>4.1.0.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>4.1.0.Final</version>
</dependency>
<!-- Import Spring dependencies, these are either from community or versions certified in WFK2 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${version.spring}</version>
<!-- <scope>provided</scope> -->
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${version.spring}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${version.spring}</version>
</dependency>
<!-- Other community dependencies -->
<dependency>
<groupId>aopalliance</groupId>
<artifactId>aopalliance</artifactId>
<version>${version.aopalliance}</version>
</dependency>
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>${version.standard.taglibs}</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>${version.commons.logging}</version>
</dependency>
<!-- Add cglib for the CatalogDaoTest -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib-nodep</artifactId>
<version>2.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.22</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.0.1</version>
</dependency>
<!-- Add JSON dependency, specified in jboss-deployment-structure.xml -->
<dependency>
<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-mapper-asl</artifactId>
<version>1.9.3</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-core-asl</artifactId>
<version>1.9.3</version>
<!-- <scope>provided</scope> -->
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.6.4</version>
<!-- <scope>provided</scope> -->
</dependency>
</dependencies>
<build>
<finalName>jboss-springmvc</finalName>
<plugins>
<!-- Force Java 6 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.4</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
<!-- Deployent on AS from console -->
<plugin>
<groupId>org.jboss.as.plugins</groupId>
<artifactId>jboss-as-maven-plugin</artifactId>
<version>${version.jboss.as.maven.plugin}</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>2.2</version>
<configuration>
<outputDirectory>C:\wildfly-8.1.0.Final\standalone\deployments</outputDirectory>
<failOnMissingWebXml>false</failOnMissingWebXml>
<warName>${project.artifactId}</warName>
</configuration>
</plugin>
</plugins>
</build>
</project>
列出的一些 依赖项没有在示例应用程序中使用，但可以在其他一些 Spring MVC 应用程序中使用。在我们运行 jboss-springmvc 应用程序之前，从项目中删除所有测试文件和类。此外，从 resources 目录中删除 import.sql。
我们有 不是 但讨论了两个文件： webapp/WEB-INF/jboss-deployment-structure.xml 和 resources/META-INF/spring/infrastructure.xml。 jboss-deployment-structure.xml 文件 是 JBoss 特定的部署描述符，用于配置粒度类加载。如果不包含 jboss-deployment-structure.xml 文件，则使用默认的类加载，即
可能不是应用程序所需要的。 jboss-deployment-structure.xml 文件可用于以下目的：
防止包含自动依赖项
添加其他依赖项
定义附加模块
向模块添加额外的资源根
修改
EAR部署隔离类加载行为
我们使用 jboss-deployment-structure.xml 来包含对 org.codehaus.jackson.jackson-core-asl 的依赖、org.codehaus.jackson.jackson-mapper-asl、org.slf4j和 mysql 模块。
jboss-deployment-structure.xml 文件列出如下：
<?xml version="1.0" encoding="UTF-8"?>
<jboss-deployment-structure xmlns="urn:jboss:deployment-structure:1.0">
<deployment>
<!-- <exclusions>
<module name="org.hibernate" />
</exclusions> -->
<dependencies>
<module name="mysql" />
<module name="org.codehaus.jackson.jackson-core-asl" />
<module name="org.codehaus.jackson.jackson-mapper-asl" />
<module name="org.slf4j" />
</dependencies>
</deployment>
</jboss-deployment-structure>
infrastructure.xml 文件用于以下目的：
在 JNDI 中注册实体管理器工厂
在 JNDI 中注册数据源
启用 JTA 事务管理
infrastructure.xml 文件列出如下：
<?xml version="1.0" encoding="UTF-8"?>
<jboss-deployment-structure xmlns="urn:jboss:deployment-structure:1.0">
<deployment>
<!-- <exclusions>
<module name="org.hibernate" />
</exclusions> -->
<dependencies>
<module name="mysql" />
<module name="org.codehaus.jackson.jackson-core-asl" />
<module name="org.codehaus.jackson.jackson-mapper-asl" />
<module name="org.slf4j" />
</dependencies>
</deployment>
</jboss-deployment-structure>
目录 结构 Spring Maven 应用程序的 jboss-springmvc\src\main\java 和 jboss-springmvc\src\main\resources 目录显示在 Project Explorer 中，如下截图：
目录 结构的Spring Maven应用的jboss-springmvc\src\main\webapp目录也是在以下屏幕截图中的 Project Explorer 中显示：
要运行 Maven 构建工具，请右键单击 pom.xml 并选择 运行方式 | Maven 安装，如下图所示：
jboss-springmvc 应用程序 被编译并打包到 jboss- springmvc.war 存档，它将输出到 deployments 目录。 Maven 输出 BUILD SUCCESS 消息，如以下屏幕截图所示：
如果 WildFly 8.1 服务器尚未启动，请启动它。 jboss-springmvc.war 存档被部署到 WildFly 8.1。现在登录 WildFly Administration Console 并点击 Manage Deployments。部署后的 jboss-springmvc.war 文件如下图所示：
catalog 架构被导出到 MySQL 数据库。 hibernate_sequence 自动递增 ID 字段也被创建。 catalog 架构描述可以通过 MySQL 命令行客户端中的 desc catalog 命令输出，如下图所示：
