Maven构建与管理项目(四)

Maven构建与管理项目(四)

使用Maven搭建Struts2框架的开发环境

创建基于Maven的Web项目

　　

　　

　　

　　

　　我使用的是MyEclipse8.5的版本，创建好的Web项目如下所示：

　　

　　我们知道，一个标准的Maven项目是必须包括【src/main/java】，【src/main/resources】，【src/test/java】，【src/test/resources】这四个Source Folder的，而创建好的项目当中只有一个(不懂为啥MyEclipse8.5没有帮我生成【src/main/java】)，所以我们还需要手动创建剩下的【src/main/java】，【src/test/java】，【src/test/resources】这三个Source Folder，以创建【src/main/java】为例，具体步骤如下：

　　

　　

　　点击【Finish】按钮完成创建，如下图所示：

　　

　　【src/test/java】，【src/test/resources】也是采用相同的方式进行创建，这里用一张动态的gif动画演示一下创建过程，如下图所示：

　　最终效果如下：

　　

　　这样我们的【Struts2AnnotationMavenProject】项目才是一个标准的Maven项目，我们可以使用Maven来构建一下【Struts2AnnotationMavenProject】项目，看看能否正常构建成功，如下图所示：

　 从运行结果显示，项目可以正常构建成功。

 

搭建Struts2的开发环境

添加Struts2框架的核心jar包

　　由于我们是使用Maven管理项目中的jar包的，所以我们需要在pom.xml文件中添加Struts2框架的核心jar包的描述。

　　编辑pom.xml文件，添加添加Struts2框架的核心jar包的描述，如下：

 
   4.0.0
   me.gacl
   Struts2AnnotationMavenProject
   war
   0.0.1-SNAPSHOT
   Struts2AnnotationMavenProject Maven Webapp
   http://maven.apache.org
  
     
       junit
       junit
       3.8.1
       test
     
      
     
         org.apache.struts
         struts2-core
         2.3.16
    
   
   
     Struts2AnnotationMavenProject
   
 

　　pom.xml文件中标红的部分就是我们添加的Struts2框架的核心jar包的描述，保存pom.xml文件，此时Maven就会自动帮我们把struts2-core这个jar包依赖的其他相关jar包导入到我们的Web项目当中，如下图所示：

　　

 

添加Struts2框架的配置文件struts.xml

　　Maven约定，web项目开发中的使用到的配置文件都要放到【src/main/resources】这个Source Folder下，如下图所示：

　　

　　编辑struts.xml文件，添加常用的配置项，配置信息如下：

 

convention-plugin和config-browser-plugin插件介绍

　　以前用struts2框架开发项目时，每次编写好一个Action，就需要在struts.xml文件中配置Action，而convention-plugin这个插件的出现出现后，就不再需要在struts.xml文件中配置Action了，convention-plugin提供了一种非常方便的注解方式来配置Action类。

　　convention-plugin采用"约定大于配置”的思想，只要我们遵守约定，完全可以少写配置甚至不写配置；config-browser-plugin插件则用于方便的浏览项目中的所有action及其与 jsp view的映射。这二个插件结合起来学习，能很方便的搞定struts2中各种复杂的action-view映射需求，所以现在使用Struts2框架开发Web应用时，一般都会配合这两个插件一起使用。

convention-plugin和config-browser-plugin插件使用

　　为了方便使用Struts2框架，我们最好在项目中配合convention-plugin、 config-browser-plugin这两个插件一起使用，在maven项目的pom.xml中加上这两个插件的jar包描述，如下：

 
     
        org.apache.struts
         struts2-convention-plugin
         2.3.20
     
     
     
         org.apache.struts
         struts2-config-browser-plugin
         2.3.20
     

　

 

在web.xml文件中配置Struts2的核心过滤器

 
 
 
     Archetype Created Web Application
 
     
     
         配置struts2的核心过滤器
         struts2
         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
     
 
     
         struts2
         *.action
     
     
 

 

测试Struts2框架是否搭建成功

