Struts2.5+Spring4.3+Hibernate5搭建

一.新建maven项目

1.新建maven项目

点击next，

点击finish，此时的项目为maven项目，不是maven项目，所以现在把maven转为web项目

2.maven转为web项目

鼠标右击项目名后点击properties选项，找到project Facets勾选Dynamic Web Module和javascript选项

点击apply 点击ok ，如果要修改Dynamic Web Module 版本，在项目根目录下.setting---->org.eclipse.wst.common.project.facet.core.xml编辑修改

<installed facet="jst.web" version="3.0"/>修改version版本即可。

dynamic web module 2.5  对应Tomcat 6.0

dynamic web module 3.0 对应Tomcat 7.0

3.Maven标准目录

　　　　src/main/java 
　　　　src/main/resources
　　　　src/test/java 
　　　　src/test/resources

4.测试maven项目

run as 选择maven install

在console栏输出

表示maven项目新建成功

5.java compile固定插件（防止每次maven update 之后java 编译器变为jre1.5版本，在控制栏会出现problem）

<build><plugins><!-- java 编译器   不设置每次maven update 自动修改为javase1.5版本 --><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.1</version><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding> </configuration></plugin></plugins></build>

二.搭建Struts环境

1.下载struts jar包

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

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

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

<!-- Struts2的核心包 --><dependency><groupId>org.apache.struts</groupId><artifactId>struts2-core</artifactId><version>2.5.10.1</version></dependency><!-- convention-plugin插件，使用了这个插件之后，就可以采用注解的方式配置Action --><dependency><groupId>org.apache.struts</groupId><artifactId>struts2-convention-plugin</artifactId><version>2.5.10.1</version></dependency><!--config-browser-plugin插件，使用了这个插件之后，就可以很方便的浏览项目中的所有action及其与 jsp view的映射 --><dependency><groupId>org.apache.struts</groupId><artifactId>struts2-config-browser-plugin</artifactId><version>2.5.10.1</version></dependency>

2.编写struts.xml配置文件

在src/main/resource目录下新建struts.xml文件（注意struts.xml开头一定不能大写，拼写一定要正确 ）

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

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

3.在web.xml文件中引入struts过滤器

<?xml version="1.0" encoding="UTF-8"?><web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/javaee       http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"><display-name>Test</display-name><welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list><!-- Struts2的核心过滤器配置 --><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class></filter><!-- Struts2过滤器拦截所有的.action请求 --><filter-mapping><filter-name>struts2</filter-name><url-pattern>*.action</url-pattern></filter-mapping></web-app> 

4.编写测试的action

在src/main/java新建包com.zhangxf.action

在此包下新建TeatAction类

package com.zhangxf.action;import org.apache.struts2.convention.annotation.Action;import org.apache.struts2.convention.annotation.Namespace;import org.apache.struts2.convention.annotation.ParentPackage;import org.apache.struts2.convention.annotation.Result;import org.apache.struts2.convention.annotation.Results;@ParentPackage("basePackage") // 使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action，Action的名字为struts2Test@Namespace("/") // 使用convention-plugin插件提供的@Namespace注解为这个Action指定一个命名空间@Results({ @Result(name = "success", location = "/success.jsp"), @Result(name = "input", location = "/register.jsp") })public class TestAction {/**      * http://localhost:8080/SSH/strust2Test!test.action      * MethodName: test      * Description:       * @author zxf      */  @Action(value="strust2Test")//使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action，Action的名字为struts2Test      public String test(){          System.out.println("进入TestAction");          return "success";      }  }

5.新建index.jsp和success.jsp

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"    pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Insert title here</title></head><body>this is webcome jsp</body></html>

success.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"    pageEncoding="UTF-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Insert title here</title></head><body>This is my success Jsp</body></html>

此时页面会报错
The superclass "javax.servlet.http.HttpServlet" was not found on the Java Build Path

只要在pom.xml文件中引用

<!-- jsp-api --><dependency><groupId>javax.servlet</groupId><artifactId>jsp-api</artifactId><version>2.0</version><scope>provided</scope></dependency><dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId><version>1.2</version></dependency>

就可以解决了。

5.执行maven install
6.启动tomcat服务器

