使用Maven搭建Struts2+Spring3+Hibernate4的整合开发环境

共计 28274 个字符，预计需要花费 71 分钟才能阅读完成。

做了三年多的 JavaEE 开发了，在平时的 JavaEE 开发中，为了能够用最快的速度开发项目，一般都会选择使用 Struts2，SpringMVC，Spring，Hibernate，MyBatis 这些开源框架来开发项目，而这些框架一般不是单独使用的，经常是 Struts2+Spring3+Hibernate、SpringMVC+Spring+Hibernate、SpringMVC+Spring+Mybatis 这几种组合中的一种，也就是多个框架配合起来使用。今天来总结一下如何使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境。

Maven 权威指南_中文完整版清晰 PDF http://www.linuxidc.com/Linux/2014-06/103690.htm

Maven 3.1.0 发布，项目构建工具 http://www.linuxidc.com/Linux/2013-07/87403.htm

Linux 安装 Maven http://www.linuxidc.com/Linux/2013-05/84489.htm

Maven3.0 配置和简单使用 http://www.linuxidc.com/Linux/2013-04/82939.htm

Ubuntu 下搭建 sun-jdk 和 Maven2 http://www.linuxidc.com/Linux/2012-12/76531.htm

Maven 使用入门 http://www.linuxidc.com/Linux/2012-11/74354.htm

第一步：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

第二步：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

第三步：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

创建好的项目如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

第四步：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

注意：这里的 JDK 要选择默认的，这样别人在使用的时候，如何 JDk 不一致的话也不会出错，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

第五步：

创建 Maven 标准目录
src/main/java
src/main/resources
src/test/java
src/test/resources

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

第六步：

发布项目：Maven install

清除编译过的项目：Maven clean

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

Maven install 命令执行结果如下：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

OK，Maven 工程创建成功！

更多详情见请继续阅读下一页的精彩内容：http://www.linuxidc.com/Linux/2015-02/114265p2.htm

1.spring-core

2.spring-context

3.spring-jdbc

4.spring-beans

5.spring-web

6.spring-expression

7.spring-orm

在 pom.xml 中编写 Spring3 需要的包，maven 会自动下载这些包以及相关的依赖 jar 包。

  1 <!-- spring3 -->
 2         <dependency>
 3             <groupId>org.springframework</groupId>
 4             <artifactId>spring-core</artifactId>
 5             <version>3.1.2.RELEASE</version>
 6         </dependency>
 7         <dependency>
 8             <groupId>org.springframework</groupId>
 9             <artifactId>spring-context</artifactId>
10             <version>3.1.2.RELEASE</version>
11         </dependency>
12         <dependency>
13             <groupId>org.springframework</groupId>
14             <artifactId>spring-jdbc</artifactId>
15             <version>3.1.2.RELEASE</version>
16         </dependency>
17         <dependency>
18             <groupId>org.springframework</groupId>
19             <artifactId>spring-beans</artifactId>
20             <version>3.1.2.RELEASE</version>
21         </dependency>
22         <dependency>
23             <groupId>org.springframework</groupId>
24             <artifactId>spring-web</artifactId>
25             <version>3.1.2.RELEASE</version>
26         </dependency>
27         <dependency>
28             <groupId>org.springframework</groupId>
29             <artifactId>spring-expression</artifactId>
30             <version>3.1.2.RELEASE</version>
31         </dependency>
32         <dependency>
33             <groupId>org.springframework</groupId>
34             <artifactId>spring-orm</artifactId>
35             <version>3.1.2.RELEASE</version>
36         </dependency>

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

在 src/main/resources 目录下创建一个 spring.xml 文件，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

spring.xml 文件的内容如下：

  1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans" 
 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4 xmlns:context="http://www.springframework.org/schema/context" 
 5 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 6 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
 7 http://www.springframework.org/schema/context 
 8 http://www.springframework.org/schema/context/spring-context-3.0.xsd
 9 ">
10 
11     <!-- 引入属性文件,config.properties 位于 src/main/resources 目录下 -->
12     <context:property-placeholder location="classpath:config.properties" />
13 
14     <!-- 自动扫描 dao 和 service 包(自动注入) -->
15     <context:component-scan base-package="me.gacl.dao,me.gacl.service" />
16 
17 </beans>

在 src/main/resources 目录下创建一个 config.properties 文件，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

config.properties 文件主要是用来编写一些系统的配置信息，例如数据库连接信息，config.properties 文件中的内容暂时先不编写，等整合到 Hibernate 时再编写具体的数据库连接信息。

首先，在 src/main/Java 中创建 me.gacl.service 包，在包中编写一个 UserServiceI 接口，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

代码如下：

  1 package me.gacl.service;
 2 
 3 /**
 4  * 测试
 5  * @author gacl
 6  *
 7  */
 8 public interface UserServiceI { 9 
10     /**
11      * 测试方法
12      */
13     void test();
14 }

然后，在 src/main/java 中创建 me.gacl.service.impl 包，在包中编写 UserServiceImpl 实现类，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

代码如下：

  1 package me.gacl.service.impl;
 2 
 3 import org.springframework.stereotype.Service;
 4 
 5 import me.gacl.service.UserServiceI;
 6 //使用 Spring 提供的 @Service 注解将 UserServiceImpl 标注为一个 Service
 7 @Service("userService")
 8 public class UserServiceImpl implements UserServiceI { 9 
10     @Override
11     public void test() {12         System.out.println("Hello World!");
13     }
14 
15 }

进行单元测试时需要使用到 Junit，所以需要在 pom.xml 文件中添加 Junit 的 jar 包描述，如下：

 1         <!-- Junit -->
2         <dependency>
3             <groupId>junit</groupId>
4             <artifactId>junit</artifactId>
5             <version>4.12</version>
6             <scope>test</scope>
7         </dependency>

<scope>test</scope>这里的 test 表示测试时编译 src/main/test 文件夹中的文件，等发布的时候不编译。最后，在 src/main/test 中创建 me.gacl.test 包，在包中编写 TestSpring 类，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

代码如下：

  1 package me.gacl.test;
 2 
 3 import me.gacl.service.UserServiceI;
 4 
 5 import org.junit.Test;
 6 import org.springframework.context.ApplicationContext;
 7 import org.springframework.context.support.ClassPathXmlApplicationContext;
 8 
 9 public class TestSpring {10 
11     @Test
12     public void test(){13         //通过 spring.xml 配置文件创建 Spring 的应用程序上下文环境
14         ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring.xml");
15         //从 Spring 的 IOC 容器中获取 bean 对象
16         UserServiceI userService = (UserServiceI) ac.getBean("userService");
17         //执行测试方法
18         userService.test();
19     }
20 }

JUnit Test 运行，结果如图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

 1 <!-- Spring 监听器 -->
2     <listener>
3         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
4     </listener>
5     <!-- Spring 配置文件位置 -->
6     <context-param>
7         <param-name>contextConfigLocation</param-name>
8         <param-value>classpath:spring.xml</param-value>
9     </context-param>

在 tomcat 服务器中进行测试，先执行【Maven install】命令发布项目, 然后将 SSHE 项目部署到 tomcat 服务器，最后启动 tomcat 服务器

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

tomcat 服务器启动的过程中没有出现报错，输入地址：http://localhost:8080/SSHE/ 能够正常进行访问，就说明 Spring3 的开发环境搭建成功，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

测试通过，Spring3 开发环境搭建成功！

Maven 权威指南_中文完整版清晰 PDF http://www.linuxidc.com/Linux/2014-06/103690.htm

Maven 3.1.0 发布，项目构建工具 http://www.linuxidc.com/Linux/2013-07/87403.htm

Linux 安装 Maven http://www.linuxidc.com/Linux/2013-05/84489.htm

Maven3.0 配置和简单使用 http://www.linuxidc.com/Linux/2013-04/82939.htm

Ubuntu 下搭建 sun-jdk 和 Maven2 http://www.linuxidc.com/Linux/2012-12/76531.htm

Maven 使用入门 http://www.linuxidc.com/Linux/2012-11/74354.htm

第一步：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

第二步：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

第三步：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

创建好的项目如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

第四步：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

注意：这里的 JDK 要选择默认的，这样别人在使用的时候，如何 JDk 不一致的话也不会出错，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

第五步：

创建 Maven 标准目录
src/main/java
src/main/resources
src/test/java
src/test/resources

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

第六步：

发布项目：Maven install