　　编写一个TestAction类，用于测试

 package me.gacl.action;

 import org.apache.struts2.convention.annotation.Action;
 import org.apache.struts2.convention.annotation.Namespace;

 @ParentPackage("basePackage")
 //使用convention插件提供的@Action注解将一个普通Java类标识为可以处理用户请求的Action类
 @Action
 //使用使用convention插件提供的@Namespace注解指明这个Action类的命名空间
 @Namespace("/")
 public class TestAction {
     /**
      * test方法的访问方式：http://localhost:8080/Struts2AnnotationMavenProject/test!test
      * MethodName: test
      * Description: 
      * @author xudp
      */
     public void test(){
         System.out.println("调用了TestAction里面的test方法");
     }
 }

　　在将类使用@Action注解标识时发现@Action注解必须使用JDK1.6才行，所以我修改了JDK的版本，改成使用JDK1.6的，如下图所示：

　　

　　由于使用了convention-plugin插件的提供的注解方式映射Action的访问路径，所以我们不再需要像以前那样在Struts.xml文件中配置Action的访问路径了，测试结果如下：

　　可以看到，我们的TestAction里面的test方法已经成功调用了，这说明我们的Struts2框架的开发环境搭建成功。并且我们也感受到了使用convention-plugin插件开发基于注解的Struts2程序是非常方便和快捷的。

　　我们的项目中还使用到了config-browser-plugin插件，下面我们来感受一下这个config-browser-plugin插件带来的便利之处

　　输入访问URL:http://localhost:8080/项目名/config-browser/index.action来访问config-browser-plugin插件提供的视图页面，例如：http://localhost:8080/Struts2AnnotationMavenProject/config-browser/index.action，这样就可以进入config-browser-plugin插件提供的视图界面，如下图所示：

　　

　　以上就是在MyEclipse中使用Maven搭建Struts2框架的开发环境的相关介绍，使用了Maven之后，大大提高了框架开发环境的搭建速度，起码我们不再需要关心Struts2框架的开发环境需要哪些jar包，我们只需要引入Struts2的核心jar包struts2-core，然后Maven就会自动帮我们把struts2-core这个jar包的相关依赖jar全部加入到项目中，将web应用中的jar包全部交给Maven进行管理是一种非常好的做法，现在主流的项目都是采用Maven进行构建的。

 

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

在平时的JavaEE开发中，为了能够用最快的速度开发项目，一般都会选择使用Struts2，SpringMVC，Spring，Hibernate，MyBatis这些开源框架来开发项目，而这些框架一般不是单独使用的，经常是Struts2+Spring3+Hibernate、SpringMVC+Spring+Hibernate、SpringMVC+Spring+Mybatis这几种组合中的一种，也就是多个框架配合起来使用。

建立Maven工程

第一步：

　　

第二步：

　　

第三步：

　　

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

　　

第四步：

　　

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

　　

第五步：

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

　　

第六步：  

　　发布项目：Maven install     

　　清除编译过的项目：Maven clean

　　

　　Maven install命令执行结果如下：

　　

　　OK，Maven工程创建成功！

 

搭建Spring3开发环境

下载Spring3需要的jar包

　　　　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包。

 
         
             org.springframework
             spring-core
             3.1.2.RELEASE
        
         
             org.springframework
             spring-context
             3.1.2.RELEASE
         
         
             org.springframework
             spring-jdbc
             3.1.2.RELEASE
        
         
             org.springframework
            spring-beans
             3.1.2.RELEASE
         
         
             org.springframework
             spring-web
             3.1.2.RELEASE
         
         
             org.springframework
             spring-expression
             3.1.2.RELEASE
         
         
             org.springframework
             spring-orm
             3.1.2.RELEASE
         

 

编写Spring配置文件

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

　　spring.xml文件的内容如下：

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

　　

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

 

编写单元测试

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

　　

　　代码如下：

 package me.gacl.service;
 
 /**
  * 测试
  * @author gacl
  *
  */
 public interface UserServiceI {
 
     /**
    * 测试方法
      */
     void test();
 }

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

　　

 package me.gacl.service.impl;
 
 import org.springframework.stereotype.Service;
 
 import me.gacl.service.UserServiceI;
 //使用Spring提供的@Service注解将UserServiceImpl标注为一个Service
 @Service("userService")
 public class UserServiceImpl implements UserServiceI {
 
     @Override
     public void test() {
         System.out.println("Hello World!");
     }
 
 }

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

         
         
             junit
             junit
             4.12
             test
         

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