输入访问地址：http://localhost:8080/SSH/strust2Test.action或者http://localhost:8080/SSH/strust2Test！test.action

成功进入success.jsp页面

控制栏输出如下：

struts环境是完成了。

三.搭建spring环境

1.下载spring4.3jar包

1.spring-core

　　　　2.spring-context

　　　　3.spring-jdbc

　　　　4.spring-beans

　　　　5.spring-web

　　　　6.spring-expression

　　　　7.spring-orm

<!-- spring4.3 --><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>4.3.9.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>4.3.9.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>4.3.9.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>4.3.9.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>4.3.9.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId><version>4.3.9.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-orm</artifactId><version>4.3.9.RELEASE</version></dependency>

2.编写spring.xml配置文件

在src/main/resouce新建spring.xml文件

spring.xml文件的内容如下：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:context="http://www.springframework.org/schema/context"   xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-4.3.xsd  http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-4.3.xsd"><!-- 引入属性文件,config.properties位于src/main/resources目录下 --><context:property-placeholder location="classpath:config.properties" /><!-- 自动扫描dao和service包(自动注入) --><!-- <context:component-scan base-package="com.zhangxf.dao,com.zhangxf.servicecom.zhangxf.serviceimpl" />   --><!-- 把com.zhangxf目录下的所有包全部导入 --><context:component-scan base-package="com.zhangxf"/></beans>

3.在src/main/resources目录下创建一个config.properties文件

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

4.编写单元测试

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

package com.zhangxf.service;public interface UserService {/** * 测试 */public void test();}

然后，在src/main/java中创建com.zhangxf.serviceimpl包，在包中编写UserServiceImpl实现类，如下图所示

package com.zhangxf.serviceimpl;import org.springframework.stereotype.Service;import com.zhangxf.service.UserService;//使用Spring提供的@Service注解将UserServiceImpl标注为一个Service  @Service("userService")  public class UserServiceImpl implements UserService {@Overridepublic void test() {System.out.println("Hello World");}}

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

<!-- junit测试 --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope><!-- 这里的test表示测试时编译src/main/test文件夹中的文件，等发布的时候不编译 --></dependency>

在src/test/java目录下新建com.zhangxf.test包

新建TestSpring类

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

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

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

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

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

四.搭建Hibernate5 环境

1.下载hibernate jar包

　1.hibernate-core

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

<!-- hibernate5.2 --><dependency><groupId>org.hibernate</groupId><artifactId>hibernate-core</artifactId><version>5.2.10.Final</version><!-- 这里的 exclusions 是排除包，因为 Struts2中有javassist， Hibernate中也有javassist, 所以如果要整合Hibernate， 一定要排除掉Struts2中的javassist，否则就冲突。 --><exclusions><exclusion><groupId>javassist</groupId><artifactId>javassist</artifactId></exclusion></exclusions></dependency>

2.添加数据库驱动jar包

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

MySQL数据库驱动jar：

<!-- mysql驱动包 --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.41</version></dependency>

也可用orcal数据库

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

3.在src/main/resources目录下创建一个hibernate.cfg.xml文件：

在hibernate.cfg.xml编写数据库连接信息：

<?xml version='1.0' encoding='utf-8'?>  <!DOCTYPE hibernate-configuration PUBLIC          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"          "http://hibernate.sourceforge.net/hibernate-configuration-5.0.dtd">  <hibernate-configuration>      <session-factory>          <!--  第一部分： 配置数据库信息 Database connection settings -->          <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>          <property name="hibernate.connection.url">jdbc:mysql:///ssher?useUnicode=true&characterEncoding=UTF-8</property>          <property name="hibernate.connection.username">root</property>          <property name="hibernate.connection.password">root</property>      <!-- 第二部分： 配置hibernate信息  可选的-->          <!-- 输出底层sql语句 -->          <property name="hibernate.show_sql">true</property>                  <!-- 输出底层sql语句格式 -->          <property name="hibernate.format_sql">true</property>                  <!-- hibernate帮创建表，需要配置之后               update: 如果已经有表，更新，如果没有，创建  -->          <property name="hibernate.hbm2ddl.auto">update</property>                  <!-- 配置数据库方言              在mysql里面实现分页 关键字 limit，只能使用mysql里面              在oracle数据库，实现分页rownum              让hibernate框架识别不同数据库的自己特有的语句   -->          <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>         <!--  将Session扔到线程里去处理，Enable Hibernate's automatic session context              management   -->          <property name="current_session_context_class">thread</property>        <!-- 第三部分： 把映射文件放到核心配置文件中 必须的-->          <mapping resource="com/zhangxf/entity/User.hbm.xml"/>          </session-factory>  </hibernate-configuration> 