清除编译过的项目：Maven clean

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

Maven install 命令执行结果如下：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

OK，Maven 工程创建成功！

更多详情见请继续阅读下一页的精彩内容：http://www.linuxidc.com/Linux/2015-02/114265p2.htm

1.strtus2-core
2.struts2-spring-plugin(struts2 和 Spring 整合时需要使用到的插件)
3.struts2-convention-plugin(使用了这个插件之后，就可以采用注解的方式配置 Struts 的 Action，免去了在 struts.xml 中的繁琐配置项)

4.struts2-config-browser-plugin(config-browser-plugin 插件不是必须的，但是使用了这个插件之后，就可以很方便的浏览项目中的所有 action 及其与 jsp view 的映射)

在 pom.xml 文件中编写 Struts2 所需要的 jar 包，Maven 会自动下载这些包

  1 <!-- Struts2 的核心包 -->
 2         <dependency>
 3             <groupId>org.apache.struts</groupId>
 4             <artifactId>struts2-core</artifactId>
 5             <version>2.3.16</version>
 6             <!--
 7             这里的 exclusions 是排除包，因为 Struts2 中有 Javassist，Hibernate 中也有 javassist,
 8             所以如果要整合 Hibernate，一定要排除掉 Struts2 中的 javassist，否则就冲突了。 9             <exclusions>
10                 <exclusion>
11                     <groupId>javassist</groupId>
12                     <artifactId>javassist</artifactId>
13                 </exclusion>
14             </exclusions> 
15             -->
16         </dependency>
17         <!-- convention-plugin 插件，使用了这个插件之后，就可以采用注解的方式配置 Action -->
18         <dependency>
19             <groupId>org.apache.struts</groupId>
20             <artifactId>struts2-convention-plugin</artifactId>
21             <version>2.3.20</version>
22         </dependency>
23         <!--config-browser-plugin 插件，使用了这个插件之后，就可以很方便的浏览项目中的所有 action 及其与 jsp view 的映射 -->
24         <dependency>
25             <groupId>org.apache.struts</groupId>
26             <artifactId>struts2-config-browser-plugin</artifactId>
27             <version>2.3.20</version>
28         </dependency>
29         <!-- Struts2 和 Spring 整合插件 -->
30         <dependency>
31             <groupId>org.apache.struts</groupId>
32             <artifactId>struts2-spring-plugin</artifactId>
33             <version>2.3.4.1</version>
34         </dependency>

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

在 src/main/resources 目录下创建一个 struts.xml 文件，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

struts.xml 文件中的内容如下：

  1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
 3 <struts>
 4 
 5     <!-- 指定由 spring 负责 action 对象的创建 -->
 6     <constant name="struts.objectFactory" value="spring" />
 7     <!-- 所有匹配 *.action 的请求都由 struts2 处理 -->
 8     <constant name="struts.action.extension" value="action" />
 9     <!-- 是否启用开发模式(开发时设置为 true, 发布到生产环境后设置为 false) -->
10     <constant name="struts.devMode" value="true" />
11     <!-- struts 配置文件改动后，是否重新加载(开发时设置为 true, 发布到生产环境后设置为 false) -->
12     <constant name="struts.configuration.xml.reload" value="true" />
13     <!-- 设置浏览器是否缓存静态内容(开发时设置为 false, 发布到生产环境后设置为 true) -->
14     <constant name="struts.serve.static.browserCache" value="false" />
15     <!-- 请求参数的编码方式 -->
16     <constant name="struts.i18n.encoding" value="utf-8" />
17     <!-- 每次 HTTP 请求系统都重新加载资源文件，有助于开发(开发时设置为 true, 发布到生产环境后设置为 false) -->
18     <constant name="struts.i18n.reload" value="true" />
19     <!-- 文件上传最大值 -->
20     <constant name="struts.multipart.maxSize" value="104857600" />
21     <!-- 让 struts2 支持动态方法调用, 使用叹号访问方法 -->
22     <constant name="struts.enable.DynamicMethodInvocation" value="true" />
23     <!-- Action 名称中是否还是用斜线 -->
24     <constant name="struts.enable.SlashesInActionNames" value="false" />
25     <!-- 允许标签中使用表达式语法 -->
26     <constant name="struts.tag.altSyntax" value="true" />
27     <!-- 对于 WebLogic,Orion,OC4J 此属性应该设置成 true -->
28     <constant name="struts.dispatcher.parametersWorkaround" value="false" />
29 
30     <package name="basePackage" extends="struts-default">
31 
32 
33     </package>
34 
35 </struts>

  1 <!-- Struts2 的核心过滤器配置 -->
 2     <filter>
 3         <filter-name>struts2</filter-name>
 4         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
 5     </filter>
 6     <!-- Struts2 过滤器拦截所有的.action 请求 -->
 7     <filter-mapping>
 8         <filter-name>struts2</filter-name>
 9         <url-pattern>*.action</url-pattern>
10     </filter-mapping>

首先，在 src/main/java 中创建 me.gacl.action 包，在包中编写一个 TestAction 类，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

代码如下：

  1 package me.gacl.action;
 2 
 3 import me.gacl.service.UserServiceI;
 4 
 5 import org.apache.struts2.convention.annotation.Action;
 6 import org.apache.struts2.convention.annotation.Namespace;
 7 import org.apache.struts2.convention.annotation.ParentPackage;
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 
10 @ParentPackage("basePackage")
11 @Action(value="strust2Test")//使用 convention-plugin 插件提供的 @Action 注解将一个普通 java 类标注为一个可以处理用户请求的 Action，Action 的名字为 struts2Test
12 @Namespace("/")//使用 convention-plugin 插件提供的 @Namespace 注解为这个 Action 指定一个命名空间
13 public class TestAction {14     
15     /**
16      * 注入 userService
17      */
18     @Autowired
19     private UserServiceI userService;
20 
21     /**
22      * http://localhost:8080/SSHE/strust2Test!test.action
23      * MethodName: test
24      * Description: 
25      * @author xudp
26      */
27     public void test(){28         System.out.println("进入 TestAction");
29         userService.test();
30     }
31 }

这里使用 @Autowired 注解将 userService 注入到 UserAction 中。

测试 Struts2 的开发环境是否搭建成功，先执行【Maven install】操作, 然后部署到 tomcat 服务器，最后启动 tomcat 服务器运行,

输入访问地址：http://localhost:8080/SSHE/strust2Test!test.action，访问结果如下：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

测试通过，Struts2 的开发环境搭建并整合 Spring 成功! 这里提一下遇到的问题，我执行完 Maven install 命令之后，重新发布到 tomcat 服务器运行，第一次运行时出现了找不到 action 的 404 错误，后来就先执行 Maven clean，然后 clean 一下项目，再执行 Maven install 命令重新编译项目，然后再发布到 tomcat 服务器中运行，这次就可以正常访问到 action 了，使用 Maven 总是会遇到一些奇怪的问题，好在凭借着一些平时积累的解决问题的经验把问题解决了。

1.hibernate-core

在 pom.xml 文件中编写 Hibernate4 所需要的 jar 包，Maven 会自动下载这些包。

 1 <!-- hibernate4 -->
2         <dependency>
3             <groupId>org.hibernate</groupId>
4             <artifactId>hibernate-core</artifactId>
5             <version>4.1.7.Final</version>
6         </dependency>

注意：一定要排除掉 Struts2 中的 Javassist，否则就冲突了。

我们知道，Hibernate 是用于和数据库交互的，应用系统所有的 CRUD 操作都要通过 Hibernate 来完成。既然要连接数据库，那么就要使用到相关的数据库驱动，所以需要加入数据库驱动的 jar 包，根据自身项目使用的数据库在 pom.xml 文件中编写相应的数据库驱动 jar：

MySQL 数据库驱动 jar：

 1 <!-- mysql 驱动包 -->
2         <dependency>
3             <groupId>mysql</groupId>
4             <artifactId>mysql-connector-java</artifactId>
5             <version>5.1.34</version>
6         </dependency>

SQLServer 数据库驱动 jar:

 1 <!-- SQLServer 数据库驱动包 -->
2         <dependency>
3             <groupId>net.sourceforge.jtds</groupId>
4             <artifactId>jtds</artifactId>
5             <version>1.3.1</version>
6         </dependency>

这里要说一下使用 Maven 管理 Oracle JDBC 驱动的问题了，正常情况下，Maven 在下载 oracle 数据库驱动时会出错，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