代码如下：

package me.gacl.test;
 
 import me.gacl.service.UserServiceI;
 
 import org.junit.Test;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 public class TestSpring {
 
     @Test
     public void test(){
         //通过spring.xml配置文件创建Spring的应用程序上下文环境
         ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring.xml");
         //从Spring的IOC容器中获取bean对象
         UserServiceI userService = (UserServiceI) ac.getBean("userService");
         //执行测试方法
         userService.test();
     }
 }

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

　　

 

在web.xml中配置Spring监听器

 
     
         org.springframework.web.context.ContextLoaderListener
     
     
     
         contextConfigLocation
         classpath:spring.xml
     

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

　　

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

　　

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

 

搭建Struts2开发环境并整合Spring3

下载Struts2需要的jar包

　　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会自动下载这些包

  
         
             org.apache.struts
             struts2-core
             2.3.16
             
         
         
         
             org.apache.struts
             struts2-convention-plugin
             2.3.20
         
        
         
             org.apache.struts
             struts2-config-browser-plugin
             2.3.20
         
         
         
             org.apache.struts
             struts2-spring-plugin
             2.3.4.1
         

 

编写Struts.xml配置文件

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

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

 

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

 
    
         struts2
         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
     
     
     
         struts2
         *.action
     

 

编写测试

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

　　

　　代码如下：

package me.gacl.action;
 
 import me.gacl.service.UserServiceI;
 
 import org.apache.struts2.convention.annotation.Action;
 import org.apache.struts2.convention.annotation.Namespace;
 import org.apache.struts2.convention.annotation.ParentPackage;
 import org.springframework.beans.factory.annotation.Autowired;
 
 @ParentPackage("basePackage")
 @Action(value="strust2Test")//使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action，Action的名字为struts2Test
 @Namespace("/")//使用convention-plugin插件提供的@Namespace注解为这个Action指定一个命名空间
 public class TestAction {
     
     /**
      * 注入userService      */
     @Autowired
     private UserServiceI userService;
 
     /**
      * http://localhost:8080/SSHE/strust2Test!test.action
      * MethodName: test
     * Description: 
      * @author xudp
      */
     public void test(){
         System.out.println("进入TestAction");
         userService.test();
     }
 }

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

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

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

　　

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

 

搭建Hibernate4开发环境并整合Spring3

下载Hibernate4需要的jar包

　　1.hibernate-core

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

 
        
            org.hibernate
            hibernate-core
            4.1.7.Final
        

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

 

添加数据库驱动jar包

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

　　MySQL数据库驱动jar：

 
         
             mysql          
             mysql-connector-java
             5.1.34
         

　SQLServer数据库驱动jar:

      
         
            net.sourceforge.jtds
             jtds
            1.3.1
         

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

　　

　　这是由于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添加到本地仓库中

　　

　　执行命令：

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

　　如下图所示： 　　

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

 
           
              com.oracle  
              ojdbc6  
              11.2.0.1.0          
          

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

 

添加数据库连接池jar包

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

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

 
         
             com.alibaba
             druid
             1.0.12
         

添加aspectjweaver包

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