4.测试hibernate

在src/main/java中创建com.zhangxf.entityl包，在包中编写实体User类，如下图所示：

在包下新建User实体类

代码如下：

package com.zhangxf.entity;public class User {            private int uid;      private String username;      private String password;      private String address;            public int getUid() {          return uid;      }      public void setUid(int uid) {          this.uid = uid;      }      public String getUsername() {          return username;      }      public void setUsername(String username) {          this.username = username;      }      public String getPassword() {          return password;      }      public void setPassword(String password) {          this.password = password;      }      public String getAddress() {          return address;      }      public void setAddress(String address) {          this.address = address;      }            @Override      public String toString() {          return "User [uid=" + uid + ", username=" + username + ", password="                  + password + ", address=" + address + "]";      }              } 

生成User.hbm.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC       "-//Hibernate/Hibernate Mapping DTD 3.0//EN"      "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  <hibernate-mapping>      <!-- 1 配置类和表对应           class标签          name属性：实体类全路径          table属性：数据库表名称      -->      <class name="com.zhangxf.entity.User" table="t_user">          <!-- 2 配置实体类id和表id对应               hibernate要求实体类有一个属性唯一值              hibernate要求表有字段作为唯一值          -->          <!-- id标签              name属性：实体类里面id属性名称              column属性：生成的表字段名称           -->          <id name="uid" column="uid">              <!-- 设置数据库表id增长策略                   native:生成表id值就是主键自动增长              -->              <generator class="native"></generator>          </id>          <!-- 配置其他属性和表字段对应               name属性：实体类属性名称              column属性：生成表字段名称          -->          <property name="username" column="username"></property>          <property name="password" column="password"></property>          <property name="address" column="address"></property>      </class>  </hibernate-mapping>  

在src/main/java新建包com.zhangxf.utils

新建HibernateUtils工具类

代码如下：