这是由于 Oracle 授权问题，Maven3 不提供 Oracle JDBC driver，为了在 Maven 项目中应用 Oracle JDBC driver, 必须手动添加到本地仓库。

解决办法：先从网上下载 Oracle 的驱动包，然后通过 Maven 命令放到本地库中去：

安装命令：

mvn install:install-file -Dfile={Path/to/your/ojdbc.jar} -DgroupId=com.oracle -DartifactId=ojdbc6 -Dversion=11.2.0.1.0 -Dpackaging=jar

例如把位于 F:\oracle 驱动 \ojdbc6.jar 添加到本地仓库中

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

执行命令：

mvn install:install-file -Dfile=F:/oracle 驱动 /ojdbc6.jar -DgroupId=com.oracle -DartifactId=ojdbc6 -Dversion=11.2.0.1.0 -Dpackaging=jar

如下图所示：
使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

然后在 pom.xml 文件中编写 ojdbc6.jar 包的 <dependency> 信息，如下所示：

 1 <!--Oracle 数据库驱动包，针对 Oracle11.2 的 ojdbc6.jar -->
2         <dependency>  
3              <groupId>com.oracle</groupId>  
4              <artifactId>ojdbc6</artifactId>  
5              <version>11.2.0.1.0</version>  
6         </dependency>

由于我们已经将 ojdbc6.jar 包加入到本地仓库中了，因此这次可以正常使用针对 Oracle 数据库的驱动包了。如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

在平时开发中，我们一般都会使用数据库连接池，应用系统初始化时，由数据库连接池向数据库申请一定数量的数据库连接，然后放到一个连接池中，当需要操作数据库时，就从数据库连接池中取出一个数据库连接，通过从连接池中获取到的数据库连接对象连接上数据库，然后进行 CRUD 操作，关于数据库连接池的选择，常用的有 DBCP，C3P0 和 Druid，这里我们使用 Druid 作为我们的数据库连接池。这三种连接池各自有各自的特点，自己熟悉哪个就用哪个，萝卜白菜，各有所爱。

在 pom.xml 文件中编写 Druid 的 jar 包，Maven 会自动下载，如下：

 1 <!--Druid 连接池包 -->
2         <dependency>
3             <groupId>com.alibaba</groupId>
4             <artifactId>druid</artifactId>
5             <version>1.0.12</version>
6         </dependency>

使用 Spring 的 aop 时需要使用到 aspectjweaver 包，所以需要添加 aspectjweaver 包，在 pom.xml 文件中添加 aspectjweaver 的 jar 包，Maven 会自动下载，如下：

 1 <!--aspectjweaver 包 -->
2         <dependency>
3             <groupId>org.aspectj</groupId>
4             <artifactId>aspectjweaver</artifactId>
5             <version>1.8.5</version>
6         </dependency>

之前我们在 src/main/resources 目录下创建了一个 config.properties 文件，里面的内容是空的，现在我们就在这个 config.properties 文件中编写连接数据库需要使用到的相关信息，如下所示：

  1 #hibernate.dialect=org.hibernate.dialect.OracleDialect
 2 #driverClassName=oracle.jdbc.driver.OracleDriver
 3 #validationQuery=SELECT 1 FROM DUAL
 4 #jdbc_url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
 5 #jdbc_username=gacl
 6 #jdbc_password=xdp
 7 
 8 hibernate.dialect=org.hibernate.dialect.MySQLDialect
 9 driverClassName=com.mysql.jdbc.Driver
10 validationQuery=SELECT 1
11 jdbc_url=jdbc:mysql://localhost:3306/sshe?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
12 jdbc_username=root
13 jdbc_password=XDP
14 
15 #hibernate.dialect=org.hibernate.dialect.SQLServerDialect
16 #driverClassName=net.sourceforge.jtds.jdbc.Driver
17 #validationQuery=SELECT 1
18 #jdbc_url=jdbc:jtds:sqlserver://127.0.0.1:1433/sshe
19 #jdbc_username=sa
20 #jdbc_password=123456
21 
22 #jndiName=java:comp/env/dataSourceName
23 
24 hibernate.hbm2ddl.auto=update
25 hibernate.show_sql=true
26 hibernate.format_sql=true

在 src/main/resources 目录下新建一个 spring-hibernate.xml 文件，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

spring-hibernate.xml 文件的内容如下：

   1 <?xml version="1.0" encoding="UTF-8"?>
  2 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="  3 http://www.springframework.org/schema/beans 
  4 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
  5 http://www.springframework.org/schema/tx 
  6 http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
  7 http://www.springframework.org/schema/aop 
  8 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
  9 ">
 10 
 11     <!-- JNDI 方式配置数据源 -->
 12     <!-- 
 13     <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
 14          <property name="jndiName" value="${jndiName}"></property> 
 15     </bean> 
 16     -->
 17 
 18     <!-- 配置数据源 -->
 19     <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
 20         <property name="url" value="${jdbc_url}" />
 21         <property name="username" value="${jdbc_username}" />
 22         <property name="password" value="${jdbc_password}" />
 23 
 24         <!-- 初始化连接大小 -->
 25         <property name="initialSize" value="0" />
 26         <!-- 连接池最大使用连接数量 -->
 27         <property name="maxActive" value="20" />
 28         <!-- 连接池最大空闲 -->
 29         <property name="maxIdle" value="20" />
 30         <!-- 连接池最小空闲 -->
 31         <property name="minIdle" value="0" />
 32         <!-- 获取连接最大等待时间 -->
 33         <property name="maxWait" value="60000" />
 34 
 35         <!-- <property name="poolPreparedStatements" value="true" /> <property name="maxPoolPreparedStatementPerConnectionSize" value="33" /> -->
 36 
 37         <property name="validationQuery" value="${validationQuery}" />
 38         <property name="testOnBorrow" value="false" />
 39         <property name="testOnReturn" value="false" />
 40         <property name="testWhileIdle" value="true" />
 41 
 42         <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
 43         <property name="timeBetweenEvictionRunsMillis" value="60000" />
 44         <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
 45         <property name="minEvictableIdleTimeMillis" value="25200000" />
 46 
 47         <!-- 打开 removeAbandoned 功能 -->
 48         <property name="removeAbandoned" value="true" />
 49         <!-- 1800 秒，也就是 30 分钟 -->
 50         <property name="removeAbandonedTimeout" value="1800" />
 51         <!-- 关闭 abanded 连接时输出错误日志 -->
 52         <property name="logAbandoned" value="true" />
 53 
 54         <!-- 监控数据库 -->
 55         <!-- <property name="filters" value="stat" /> -->
 56         <property name="filters" value="mergeStat" />
 57     </bean>
 58 
 59     <!-- 配置 hibernate session 工厂 -->
 60     <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
 61         <property name="dataSource" ref="dataSource" />
 62         <property name="hibernateProperties">
 63             <props>
 64                 <!-- web 项目启动时是否更新表结构 -->
 65                 <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
 66                 <!-- 系统使用的数据库方言，也就是使用的数据库类型 -->
 67                 <prop key="hibernate.dialect">${hibernate.dialect}</prop>
 68                 <!-- 是否打印 Hibernate 生成的 SQL 到控制台 -->
 69                 <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
 70                 <!-- 是否格式化打印出来的 SQL -->
 71                 <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
 72             </props>
 73         </property>
 74 
 75         <!-- 自动扫描注解方式配置的 hibernate 类文件 -->
 76         <property name="packagesToScan">
 77             <list>
 78                 <value>me.gacl.model</value>
 79             </list>
 80         </property>
 81 
 82         <!-- 自动扫描 hbm 方式配置的 hibernate 文件和.hbm 文件 -->
 83         <!-- 
 84         <property name="mappingDirectoryLocations">
 85             <list>
 86                 <value>classpath:me/gacl/model/hbm</value>
 87             </list>
 88         </property>
 89          -->
 90     </bean>
 91 
 92     <!-- 配置事务管理器 -->
 93     <bean name="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
 94         <property name="sessionFactory" ref="sessionFactory"></property>
 95     </bean>
 96 
 97     <!-- 注解方式配置事物 -->
 98     <!-- <tx:annotation-driven transaction-manager="transactionManager" /> -->
 99 
