一.新建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
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><%@ 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>
在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.service
com.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();
}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 {
@Override
public void test() {
System.out.println("Hello World");
}
}
<!-- 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();
}
}
在tomcat服务器中进行测试，先执行【Maven install】命令发布项目,然后将SSH项目部署到tomcat服务器，最后启动tomcat服务器
tomcat服务器启动的过程中没有出现报错，输入地址：http://localhost:8080/SSH/ 能够正常进行访问，就说明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><!--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文件：
<?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 + "]";
}
}
<?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>
新建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
*/
@Autowired
private UserService userService; /**
* 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，结果如下
六.spring与hibernate整合
1.编写数据库连接配置信息文件config.properties，如下图：
hibernate.dialect=org.hibernate.dialect.MySQLDialect
driverClassName=com.mysql.jdbc.Driver
validationQuery=SELECT 1
jdbc_url=jdbc:mysql://localhost:3306/ssh?useUnicode=true&characterEncoding=UTF-8
#jdbc.url = jdbc\:mysql\://localhost\:3306/PHCSMP?useUnicode\=true&characterEncoding\=utf8
jdbc_username=root
jdbc_password=roothibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.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>
在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);
}
代码如下：
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;
@Override
public Serializable save(User user) {
System.out.println("UserDaoIMPL"+"========"+user.getAddress());
return sessionFactory.getCurrentSession().save(user);
}
}
在之前创建好的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);
}
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;
@Override
public void test() {
System.out.println("Hello！Spring 测试成功");
}
@Override
@Transactional
public Serializable save(User user) {
System.out.println("service到dao,spring和hibernate整合成功");
System.out.println("address========"+user.getAddress());
return userDao.save(user);
}
}
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);
}
}
数据库中：
测试成功，数据成功保存到数据库，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
*/
@Autowired
private 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);
}
}
数据库中：
查询数据库，数据已成功保存到数据库，至此，三大框架整合完成。
如果有什么问题，联系QQ2532466427
扫一扫
891
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