!--aspectjweaver包 -->
         
             org.aspectj
             aspectjweaver
             1.8.5
         

 

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

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

 #hibernate.dialect=org.hibernate.dialect.OracleDialect
 #driverClassName=oracle.jdbc.driver.OracleDriver
 #validationQuery=SELECT 1 FROM DUAL
 #jdbc_url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
 #jdbc_username=gacl
 #jdbc_password=xdp
 
 hibernate.dialect=org.hibernate.dialect.MySQLDialect
 driverClassName=com.mysql.jdbc.Driver
 validationQuery=SELECT 1
 jdbc_url=jdbc:mysql://localhost:3306/sshe?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
 jdbc_username=root
 jdbc_password=XDP
 
 #hibernate.dialect=org.hibernate.dialect.SQLServerDialect
 #driverClassName=net.sourceforge.jtds.jdbc.Driver
 #validationQuery=SELECT 1
 #jdbc_url=jdbc:jtds:sqlserver://127.0.0.1:1433/sshe
 #jdbc_username=sa
 #jdbc_password=123456
 
 #jndiName=java:comp/env/dataSourceName
 
 hibernate.hbm2ddl.auto=update
 hibernate.show_sql=true
 hibernate.format_sql=true

 

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

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

　　

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

  
  
  
      
      
  
      
      
          
          
          
 
          
          
          
          
          
          
         
          
          
          
 
       
  
          
          
          
          
  
          
          
        
          
  
          
          
          
          
         
         
 
          
          
          
      
  
      
      
          
          
              
                  
                  ${hibernate.hbm2ddl.auto}
                  
                  ${hibernate.dialect}
                  
                 ${hibernate.show_sql}
                 
                  ${hibernate.format_sql}
              
          
  
          
          
              
                  me.gacl.model
              
         
 
          
          
      

      
      
          
      
  
      
      
  
     
     
         
             
             
             
             
             
            
             
             
             
             
             
             
             
             
             
             
             
             
         
     
     
     
         
         
     
     
 

 

编写单元测试代码

1、在MySQL中创建sshe数据库

　　SQL脚本：

CREATE DATABASE SSHE;

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

代码如下：