100     <!-- 拦截器方式配置事物 -->
101     <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
102         <tx:attributes>
103             <!-- 以如下关键字开头的方法使用事物 -->
104             <tx:method name="add*" />
105             <tx:method name="save*" />
106             <tx:method name="update*" />
107             <tx:method name="modify*" />
108             <tx:method name="edit*" />
109             <tx:method name="delete*" />
110             <tx:method name="remove*" />
111             <tx:method name="repair" />
112             <tx:method name="deleteAndRepair" />
113             <!-- 以如下关键字开头的方法不使用事物 -->
114             <tx:method name="get*" propagation="SUPPORTS" />
115             <tx:method name="find*" propagation="SUPPORTS" />
116             <tx:method name="load*" propagation="SUPPORTS" />
117             <tx:method name="search*" propagation="SUPPORTS" />
118             <tx:method name="datagrid*" propagation="SUPPORTS" />
119             <!-- 其他方法不使用事物 -->
120             <tx:method name="*" propagation="SUPPORTS" />
121         </tx:attributes>
122     </tx:advice>
123     <!-- 切面，将事物用在哪些对象上 -->
124     <aop:config>
125         <aop:pointcut id="transactionPointcut" expression="execution(* me.gacl.service..*Impl.*(..))" />
126         <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />
127     </aop:config>
128     
129 </beans>

1、在 MySQL 中创建 sshe 数据库

SQL 脚本：

CREATE DATABASE SSHE;

2、在 src/main/java 中创建 me.gac.model 包，在包中编写一个 User 类，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

代码如下：

  1 package me.gacl.model;
 2 
 3 import java.util.Date;
 4 
 5 import javax.persistence.Column;
 6 import javax.persistence.Entity;
 7 import javax.persistence.Id;
 8 import javax.persistence.Table;
 9 import javax.persistence.Temporal;
10 import javax.persistence.TemporalType;
11 
12 @Entity
13 @Table(name = "T_USER", schema = "SSHE")
14 public class User implements java.io.Serializable {15 
16     // Fields
17     private String id;
18     private String name;
19     private String pwd;
20     private Date createdatetime;
21     private Date modifydatetime;
22 
23     // Constructors
24 
25     /** default constructor */
26     public User() {27     }
28 
29     /** minimal constructor */
30     public User(String id, String name, String pwd) {31         this.id = id;
32         this.name = name;
33         this.pwd = pwd;
34     }
35 
36     /** full constructor */
37     public User(String id, String name, String pwd, Date createdatetime, Date modifydatetime) {38         this.id = id;
39         this.name = name;
40         this.pwd = pwd;
41         this.createdatetime = createdatetime;
42         this.modifydatetime = modifydatetime;
43     }
44 
45     // Property accessors
46     @Id
47     @Column(name = "ID", unique = true, nullable = false, length = 36)
48     public String getId() {49         return this.id;
50     }
51 
52     public void setId(String id) {53         this.id = id;
54     }
55 
56     @Column(name = "NAME",nullable = false, length = 100)
57     public String getName() {58         return this.name;
59     }
60 
61     public void setName(String name) {62         this.name = name;
63     }
64 
65     @Column(name = "PWD", nullable = false, length = 32)
66     public String getPwd() {67         return this.pwd;
68     }
69 
70     public void setPwd(String pwd) {71         this.pwd = pwd;
72     }
73 
74     @Temporal(TemporalType.TIMESTAMP)
75     @Column(name = "CREATEDATETIME", length = 7)
76     public Date getCreatedatetime() {77         return this.createdatetime;
78     }
79 
80     public void setCreatedatetime(Date createdatetime) {81         this.createdatetime = createdatetime;
82     }
83 
84     @Temporal(TemporalType.TIMESTAMP)
85     @Column(name = "MODIFYDATETIME", length = 7)
86     public Date getModifydatetime() {87         return this.modifydatetime;
88     }
89 
90     public void setModifydatetime(Date modifydatetime) {91         this.modifydatetime = modifydatetime;
92     }
93 }

3、在 src/main/java 中创建 me.gacl.dao 包，在包中编写一个 UserDaoI 接口，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

代码如下：

  1 package me.gacl.dao;
 2 
 3 import java.io.Serializable;
 4 
 5 import me.gacl.model.User;
 6 
 7 public interface UserDaoI { 8 
 9     /**
10      * 保存用户
11      * @param user
12      * @return
13      */
14     Serializable save(User user); 
15 }

在 src/main/java 中创建 me.gacl.dao.impl 包，在包中编写 UserDaoImpl 实现类，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

代码如下：

  1 package me.gacl.dao.impl;
 2 
 3 import java.io.Serializable;
 4 
 5 import org.hibernate.SessionFactory;
 6 import org.springframework.beans.factory.annotation.Autowired;
 7 import org.springframework.stereotype.Repository;
 8 
 9 import me.gacl.dao.UserDaoI;
10 import me.gacl.model.User;
11 
12 @Repository("userDao")
13 public class UserDaoImpl implements UserDaoI {14     
15     /**
16      * 使用 @Autowired 注解将 sessionFactory 注入到 UserDaoImpl 中
17      */
18     @Autowired
19     private SessionFactory sessionFactory;
20     
21     @Override
22     public Serializable save(User user) {23         return sessionFactory.getCurrentSession().save(user);
24     }
25 }

这里使用 @Repository(“userDao”)注解完成 dao 注入，使用 @Autowired 注解将 sessionFactory 注入到 UserDaoImpl 中。

4、在之前创建好的 UserServiceI 接口中添加一个 save 方法的定义，如下：

  1 package me.gacl.service;
 2 
 3 import java.io.Serializable;
 4 import me.gacl.model.User;
 5 
 6 /**
 7  * 测试
 8  * @author gacl
 9  *
10  */
11 public interface UserServiceI {12 
13     /**
14      * 测试方法
15      */
16     void test();
17     
18     /**
19      * 保存用户
20      * @param user
21      * @return
22      */
23     Serializable save(User user); 
24 }

5、在 UserServiceImpl 类中实现 save 方法，如下：

  1 package me.gacl.service.impl;
 2 
 3 import java.io.Serializable;
 4 
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.stereotype.Service;
 7 
 8 import me.gacl.dao.UserDaoI;
 9 import me.gacl.model.User;
10 import me.gacl.service.UserServiceI;
11 //使用 Spring 提供的 @Service 注解将 UserServiceImpl 标注为一个 Service
12 @Service("userService")
13 public class UserServiceImpl implements UserServiceI {14 
15     /**
16      * 注入 userDao
17      */
18     @Autowired
19     private UserDaoI userDao;
20     
21     @Override
22     public void test() {23         System.out.println("Hello World!");
24     }
25 
26     @Override
27     public Serializable save(User user) {28         return userDao.save(user);
29     }
30 }

6、在 src/main/test 下的 me.gacl.test 包中编写 TestHibernate 类，代码如下：

  1 package me.gacl.test;
 2 
 3 import java.util.Date;
 4 import java.util.UUID;
 5 
 6 import me.gacl.model.User;
 7 import me.gacl.service.UserServiceI;
 8 
 9 import org.junit.Before;
10 import org.junit.Test;
11 import org.springframework.context.ApplicationContext;
12 import org.springframework.context.support.ClassPathXmlApplicationContext;
13 
14 public class TestHibernate {15 
16     private UserServiceI userService;
17     
18     /**
19      * 这个 before 方法在所有的测试方法之前执行，并且只执行一次
20      * 所有做 Junit 单元测试时一些初始化工作可以在这个方法里面进行
21      * 比如在 before 方法里面初始化 ApplicationContext 和 userService
22      */
23     @Before
24     public void before(){25         ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
26         userService = (UserServiceI) ac.getBean("userService");
27     }
28     
29     @Test
30     public void testSaveMethod(){31         //ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
32         //UserServiceI userService = (UserServiceI) ac.getBean("userService");
33         User user = new User();
34         user.setId(UUID.randomUUID().toString().replaceAll("-", ""));
35         user.setName("孤傲苍狼");
36         user.setPwd("123");
37         user.setCreatedatetime(new Date()); 
38         userService.save(user);
39     }
40 }

执行 Junit 单元测试，如下所示：
使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

测试通过，再看看 sshe 数据库，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

Hibernate 在执行过程中，先帮我们在 sshe 数据库中创建一张 t_user 表，t_user 的表结构根据 User 实体类中的属性定义来创建的，然后再将数据插入到 t_user 表中，如下图所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

到此，Hibernate4 开发环境的搭建并且与 Spring 整合的工作算是全部完成并且测试通过了。