package com.zhangxf.utils;import org.hibernate.SessionFactory;  import org.hibernate.cfg.Configuration;    public class HibernateUtils {        static Configuration cfg = null;      static SessionFactory sessionFactory = null;      //静态代码块实现      static {          //加载核心配置文件          cfg = new Configuration();          cfg.configure();          sessionFactory = cfg.buildSessionFactory();      }            //提供方法返回sessionFactory      public static SessionFactory getSessionFactory() {          return sessionFactory;      }            public static void main(String[] args) {                }  }  

在src/test/java新建TestHibernate测试类，代码如下：

package com.zhangxf.test;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.junit.Test;import com.zhangxf.entity.User;import com.zhangxf.utils.HibernateUtils;//测试成功public class TestHibernate {@Test      public void testAdd() {            //      第一步 加载hibernate核心配置文件          // 到src下面找到名称是hibernate.cfg.xml          //在hibernate里面封装对象 //Configuration就是代表着hibernate的那个xml配置文件对象，//如果configure方法中没有参数的话，默认是就是hibernate.cfg.xml。//      Configuration cfg = new Configuration();  //      cfg.configure();            //      第二步 创建SessionFactory对象          //读取hibernate核心配置文件内容，创建sessionFactory          //在过程中，根据映射关系，在配置数据库里面把表创建  //      SessionFactory sessionFactory = cfg.buildSessionFactory();                    //由于使用了工具类，所以第一步和第二步可以使用下边一句代替          SessionFactory sessionFactory = HibernateUtils.getSessionFactory();            //      第三步 使用SessionFactory创建session对象          // 类似于连接          Session session = sessionFactory.openSession();            //      第四步 开启事务          Transaction tx = session.beginTransaction();    //      第五步 写具体逻辑 crud操作          //添加功能          User user = new User();          user.setUsername("李达康");          user.setPassword("大风长公司");          user.setAddress("汉东省京州市");          //调用session的方法实现添加          session.save(user);            //      第六步 提交事务          tx.commit();    //      第七步 关闭资源          session.close();          sessionFactory.close();           }  }

运行测试TestHibernate

数据库有数据说明测试成功。

Hibernate也搭建好了。

五.struts和spring整合

1.下载struts2和Spring整合时需要使用到的插件

   1.struts2-spring-plugin(struts2和Spring整合时需要使用到的插件)

在pom.xml文件中编写struts2和Spring整合时需要使用到的插件需要的jar包

<!-- Struts2和Spring4整合插件 --><dependency><groupId>org.apache.struts</groupId><artifactId>struts2-spring-plugin</artifactId><version>2.5.12</version></dependency>

2.配置struts.xml，指定spring负责ation的创建

<!-- 指定由spring负责action对象的创建 ，进行spring和struts整合-->    <constant name="struts.objectFactory" value="spring" /> 

3.在web.xml文件中配置spring监听器

<!-- Spring监听器 --><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><!-- Spring配置文件位置 --><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:spring.xml</param-value></context-param>

4.在TestAction注入userService，代码如下：

/** * 注入userService */@Autowiredprivate UserService userService;

重新写个testStrutsAndSpring()方法测试strutts和hibernate 的整合

/** * http://localhost:8080/SSH/strustAndSpring.action  * Description: *  * @author zhangxf */@Action(value = "strustAndSpring")public String testStrutsAndSpring() {System.out.println("进入TestStrustAndSpringAction");userService.test();System.out.println("struts和hibernate整合成功");return "success";}

5.启动tomcat

访问http://localhost:8080/SSH/strustAndSpring.action，结果如下

struts2与spring4整合成功。

六.spring与hibernate整合

1.编写数据库连接配置信息文件config.properties，如下图：

hibernate.dialect=org.hibernate.dialect.MySQLDialectdriverClassName=com.mysql.jdbc.DrivervalidationQuery=SELECT 1jdbc_url=jdbc:mysql://localhost:3306/ssh?useUnicode=true&characterEncoding=UTF-8#jdbc.url = jdbc\:mysql\://localhost\:3306/PHCSMP?useUnicode\=true&characterEncoding\=utf8jdbc_username=rootjdbc_password=root

hibernate.hbm2ddl.auto=updatehibernate.show_sql=truehibernate.format_sql=true

2.编写hibernate与spring整合的配置文件

<?xml version="1.0" encoding="UTF-8"?><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="  http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans-4.3.xsd   http://www.springframework.org/schema/tx   http://www.springframework.org/schema/tx/spring-tx-4.3.xsd  http://www.springframework.org/schema/aop   http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  "><!-- JNDI方式配置数据源 --><!-- <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"> <property name="jndiName" value="${jndiName}"></property> </bean> --><!-- 配置数据源     使用的是Druid数据源--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"><property name="driverClassName" value="${driverClassName}" /><!-- <property name="url" value="jdbc:mysql://localhost:3306/ssher?useUnicode=true&characterEncoding=UTF-8" />  --><property name="url" value="${jdbc_url}" /><property name="username" value="${jdbc_username}" /><property name="password" value="${jdbc_password}" /><!-- 初始化连接大小 --><property name="initialSize" value="0" /><!-- 连接池最大使用连接数量 --><property name="maxActive" value="20" /><!-- 连接池最小空闲 --><property name="minIdle" value="0" /><!-- 获取连接最大等待时间 --><property name="maxWait" value="60000" /><property name="poolPreparedStatements" value="true" /><property name="maxPoolPreparedStatementPerConnectionSize"value="33" /><!-- 用来检测有效sql --><property name="validationQuery" value="${validationQuery}" /><property name="testOnBorrow" value="false" /><property name="testOnReturn" value="false" /><property name="testWhileIdle" value="true" /><!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 --><property name="timeBetweenEvictionRunsMillis" value="60000" /><!-- 配置一个连接在池中最小生存的时间，单位是毫秒 --><property name="minEvictableIdleTimeMillis" value="25200000" /><!-- 打开removeAbandoned功能 --><property name="removeAbandoned" value="true" /><!-- 1800秒，也就是30分钟 --><property name="removeAbandonedTimeout" value="1800" /><!-- 关闭abanded连接时输出错误日志 --><property name="logAbandoned" value="true" /><!-- 监控数据库，SQL合并配置 --><!-- <property name="filters" value="mergeStat" /> --><!-- 使用druid的特性，防止SQL注入攻击，统计监控信息 --><property name="filters" value="mergeStat,stat,wall" /></bean><!-- 配置hibernate5 session工厂 --><bean id="sessionFactory"class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"><!-- 配置依赖的数据源属性 -->  <property name="dataSource" ref="dataSource" /><!-- hibernate 配置文件的路径 --> <!-- <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>  --> <property name="hibernateProperties"><props><!-- web项目启动时是否更新表结构 --><prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop><!-- 系统使用的数据库方言，也就是使用的数据库类型 --><prop key="hibernate.dialect">${hibernate.dialect}</prop><!-- 是否打印Hibernate生成的SQL到控制台 --><prop key="hibernate.show_sql">${hibernate.show_sql}</prop><!-- 是否格式化打印出来的SQL --><prop key="hibernate.format_sql">${hibernate.format_sql}</prop><!-- 配置current session的上下文环境，方便我们调用sessionFactory获取当前线程统一个session对象 --><!-- 没有配置报createSQLQuery is not valid without active transaction错误** --><prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate5.SpringSessionContext</prop>      </props></property><!-- 扫描hibernate注解配置的entity --><property name="packagesToScan" value="com.zhangxf.entity" /><!-- 自动扫描hbm方式配置的hibernate文件和.hbm文件 --><property name="mappingDirectoryLocations"><list> <value>classpath:com/zhangxf/entity</value> </list> </property></bean> <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">        <property name="sessionFactory" ref="sessionFactory"/>    </bean>    <tx:annotation-driven proxy-target-class="true" transaction-manager="transactionManager"/><!-- 配置事务管理器 --><bean name="transactionManager"class="org.springframework.orm.hibernate5.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"></property></bean><!-- 注解方式配置事物 --><tx:annotation-driven transaction-manager="transactionManager" /> <!-- 拦截器方式配置事物 --><tx:advice id="transactionAdvice" transaction-manager="transactionManager"><tx:attributes><!-- 以如下关键字开头的方法使用事物 --><!-- <tx:method name="add*" /><tx:method name="save*" /><tx:method name="update*" /><tx:method name="modify*" /><tx:method name="edit*" /><tx:method name="delete*" /><tx:method name="remove*" /><tx:method name="repair" /><tx:method name="deleteAndRepair" />以如下关键字开头的方法不使用事物<tx:method name="get*" propagation="SUPPORTS" /><tx:method name="find*" propagation="SUPPORTS" /><tx:method name="load*" propagation="SUPPORTS" /><tx:method name="search*" propagation="SUPPORTS" /><tx:method name="datagrid*" propagation="SUPPORTS" /> --><!-- 其他方法不使用事物 --><tx:method name="*" propagation="SUPPORTS" /></tx:attributes></tx:advice><!-- 切面，将事物用在哪些对象上 --><!-- <aop:config><aop:pointcut id="transactionPointcut"expression="execution(*com.zhangxf.service.*Impl.*(..))" /><aop:advisor pointcut-ref="transactionPointcut"advice-ref="transactionAdvice" /></aop:config> --></beans>  

3.在pom.xml文件中引入数据源

<!-- 数据源 druid --><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.0.12</version></dependency>

4编写测试

在src/main/java中创建com.zhangxf.dao包，在包中编写一个 UserDao接口，如下图所示：

代码如下：

package com.zhangxf.dao;import java.io.Serializable;import com.zhangxf.entity.User;public interface UserDao {/** * 保存用户 *  * @param user * @return */public Serializable save(User user);}

在src/main/java中创建com.zhangxf.daoimpl包，在包中编写一个 UserDaoimpl实现UserDao的接口，如下图所示：

代码如下：

package com.zhangxf.daoimpl;import java.io.Serializable;import org.hibernate.SessionFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Repository;import com.zhangxf.dao.UserDao;import com.zhangxf.entity.User;@Repository("userDao") public class UserDaoImpl implements UserDao {/**       * 使用@Autowired注解将sessionFactory注入到UserDaoImpl中       */        @Autowired        private SessionFactory sessionFactory;   @Overridepublic Serializable save(User user) {System.out.println("UserDaoIMPL"+"========"+user.getAddress());return sessionFactory.getCurrentSession().save(user); }}

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

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

package com.zhangxf.service;import java.io.Serializable;import com.zhangxf.entity.User;public interface UserService {/** * 测试 */public void test();/**       * 保存用户       * @param user       * @return       */    public Serializable save(User user);  }

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

package com.zhangxf.serviceimpl;import java.io.Serializable;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import com.zhangxf.dao.UserDao;import com.zhangxf.entity.User;import com.zhangxf.service.UserService;//使用Spring提供的@Service注解将UserServiceImpl标注为一个Service  @Service("userService")  public class UserServiceImpl implements UserService { /**       * 注入userDao       */        @Autowired        private UserDao userDao;  @Overridepublic void test() {System.out.println("Hello！Spring 测试成功");}@Override@Transactionalpublic Serializable save(User user) {System.out.println("service到dao,spring和hibernate整合成功");System.out.println("address========"+user.getAddress());return userDao.save(user);}}

src/main/test下的com.zhangxf.test包中编写 TestSpringHibernate类，代码如下：

package com.zhangxf.test;  import org.junit.Before;  import org.junit.Test;  import org.springframework.context.ApplicationContext;  import org.springframework.context.support.ClassPathXmlApplicationContext;import com.zhangxf.entity.User;import com.zhangxf.service.UserService;      public class TestSpringHibernate {            private UserService userService;              /**       * 这个before方法在所有的测试方法之前执行，并且只执行一次       * 所有做Junit单元测试时一些初始化工作可以在这个方法里面进行       * 比如在before方法里面初始化ApplicationContext和userService       */        @Before        public void before(){            @SuppressWarnings("resource")ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});            userService = (UserService) ac.getBean("userService");        }                @Test        public void testSaveMethod(){            User user = new User();            user.setUsername("易学习");            user.setPassword("汉东省");         user.setAddress("京州市");        userService.save(user);        }  }  