package me.gacl.model;
 
 import java.util.Date;
 
 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.Table;
 import javax.persistence.Temporal;
 import javax.persistence.TemporalType;
 
 @Entity
 @Table(name = "T_USER", schema = "SSHE")
 public class User implements java.io.Serializable {
 
     // Fields
     private String id;
     private String name;
     private String pwd;
     private Date createdatetime;
     private Date modifydatetime;
 
     // Constructors
 
     /** default constructor */
     public User() {
     }
 
     /** minimal constructor */
     public User(String id, String name, String pwd) {
         this.id = id;
         this.name = name;
         this.pwd = pwd;
     }
 
     /** full constructor */
     public User(String id, String name, String pwd, Date createdatetime, Date modifydatetime) {
         this.id = id;
         this.name = name;
         this.pwd = pwd;
         this.createdatetime = createdatetime;
         this.modifydatetime = modifydatetime;
     }
 
     // Property accessors
   @Id
     @Column(name = "ID", unique = true, nullable = false, length = 36)
     public String getId() {
         return this.id;
     }
 
     public void setId(String id) {
         this.id = id;
     }
 
     @Column(name = "NAME",nullable = false, length = 100)
   public String getName() {
         return this.name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     @Column(name = "PWD", nullable = false, length = 32)
     public String getPwd() {
         return this.pwd;
     }
 
     public void setPwd(String pwd) {
         this.pwd = pwd;
   }
 
     @Temporal(TemporalType.TIMESTAMP)
   @Column(name = "CREATEDATETIME", length = 7)
     public Date getCreatedatetime() {
         return this.createdatetime;
     }
 
     public void setCreatedatetime(Date createdatetime) {
         this.createdatetime = createdatetime;
     }
 
     @Temporal(TemporalType.TIMESTAMP)
     @Column(name = "MODIFYDATETIME", length = 7)
     public Date getModifydatetime() {
         return this.modifydatetime;
     }
 
     public void setModifydatetime(Date modifydatetime) {
         this.modifydatetime = modifydatetime;
     }
 }

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

　　

代码如下：

 package me.gacl.dao;
 
 import java.io.Serializable;
 
 import me.gacl.model.User;
 
 public interface UserDaoI {
 
     /**
      * 保存用户
      * @param user
      * @return
      */
     Serializable save(User user); 
 }

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

　　

代码如下：

 package me.gacl.dao.impl;
 
 import java.io.Serializable;
 
 import org.hibernate.SessionFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Repository;
 
 import me.gacl.dao.UserDaoI;
 import me.gacl.model.User;
 
 @Repository("userDao")
 public class UserDaoImpl implements UserDaoI {
     
     /**
      * 使用@Autowired注解将sessionFactory注入到UserDaoImpl中
      */
     @Autowired
     private SessionFactory sessionFactory;
     
     @Override    public Serializable save(User user) {
         return sessionFactory.getCurrentSession().save(user);
     }
 }

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

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

 package me.gacl.service;
 
 import java.io.Serializable;
 import me.gacl.model.User;
 
 /**
  * 测试
  * @author gacl
  *
  */
 public interface UserServiceI {
 
     /**
      * 测试方法
      */
    void test();
     
     /**
     * 保存用户
      * @param user
      * @return
      */
     Serializable save(User user); 
 }

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

 package me.gacl.service.impl;
  
 import java.io.Serializable;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import me.gacl.dao.UserDaoI;
 import me.gacl.model.User;
 import me.gacl.service.UserServiceI;
 //使用Spring提供的@Service注解将UserServiceImpl标注为一个Service
 @Service("userService")
 public class UserServiceImpl implements UserServiceI {
 
     /**
      * 注入userDao
      */
     @Autowired
     private UserDaoI userDao;
     
     @Override
     public void test() {
         System.out.println("Hello World!");
     }
 
     @Override
     public Serializable save(User user) {
         return userDao.save(user);
     }
 }

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

 package me.gacl.test;
 
 import java.util.Date;
 import java.util.UUID;
 
 import me.gacl.model.User;
 import me.gacl.service.UserServiceI;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 public class TestHibernate {
 
     private UserServiceI userService;
     
     /**
      * 这个before方法在所有的测试方法之前执行，并且只执行一次
      * 所有做Junit单元测试时一些初始化工作可以在这个方法里面进行
      * 比如在before方法里面初始化ApplicationContext和userService
      */
     @Before
     public void before(){
         ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
         userService = (UserServiceI) ac.getBean("userService");
     }
     
     @Test
     public void testSaveMethod(){
         //ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
         //UserServiceI userService = (UserServiceI) ac.getBean("userService");
         User user = new User();
         user.setId(UUID.randomUUID().toString().replaceAll("-", ""));
         user.setName("孤傲苍狼");
         user.setPwd("123");
         user.setCreatedatetime(new Date()); 
         userService.save(user);
     }
 }

　执行Junit单元测试，如下所示：

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

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

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

 

三大框架综合测试

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

完善web.xml文件中的配置

 
     
     
         index.jsp
     
 
     
     
         org.springframework.web.context.ContextLoaderListener
     
     
     
         contextConfigLocation
         classpath:spring.xml,classpath:spring-hibernate.xml
     
     
     
     
         org.springframework.web.util.IntrospectorCleanupListener
     
     
     
     
         openSessionInViewFilter
         org.springframework.orm.hibernate4.support.OpenSessionInViewFilter
         
             singleSession
             true
         
     
     
         openSessionInViewFilter
         *.action
     
     
     
     
         struts2
         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
     
     
     
         struts2
         *.action
     
     
     
     
         druidStatView
         com.alibaba.druid.support.http.StatViewServlet
     
     
         druidStatView
         /druid/*
     
 

编写测试代码

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

 package me.gacl.action;
 
 import java.util.Date;
 import java.util.UUID;
 
 import me.gacl.model.User;
 import me.gacl.service.UserServiceI;
 
 import org.apache.struts2.convention.annotation.Action;
 import org.apache.struts2.convention.annotation.Namespace;
 import org.apache.struts2.convention.annotation.ParentPackage;
 import org.springframework.beans.factory.annotation.Autowired;
 
 @ParentPackage("basePackage")
 @Action(value="strust2Test")//使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action
 @Namespace("/")//使用convention-plugin插件提供的@Namespace注解为这个Action指定一个命名空间
 public class TestAction {
     
     /**
      * 注入userService
      */
     @Autowired
     private UserServiceI userService;
 
     /**
     * http://localhost:8080/SSHE/strust2Test!test.action
     * MethodName: test
      * Description: 
      * @author xudp
      */
     public void test(){
         System.out.println("进入TestAction");
         userService.test();
     }
     
     /**
      * http://localhost:8080/SSHE/strust2Test!saveUser.action
      */
     public void saveUser(){
         User user = new User();
         user.setId(UUID.randomUUID().toString().replaceAll("-", ""));
         user.setName("xdp孤傲苍狼");
         user.setPwd("123456");
         user.setCreatedatetime(new Date()); 
         userService.save(user);
     }
 }

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

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

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

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

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

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