经过前面的四大步骤，我们已经成功地搭建好基于 struts2+hibernate4+spring3 这三大框架的整合开发环境，下面我们来综合测试一下三大框架配合使用进行开发的效果。

  1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app version="3.0" xmlns="http://Java.sun.com/xml/ns/javaee"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
 5     http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
 6     <display-name></display-name>
 7     <welcome-file-list>
 8         <welcome-file>index.jsp</welcome-file>
 9     </welcome-file-list>
10 
11     <!-- Spring 监听器 -->
12     <listener>
13         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
14     </listener>
15     <!-- Spring 配置文件位置 -->
16     <context-param>
17         <param-name>contextConfigLocation</param-name>
18         <param-value>classpath:spring.xml,classpath:spring-hibernate.xml</param-value>
19     </context-param>
20     
21     <!-- 防止 spring 内存溢出监听器 -->
22     <listener>
23         <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
24     </listener>
25     
26     <!-- openSessionInView 配置 -->
27     <filter>
28         <filter-name>openSessionInViewFilter</filter-name>
29         <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
30         <init-param>
31             <param-name>singleSession</param-name>
32             <param-value>true</param-value>
33         </init-param>
34     </filter>
35     <filter-mapping>
36         <filter-name>openSessionInViewFilter</filter-name>
37         <url-pattern>*.action</url-pattern>
38     </filter-mapping>
39     
40     <!-- Struts2 的核心过滤器配置 -->
41     <filter>
42         <filter-name>struts2</filter-name>
43         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
44     </filter>
45     <!-- Struts2 过滤器拦截所有的.action 请求 -->
46     <filter-mapping>
47         <filter-name>struts2</filter-name>
48         <url-pattern>*.action</url-pattern>
49     </filter-mapping>
50     
51     <!-- druid 监控页面，使用 ${pageContext.request.contextPath}/druid/index.html 访问 -->
52     <servlet>
53         <servlet-name>druidStatView</servlet-name>
54         <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
55     </servlet>
56     <servlet-mapping>
57         <servlet-name>druidStatView</servlet-name>
58         <url-pattern>/druid/*</url-pattern>
59     </servlet-mapping>
60 </web-app>

在 TestAction 类中添加一个 saveUser 方法，如下：

  1 package me.gacl.action;
 2 
 3 import java.util.Date;
 4 import java.util.UUID;
 5 
 6 import me.gacl.model.User;
 7 import me.gacl.service.UserServiceI;
 8 
 9 import org.apache.struts2.convention.annotation.Action;
10 import org.apache.struts2.convention.annotation.Namespace;
11 import org.apache.struts2.convention.annotation.ParentPackage;
12 import org.springframework.beans.factory.annotation.Autowired;
13 
14 @ParentPackage("basePackage")
15 @Action(value="strust2Test")//使用 convention-plugin 插件提供的 @Action 注解将一个普通 java 类标注为一个可以处理用户请求的 Action
16 @Namespace("/")//使用 convention-plugin 插件提供的 @Namespace 注解为这个 Action 指定一个命名空间
17 public class TestAction {18     
19     /**
20      * 注入 userService
21      */
22     @Autowired
23     private UserServiceI userService;
24 
25     /**
26      * http://localhost:8080/SSHE/strust2Test!test.action
27      * MethodName: test
28      * Description: 
29      * @author xudp
30      */
31     public void test(){32         System.out.println("进入 TestAction");
33         userService.test();
34     }
35     
36     /**
37      * http://localhost:8080/SSHE/strust2Test!saveUser.action
38      */
39     public void saveUser(){40         User user = new User();
41         user.setId(UUID.randomUUID().toString().replaceAll("-", ""));
42         user.setName("xdp 孤傲苍狼");
43         user.setPwd("123456");
44         user.setCreatedatetime(new Date()); 
45         userService.save(user);
46     }
47 }

执行【Maven install】操作，重新编译和发布项目，在执行【Maven install】操作之前，需要修改 TestSpring 这个测试类中的 test 方法的代码，如下：

  1 package me.gacl.test;
 2 
 3 import me.gacl.service.UserServiceI;
 4 
 5 import org.junit.Test;
 6 import org.springframework.context.ApplicationContext;
 7 import org.springframework.context.support.ClassPathXmlApplicationContext;
 8 
 9 public class TestSpring {10 
11     @Test
12     public void test(){13         //通过 spring.xml 配置文件创建 Spring 的应用程序上下文环境
14         //ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring.xml");
15         /**
16          * 因为已经整合了 Hibernate，UserServiceImpl 类中使用到了 userDao，17          *userDao 是由 spring 创建并且注入给 UserServiceImpl 类的，而 userDao 中又使用到了 sessionFactory 对象
18          * 而创建 sessionFactory 对象时需要使用到 spring-hibernate.xml 这个配置文件中的配置项信息，19          * 所以创建 Spring 的应用程序上下文环境时，需要同时使用 spring.xml 和 spring-hibernate.xml 这两个配置文件
20          * 否则在执行 Maven install 命令时，因为 maven 会先执行 test 方法中的代码，而代码执行到
21          *UserServiceI userService = (UserServiceI) ac.getBean("userService");
22          * 这一行时就会因为 userDao 中使用到 sessionFactory 对象无法正常创建的而出错，这样执行 Maven install 命令编译项目时就会失败！23          *
24          */
25         ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
26         //从 Spring 的 IOC 容器中获取 bean 对象
27         UserServiceI userService = (UserServiceI) ac.getBean("userService");
28         //执行测试方法
29         userService.test();
30     }
31 }

每次执行【Maven install】命令时都会执行 Junit 单元测试中的代码有时候感觉挺累赘的，有时候往往就是因为一些单元测试中的代码导致【Maven install】命令编译项目失败！

将编译好的项目部署到 tomcat 服务器中运行，输入地址：http://localhost:8080/SSHE/strust2Test!saveUser.action 进行访问，如下所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

访问 action 的过程中没有出现错误，并且后台也没有报错并且打印出了 Hibernate 执行插入操作时的 SQL 语句，如下所示：

使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境

这说明三大框架整合开发的测试通过了。以上就是使用使用 Maven 搭建 Struts2+Spring3+Hibernate4 的整合开发环境的全部内容。

使用Maven搭建Struts2+Spring3+Hibernate4的整合开发环境

一、建立 Maven 工程

二、搭建 Spring3 开发环境

2.1、下载 Spring3 需要的 jar 包

2.2、编写 Spring 配置文件

2.3、编写单元测试

2.4、在 web.xml 中配置 Spring 监听器

一、建立 Maven 工程

三、搭建 Struts2 开发环境并整合 Spring3

3.1、下载 Struts2 需要的 jar 包

3.2、编写 Struts.xml 配置文件

3.3、在 web.xml 中配置 Struts2 的过滤器

3.4、编写测试

四、搭建 Hibernate4 开发环境并整合 Spring3

4.1、下载 Hibernate4 需要的 jar 包

4.2、添加数据库驱动 jar 包

4.3、添加数据库连接池 jar 包

4.4、添加 aspectjweaver 包

4.5、编写连接数据库的配置信息

4.6、编写 Hibernate 与 Spring 整合的配置文件

4.7、编写单元测试代码

五、三大框架综合测试

5.1、完善 web.xml 文件中的配置

5.2、编写测试代码

开源堡垒机JumpServer配置教程：使用步骤与配置

申请腾讯混元的API Key并且使用LobeChat调用混元AI

【开源安全保护】如何安装JumpServer堡垒机

基于Docker快速搭建一个开源的IT人员在线工具箱-it-tools

Docker部署搭建一个开源强大的图书管理系统

查看linux中所有用户的三种方式

Linux学习准备工作

第一节：Bash编程易犯的错误

如何安装官方ChatGPT桌面软件，支持Windows和MacOS系统