5.junit执行结果成功：

数据库中：也增加了这条数据

测试成功，数据成功保存到数据库，spring与hibernate整合完成。

七.三大框架整合测试

1.在web.xml中添加classpath:spring-hibernate.xm到spring的配置参数中

<!-- Spring配置文件位置 --><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:spring.xml,classpath:spring-hibernate.xml</param-value></context-param>

2.在TestAction中增加saveUser方法，代码如下：

package com.zhangxf.action;import org.apache.struts2.convention.annotation.Action;import org.apache.struts2.convention.annotation.Namespace;import org.apache.struts2.convention.annotation.ParentPackage;import org.apache.struts2.convention.annotation.Result;import org.apache.struts2.convention.annotation.Results;import org.springframework.beans.factory.annotation.Autowired;import com.zhangxf.entity.User;import com.zhangxf.service.UserService;@ParentPackage("basePackage") // 使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action，Action的名字为struts2Test@Namespace("/") // 使用convention-plugin插件提供的@Namespace注解为这个Action指定一个命名空间@Results({ @Result(name = "success", location = "/success.jsp"), @Result(name = "input", location = "/register.jsp") })public class TestAction {/** * 注入userService */@Autowiredprivate UserService userService;/**      * http://localhost:8080/SSH/strust2Test!test.action      * MethodName: test      * Description:       * @author zhangxf      */  @Action(value="strust2Test")//使用convention-plugin插件提供的@Action注解将一个普通java类标注为一个可以处理用户请求的Action，Action的名字为struts2Test      public String test(){          System.out.println("进入TestAction");          return "success";      }  /** * http://localhost:8080/SSH/strustAndSpring.action  * Description: *  * @author zhangxf */@Action(value = "strustAndSpring")public String testStrutsAndSpring() {System.out.println("进入TestStrustAndSpringAction");userService.test();System.out.println("struts和hibernate整合成功");return "success";}@Action(value ="save")public void saveUser() {User user = new User();user.setUsername("皇家工业学院");user.setPassword("尖草坪区");user.setAddress("23#612皇家宿舍");userService.save(user);}}

启动tomcat,访问http://localhost:8080/SSH/save.action，结果如下：

数据库中：

查询数据库，数据已成功保存到数据库，至此，三大框架整合完成。

如果有什么问题，联系QQ2532466427