网络管理员必备命令

	1 <!-- spring3 -->
	2 <dependency>
	3 <groupId>org.springframework</groupId>
	4 <artifactId>spring-core</artifactId>
	5 <version>3.1.2.RELEASE</version>
	6 </dependency>
	7 <dependency>
	8 <groupId>org.springframework</groupId>
	9 <artifactId>spring-context</artifactId>
	10 <version>3.1.2.RELEASE</version>
	11 </dependency>
	12 <dependency>
	13 <groupId>org.springframework</groupId>
	14 <artifactId>spring-jdbc</artifactId>
	15 <version>3.1.2.RELEASE</version>
	16 </dependency>
	17 <dependency>
	18 <groupId>org.springframework</groupId>
	19 <artifactId>spring-beans</artifactId>
	20 <version>3.1.2.RELEASE</version>
	21 </dependency>
	22 <dependency>
	23 <groupId>org.springframework</groupId>
	24 <artifactId>spring-web</artifactId>
	25 <version>3.1.2.RELEASE</version>
	26 </dependency>
	27 <dependency>
	28 <groupId>org.springframework</groupId>
	29 <artifactId>spring-expression</artifactId>
	30 <version>3.1.2.RELEASE</version>
	31 </dependency>
	32 <dependency>
	33 <groupId>org.springframework</groupId>
	34 <artifactId>spring-orm</artifactId>
	35 <version>3.1.2.RELEASE</version>
	36 </dependency>

	1 <?xml version="1.0" encoding="UTF-8"?>
	2 <beans xmlns="http://www.springframework.org/schema/beans"
	3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	4 xmlns:context="http://www.springframework.org/schema/context"
	5 xsi:schemaLocation="http://www.springframework.org/schema/beans
	6 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	7 http://www.springframework.org/schema/context
	8 http://www.springframework.org/schema/context/spring-context-3.0.xsd
	9 ">
	10
	11 <!-- 引入属性文件,config.properties 位于 src/main/resources 目录下 -->
	12 <context:property-placeholder location="classpath:config.properties" />
	13
	14 <!-- 自动扫描 dao 和 service 包(自动注入) -->
	15 <context:component-scan base-package="me.gacl.dao,me.gacl.service" />
	16
	17 </beans>

	1 package me.gacl.service;
	2
	3 /**
	4 * 测试
	5 * @author gacl
	6 *
	7 */
	8 public interface UserServiceI { 9
	10 /**
	11 * 测试方法
	12 */
	13 void test();
	14 }

	1 package me.gacl.service.impl;
	2
	3 import org.springframework.stereotype.Service;
	4
	5 import me.gacl.service.UserServiceI;
	6 //使用 Spring 提供的 @Service 注解将 UserServiceImpl 标注为一个 Service
	7 @Service("userService")
	8 public class UserServiceImpl implements UserServiceI { 9
	10 @Override
	11 public void test() {12 System.out.println("Hello World!");
	13 }
	14
	15 }

	1 <!-- Junit -->
	2 <dependency>
	3 <groupId>junit</groupId>
	4 <artifactId>junit</artifactId>
	5 <version>4.12</version>
	6 <scope>test</scope>
	7 </dependency>

	1 package me.gacl.test;
	2
	3 import me.gacl.service.UserServiceI;
	4
	5 import org.junit.Test;
	6 import org.springframework.context.ApplicationContext;
	7 import org.springframework.context.support.ClassPathXmlApplicationContext;
	8
	9 public class TestSpring {10
	11 @Test
	12 public void test(){13 //通过 spring.xml 配置文件创建 Spring 的应用程序上下文环境
	14 ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring.xml");
	15 //从 Spring 的 IOC 容器中获取 bean 对象
	16 UserServiceI userService = (UserServiceI) ac.getBean("userService");
	17 //执行测试方法
	18 userService.test();
	19 }
	20 }

	1 <!-- Spring 监听器 -->
	2 <listener>
	3 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	4 </listener>
	5 <!-- Spring 配置文件位置 -->
	6 <context-param>
	7 <param-name>contextConfigLocation</param-name>
	8 <param-value>classpath:spring.xml</param-value>
	9 </context-param>

	1 <!-- Struts2 的核心包 -->
	2 <dependency>
	3 <groupId>org.apache.struts</groupId>
	4 <artifactId>struts2-core</artifactId>
	5 <version>2.3.16</version>
	6 <!--
	7 这里的 exclusions 是排除包，因为 Struts2 中有 Javassist，Hibernate 中也有 javassist,
	8 所以如果要整合 Hibernate，一定要排除掉 Struts2 中的 javassist，否则就冲突了。 9 <exclusions>
	10 <exclusion>
	11 <groupId>javassist</groupId>
	12 <artifactId>javassist</artifactId>
	13 </exclusion>
	14 </exclusions>
	15 -->
	16 </dependency>
	17 <!-- convention-plugin 插件，使用了这个插件之后，就可以采用注解的方式配置 Action -->
	18 <dependency>
	19 <groupId>org.apache.struts</groupId>
	20 <artifactId>struts2-convention-plugin</artifactId>
	21 <version>2.3.20</version>
	22 </dependency>
	23 <!--config-browser-plugin 插件，使用了这个插件之后，就可以很方便的浏览项目中的所有 action 及其与 jsp view 的映射 -->
	24 <dependency>
	25 <groupId>org.apache.struts</groupId>
	26 <artifactId>struts2-config-browser-plugin</artifactId>
	27 <version>2.3.20</version>
	28 </dependency>
	29 <!-- Struts2 和 Spring 整合插件 -->
	30 <dependency>
	31 <groupId>org.apache.struts</groupId>
	32 <artifactId>struts2-spring-plugin</artifactId>
	33 <version>2.3.4.1</version>
	34 </dependency>

	1 <?xml version="1.0" encoding="UTF-8"?>
	2 <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
	3 <struts>
	4
	5 <!-- 指定由 spring 负责 action 对象的创建 -->
	6 <constant name="struts.objectFactory" value="spring" />
	7 <!-- 所有匹配 *.action 的请求都由 struts2 处理 -->
	8 <constant name="struts.action.extension" value="action" />
	9 <!-- 是否启用开发模式(开发时设置为 true, 发布到生产环境后设置为 false) -->
	10 <constant name="struts.devMode" value="true" />
	11 <!-- struts 配置文件改动后，是否重新加载(开发时设置为 true, 发布到生产环境后设置为 false) -->
	12 <constant name="struts.configuration.xml.reload" value="true" />
	13 <!-- 设置浏览器是否缓存静态内容(开发时设置为 false, 发布到生产环境后设置为 true) -->
	14 <constant name="struts.serve.static.browserCache" value="false" />
	15 <!-- 请求参数的编码方式 -->
	16 <constant name="struts.i18n.encoding" value="utf-8" />
	17 <!-- 每次 HTTP 请求系统都重新加载资源文件，有助于开发(开发时设置为 true, 发布到生产环境后设置为 false) -->
	18 <constant name="struts.i18n.reload" value="true" />
	19 <!-- 文件上传最大值 -->
	20 <constant name="struts.multipart.maxSize" value="104857600" />
	21 <!-- 让 struts2 支持动态方法调用, 使用叹号访问方法 -->
	22 <constant name="struts.enable.DynamicMethodInvocation" value="true" />
	23 <!-- Action 名称中是否还是用斜线 -->
	24 <constant name="struts.enable.SlashesInActionNames" value="false" />
	25 <!-- 允许标签中使用表达式语法 -->
	26 <constant name="struts.tag.altSyntax" value="true" />
	27 <!-- 对于 WebLogic,Orion,OC4J 此属性应该设置成 true -->
	28 <constant name="struts.dispatcher.parametersWorkaround" value="false" />
	29
	30 <package name="basePackage" extends="struts-default">
	31
	32
	33 </package>
	34
	35 </struts>

	1 <!-- Struts2 的核心过滤器配置 -->
	2 <filter>
	3 <filter-name>struts2</filter-name>
	4 <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
	5 </filter>
	6 <!-- Struts2 过滤器拦截所有的.action 请求 -->
	7 <filter-mapping>
	8 <filter-name>struts2</filter-name>
	9 <url-pattern>*.action</url-pattern>
	10 </filter-mapping>

	1 package me.gacl.action;
	2
	3 import me.gacl.service.UserServiceI;
	4
	5 import org.apache.struts2.convention.annotation.Action;
	6 import org.apache.struts2.convention.annotation.Namespace;
	7 import org.apache.struts2.convention.annotation.ParentPackage;
	8 import org.springframework.beans.factory.annotation.Autowired;
	9
	10 @ParentPackage("basePackage")
	11 @Action(value="strust2Test")//使用 convention-plugin 插件提供的 @Action 注解将一个普通 java 类标注为一个可以处理用户请求的 Action，Action 的名字为 struts2Test
	12 @Namespace("/")//使用 convention-plugin 插件提供的 @Namespace 注解为这个 Action 指定一个命名空间
	13 public class TestAction {14
	15 /**
	16 * 注入 userService
	17 */
	18 @Autowired
	19 private UserServiceI userService;
	20
	21 /**
	22 * http://localhost:8080/SSHE/strust2Test!test.action
	23 * MethodName: test
	24 * Description:
	25 * @author xudp
	26 */
	27 public void test(){28 System.out.println("进入 TestAction");
	29 userService.test();
	30 }
	31 }

	1 <!-- hibernate4 -->
	2 <dependency>
	3 <groupId>org.hibernate</groupId>
	4 <artifactId>hibernate-core</artifactId>
	5 <version>4.1.7.Final</version>
	6 </dependency>

	1 <!-- mysql 驱动包 -->
	2 <dependency>
	3 <groupId>mysql</groupId>
	4 <artifactId>mysql-connector-java</artifactId>
	5 <version>5.1.34</version>
	6 </dependency>

	1 <!-- SQLServer 数据库驱动包 -->
	2 <dependency>
	3 <groupId>net.sourceforge.jtds</groupId>
	4 <artifactId>jtds</artifactId>
	5 <version>1.3.1</version>
	6 </dependency>

	1 <!--Oracle 数据库驱动包，针对 Oracle11.2 的 ojdbc6.jar -->
	2 <dependency>
	3 <groupId>com.oracle</groupId>
	4 <artifactId>ojdbc6</artifactId>
	5 <version>11.2.0.1.0</version>
	6 </dependency>

	1 <!--Druid 连接池包 -->
	2 <dependency>
	3 <groupId>com.alibaba</groupId>
	4 <artifactId>druid</artifactId>
	5 <version>1.0.12</version>
	6 </dependency>

	1 <!--aspectjweaver 包 -->
	2 <dependency>
	3 <groupId>org.aspectj</groupId>
	4 <artifactId>aspectjweaver</artifactId>
	5 <version>1.8.5</version>
	6 </dependency>

	1 #hibernate.dialect=org.hibernate.dialect.OracleDialect
	2 #driverClassName=oracle.jdbc.driver.OracleDriver
	3 #validationQuery=SELECT 1 FROM DUAL
	4 #jdbc_url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
	5 #jdbc_username=gacl
	6 #jdbc_password=xdp
	7
	8 hibernate.dialect=org.hibernate.dialect.MySQLDialect
	9 driverClassName=com.mysql.jdbc.Driver
	10 validationQuery=SELECT 1
	11 jdbc_url=jdbc:mysql://localhost:3306/sshe?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
	12 jdbc_username=root
	13 jdbc_password=XDP
	14
	15 #hibernate.dialect=org.hibernate.dialect.SQLServerDialect
	16 #driverClassName=net.sourceforge.jtds.jdbc.Driver
	17 #validationQuery=SELECT 1
	18 #jdbc_url=jdbc:jtds:sqlserver://127.0.0.1:1433/sshe
	19 #jdbc_username=sa
	20 #jdbc_password=123456
	21
	22 #jndiName=java:comp/env/dataSourceName
	23
	24 hibernate.hbm2ddl.auto=update
	25 hibernate.show_sql=true
	26 hibernate.format_sql=true

	1 <?xml version="1.0" encoding="UTF-8"?>
	2 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" 3 http://www.springframework.org/schema/beans
	4 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	5 http://www.springframework.org/schema/tx
	6 http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
	7 http://www.springframework.org/schema/aop
	8 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
	9 ">
	10
	11 <!-- JNDI 方式配置数据源 -->
	12 <!--
	13 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
	14 <property name="jndiName" value="${jndiName}"></property>
	15 </bean>
	16 -->
	17
	18 <!-- 配置数据源 -->
	19 <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
	20 <property name="url" value="${jdbc_url}" />
	21 <property name="username" value="${jdbc_username}" />
	22 <property name="password" value="${jdbc_password}" />
	23
	24 <!-- 初始化连接大小 -->
	25 <property name="initialSize" value="0" />
	26 <!-- 连接池最大使用连接数量 -->
	27 <property name="maxActive" value="20" />
	28 <!-- 连接池最大空闲 -->
	29 <property name="maxIdle" value="20" />
	30 <!-- 连接池最小空闲 -->
	31 <property name="minIdle" value="0" />
	32 <!-- 获取连接最大等待时间 -->
	33 <property name="maxWait" value="60000" />
	34
	35 <!-- <property name="poolPreparedStatements" value="true" /> <property name="maxPoolPreparedStatementPerConnectionSize" value="33" /> -->
	36
	37 <property name="validationQuery" value="${validationQuery}" />
	38 <property name="testOnBorrow" value="false" />
	39 <property name="testOnReturn" value="false" />
	40 <property name="testWhileIdle" value="true" />
	41
	42 <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
	43 <property name="timeBetweenEvictionRunsMillis" value="60000" />
	44 <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
	45 <property name="minEvictableIdleTimeMillis" value="25200000" />
	46
	47 <!-- 打开 removeAbandoned 功能 -->
	48 <property name="removeAbandoned" value="true" />
	49 <!-- 1800 秒，也就是 30 分钟 -->
	50 <property name="removeAbandonedTimeout" value="1800" />
	51 <!-- 关闭 abanded 连接时输出错误日志 -->
	52 <property name="logAbandoned" value="true" />
	53
	54 <!-- 监控数据库 -->
	55 <!-- <property name="filters" value="stat" /> -->
	56 <property name="filters" value="mergeStat" />
	57 </bean>
	58
	59 <!-- 配置 hibernate session 工厂 -->
	60 <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
	61 <property name="dataSource" ref="dataSource" />
	62 <property name="hibernateProperties">
	63 <props>
	64 <!-- web 项目启动时是否更新表结构 -->
	65 <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
	66 <!-- 系统使用的数据库方言，也就是使用的数据库类型 -->
	67 <prop key="hibernate.dialect">${hibernate.dialect}</prop>
	68 <!-- 是否打印 Hibernate 生成的 SQL 到控制台 -->
	69 <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
	70 <!-- 是否格式化打印出来的 SQL -->
	71 <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
	72 </props>
	73 </property>
	74
	75 <!-- 自动扫描注解方式配置的 hibernate 类文件 -->
	76 <property name="packagesToScan">
	77 <list>
	78 <value>me.gacl.model</value>
	79 </list>
	80 </property>
	81
	82 <!-- 自动扫描 hbm 方式配置的 hibernate 文件和.hbm 文件 -->
	83 <!--
	84 <property name="mappingDirectoryLocations">
	85 <list>
	86 <value>classpath:me/gacl/model/hbm</value>
	87 </list>
	88 </property>
	89 -->
	90 </bean>
	91
	92 <!-- 配置事务管理器 -->
	93 <bean name="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
	94 <property name="sessionFactory" ref="sessionFactory"></property>
	95 </bean>
	96
	97 <!-- 注解方式配置事物 -->
	98 <!-- <tx:annotation-driven transaction-manager="transactionManager" /> -->
	99
	100 <!-- 拦截器方式配置事物 -->
	101 <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
	102 <tx:attributes>
	103 <!-- 以如下关键字开头的方法使用事物 -->
	104 <tx:method name="add*" />
	105 <tx:method name="save*" />
	106 <tx:method name="update*" />
	107 <tx:method name="modify*" />
	108 <tx:method name="edit*" />
	109 <tx:method name="delete*" />
	110 <tx:method name="remove*" />
	111 <tx:method name="repair" />
	112 <tx:method name="deleteAndRepair" />
	113 <!-- 以如下关键字开头的方法不使用事物 -->
	114 <tx:method name="get*" propagation="SUPPORTS" />
	115 <tx:method name="find*" propagation="SUPPORTS" />
	116 <tx:method name="load*" propagation="SUPPORTS" />
	117 <tx:method name="search*" propagation="SUPPORTS" />
	118 <tx:method name="datagrid*" propagation="SUPPORTS" />
	119 <!-- 其他方法不使用事物 -->
	120 <tx:method name="*" propagation="SUPPORTS" />
	121 </tx:attributes>
	122 </tx:advice>
	123 <!-- 切面，将事物用在哪些对象上 -->
	124 <aop:config>
	125 <aop:pointcut id="transactionPointcut" expression="execution(* me.gacl.service..Impl.(..))" />
	126 <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />
	127 </aop:config>
	128
	129 </beans>

	1 package me.gacl.model;
	2
	3 import java.util.Date;
	4
	5 import javax.persistence.Column;
	6 import javax.persistence.Entity;
	7 import javax.persistence.Id;
	8 import javax.persistence.Table;
	9 import javax.persistence.Temporal;
	10 import javax.persistence.TemporalType;
	11
	12 @Entity
	13 @Table(name = "T_USER", schema = "SSHE")
	14 public class User implements java.io.Serializable {15
	16 // Fields
	17 private String id;
	18 private String name;
	19 private String pwd;
	20 private Date createdatetime;
	21 private Date modifydatetime;
	22
	23 // Constructors
	24
	25 /** default constructor */
	26 public User() {27 }
	28
	29 /** minimal constructor */
	30 public User(String id, String name, String pwd) {31 this.id = id;
	32 this.name = name;
	33 this.pwd = pwd;
	34 }
	35
	36 /** full constructor */
	37 public User(String id, String name, String pwd, Date createdatetime, Date modifydatetime) {38 this.id = id;
	39 this.name = name;
	40 this.pwd = pwd;
	41 this.createdatetime = createdatetime;
	42 this.modifydatetime = modifydatetime;
	43 }
	44
	45 // Property accessors
	46 @Id
	47 @Column(name = "ID", unique = true, nullable = false, length = 36)
	48 public String getId() {49 return this.id;
	50 }
	51
	52 public void setId(String id) {53 this.id = id;
	54 }
	55
	56 @Column(name = "NAME",nullable = false, length = 100)
	57 public String getName() {58 return this.name;
	59 }
	60
	61 public void setName(String name) {62 this.name = name;
	63 }
	64
	65 @Column(name = "PWD", nullable = false, length = 32)
	66 public String getPwd() {67 return this.pwd;
	68 }
	69
	70 public void setPwd(String pwd) {71 this.pwd = pwd;
	72 }
	73
	74 @Temporal(TemporalType.TIMESTAMP)
	75 @Column(name = "CREATEDATETIME", length = 7)
	76 public Date getCreatedatetime() {77 return this.createdatetime;
	78 }
	79
	80 public void setCreatedatetime(Date createdatetime) {81 this.createdatetime = createdatetime;
	82 }
	83
	84 @Temporal(TemporalType.TIMESTAMP)
	85 @Column(name = "MODIFYDATETIME", length = 7)
	86 public Date getModifydatetime() {87 return this.modifydatetime;
	88 }
	89
	90 public void setModifydatetime(Date modifydatetime) {91 this.modifydatetime = modifydatetime;
	92 }
	93 }

	1 package me.gacl.dao;
	2
	3 import java.io.Serializable;
	4
	5 import me.gacl.model.User;
	6
	7 public interface UserDaoI { 8
	9 /**
	10 * 保存用户
	11 * @param user
	12 * @return
	13 */
	14 Serializable save(User user);
	15 }

	1 package me.gacl.dao.impl;
	2
	3 import java.io.Serializable;
	4
	5 import org.hibernate.SessionFactory;
	6 import org.springframework.beans.factory.annotation.Autowired;
	7 import org.springframework.stereotype.Repository;
	8
	9 import me.gacl.dao.UserDaoI;
	10 import me.gacl.model.User;
	11
	12 @Repository("userDao")
	13 public class UserDaoImpl implements UserDaoI {14
	15 /**
	16 * 使用 @Autowired 注解将 sessionFactory 注入到 UserDaoImpl 中
	17 */
	18 @Autowired
	19 private SessionFactory sessionFactory;
	20
	21 @Override
	22 public Serializable save(User user) {23 return sessionFactory.getCurrentSession().save(user);
	24 }
	25 }

	1 package me.gacl.service;
	2
	3 import java.io.Serializable;
	4 import me.gacl.model.User;
	5
	6 /**
	7 * 测试
	8 * @author gacl
	9 *
	10 */
	11 public interface UserServiceI {12
	13 /**
	14 * 测试方法
	15 */
	16 void test();
	17
	18 /**
	19 * 保存用户
	20 * @param user
	21 * @return
	22 */
	23 Serializable save(User user);
	24 }

	1 package me.gacl.service.impl;
	2
	3 import java.io.Serializable;
	4
	5 import org.springframework.beans.factory.annotation.Autowired;
	6 import org.springframework.stereotype.Service;
	7
	8 import me.gacl.dao.UserDaoI;
	9 import me.gacl.model.User;
	10 import me.gacl.service.UserServiceI;
	11 //使用 Spring 提供的 @Service 注解将 UserServiceImpl 标注为一个 Service
	12 @Service("userService")
	13 public class UserServiceImpl implements UserServiceI {14
	15 /**
	16 * 注入 userDao
	17 */
	18 @Autowired
	19 private UserDaoI userDao;
	20
	21 @Override
	22 public void test() {23 System.out.println("Hello World!");
	24 }
	25
	26 @Override
	27 public Serializable save(User user) {28 return userDao.save(user);
	29 }
	30 }

	1 package me.gacl.test;
	2
	3 import java.util.Date;
	4 import java.util.UUID;
	5
	6 import me.gacl.model.User;
	7 import me.gacl.service.UserServiceI;
	8
	9 import org.junit.Before;
	10 import org.junit.Test;
	11 import org.springframework.context.ApplicationContext;
	12 import org.springframework.context.support.ClassPathXmlApplicationContext;
	13
	14 public class TestHibernate {15
	16 private UserServiceI userService;
	17
	18 /**
	19 * 这个 before 方法在所有的测试方法之前执行，并且只执行一次
	20 * 所有做 Junit 单元测试时一些初始化工作可以在这个方法里面进行
	21 * 比如在 before 方法里面初始化 ApplicationContext 和 userService
	22 */
	23 @Before
	24 public void before(){25 ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
	26 userService = (UserServiceI) ac.getBean("userService");
	27 }
	28
	29 @Test
	30 public void testSaveMethod(){31 //ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
	32 //UserServiceI userService = (UserServiceI) ac.getBean("userService");
	33 User user = new User();
	34 user.setId(UUID.randomUUID().toString().replaceAll("-", ""));
	35 user.setName("孤傲苍狼");
	36 user.setPwd("123");
	37 user.setCreatedatetime(new Date());
	38 userService.save(user);
	39 }
	40 }

	1 <?xml version="1.0" encoding="UTF-8"?>
	2 <web-app version="3.0" xmlns="http://Java.sun.com/xml/ns/javaee"
	3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	4 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
	5 http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
	6 <display-name></display-name>
	7 <welcome-file-list>
	8 <welcome-file>index.jsp</welcome-file>
	9 </welcome-file-list>
	10
	11 <!-- Spring 监听器 -->
	12 <listener>
	13 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	14 </listener>
	15 <!-- Spring 配置文件位置 -->
	16 <context-param>
	17 <param-name>contextConfigLocation</param-name>
	18 <param-value>classpath:spring.xml,classpath:spring-hibernate.xml</param-value>
	19 </context-param>
	20
	21 <!-- 防止 spring 内存溢出监听器 -->
	22 <listener>
	23 <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
	24 </listener>
	25
	26 <!-- openSessionInView 配置 -->
	27 <filter>
	28 <filter-name>openSessionInViewFilter</filter-name>
	29 <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
	30 <init-param>
	31 <param-name>singleSession</param-name>
	32 <param-value>true</param-value>
	33 </init-param>
	34 </filter>
	35 <filter-mapping>
	36 <filter-name>openSessionInViewFilter</filter-name>
	37 <url-pattern>*.action</url-pattern>
	38 </filter-mapping>
	39
	40 <!-- Struts2 的核心过滤器配置 -->
	41 <filter>
	42 <filter-name>struts2</filter-name>
	43 <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
	44 </filter>
	45 <!-- Struts2 过滤器拦截所有的.action 请求 -->
	46 <filter-mapping>
	47 <filter-name>struts2</filter-name>
	48 <url-pattern>*.action</url-pattern>
	49 </filter-mapping>
	50
	51 <!-- druid 监控页面，使用 ${pageContext.request.contextPath}/druid/index.html 访问 -->
	52 <servlet>
	53 <servlet-name>druidStatView</servlet-name>
	54 <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
	55 </servlet>
	56 <servlet-mapping>
	57 <servlet-name>druidStatView</servlet-name>
	58 <url-pattern>/druid/*</url-pattern>
	59 </servlet-mapping>
	60 </web-app>