Spring+Struts2+Hibernate整合

红太狼 2022-07-15 05:03 289阅读 0赞

**详细的介绍搭建SSH框架环境 ，并用框架实现简单的CRUD操作。**

# **基本需求** #

**概述：完成员工信息的增删改查操作（CRUD），其中员工和部门是单向的多对一关系，在保存和修改页面使用下拉列表实现部门的选择。**

图示：

所有员工显示：

![Center][]

![Image 1][]

保存：

![Center 1][]

![Image 1][]

修改：

![Center 2][]

![Image 1][]

# **环境搭建：** #

## **导入相关jar包** ##

Spring+ Struts2+ Hibernate jar包目录

antlr-2.7.7.jar

asm-3.3.jar

asm-commons-3.3.jar

asm-tree-3.3.jar

c3p0-0.9.1.2.jar

com.springsource.net.sf.cglib-2.2.0.jar

com.springsource.org.aopalliance-1.0.0.jar

com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

commons-fileupload-1.3.jar

commons-io-2.0.1.jar

commons-lang3-3.1.jar

commons-logging-1.1.3.jar

dom4j-1.6.1.jar

ehcache-core-2.4.3.jar

freemarker-2.3.19.jar

hibernate-commons-annotations-4.0.2.Final.jar

hibernate-core-4.2.4.Final.jar

hibernate-ehcache-4.2.4.Final.jar

hibernate-jpa-2.0-api-1.0.1.Final.jar

javassist-3.15.0-GA.jar

jboss-logging-3.1.0.GA.jar

jboss-transaction-api\_1.1\_spec-1.0.1.Final.jar

log4j-1.2.17.jar

mysql-connector-java-5.1.7-bin.jar

ognl-3.0.6.jar

slf4j-api-1.6.1.jar

spring-aop-4.0.0.RELEASE.jar

spring-aspects-4.0.0.RELEASE.jar

spring-beans-4.0.0.RELEASE.jar

spring-context-4.0.0.RELEASE.jar

spring-core-4.0.0.RELEASE.jar

spring-expression-4.0.0.RELEASE.jar

spring-jdbc-4.0.0.RELEASE.jar

spring-orm-4.0.0.RELEASE.jar

spring-tx-4.0.0.RELEASE.jar

spring-web-4.0.0.RELEASE.jar

struts2-core-2.3.15.3.jar

struts2-spring-plugin-2.3.15.3.jar

xwork-core-2.3.15.3.jar

## **建立基本的包结构，编写配置文件** ##

![Image 1][]

将包结构建立好后，就可以依据包结构对配置文件进行配置

![Center 3][]

建立配置文件（二级缓存的文件在优化的时候使用）

![Center 4][]

![Image 1][]

### **编写配置文件** ###

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-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>

<property name="hibernate.hbm2ddl.auto">update</property>

</session-factory>

</hibernate-configuration>

jdbc.properties

jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/springhibernate

jdbc.user=root

jdbc.password=123456

beans.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:tx="http://www.springframework.org/schema/tx"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

<context:component-scan base-package="com.myframe.ssh"></context:component-scan>

<context:property-placeholder location="classpath:jdbc.properties" />

</bean>

<!-- 配置LocalSessionFactoryBean 用于创建一个sessionFactory，ioc容器管理session对象

这样就可以完成hibernate和Spring整合

\-->

<bean id="sessionFactory"

class=" org.springframework.orm.hibernate4.LocalSessionFactoryBean">

<list>

<value>classpath:com/myframe/ssh/pojo/\*.hbm.xml</value>

</list>

</property>

</bean>

<bean id="transactionManager"

class=" org.springframework.orm.hibernate4.HibernateTransactionManager">

</bean>

<tx:annotation-driven transaction-manager="transactionManager" />

</beans>

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">

</package>

</struts>

Spring的IOC容器和Struts2的核心控制器需要在web.xml中配置

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app\_2\_5.xsd"

id="WebApp\_ID" version="2.5">

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:beans.xml</param-value>

</context-param>

<listener-class> org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<filter-name>struts2</filter-name>

<filter-class> org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/\*</url-pattern>

</filter-mapping>

</web-app>

**基本的环境配置完成。**

# **编写POJO类，并生成映射文件** #

测试使用的POJO类（员工和部门类，单向的多对一的关系），并创建映射文件，在设置好的包结构中创建（已经提前配置好映射文件的管理）。

<list>

<value>classpath:com/myframe/ssh/pojo/\*.hbm.xml</value>

</list>

</property>

Employee

package com.myframe.ssh.pojo;

public class Employee \{

private Integer empId;

private String empName;

// 建立单向的多对一关系

private Department department;

public Department getDepartment() \{

return department;

public void setDepartment(Department department) \{

this.department = department;

public Employee() \{

super();

public Employee(Integer empId, String empName) \{

super();

this.empId = empId;

this.empName = empName;

public Integer getEmpId() \{

return empId;

public void setEmpId(Integer empId) \{

this.empId = empId;

public String getEmpName() \{

return empName;

public void setEmpName(String empName) \{

this.empName = empName;

@Override

public String toString() \{

return "Employee \[empId=" + empId + ", empName=" + empName + "\]";

Employee.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.myframe.ssh.pojo">

</id>

</property>

<many-to-one name="department" class="Department" fetch="join" >

</many-to-one>

</class>

</hibernate-mapping>

Department

package com.myframe.ssh.pojo;

public class Department \{

private Integer deptId;

private String deptName;

public Department(Integer deptId, String deptName) \{

super();

this.deptId = deptId;

this.deptName = deptName;

public Department() \{

super();

public Integer getDeptId() \{

return deptId;

public void setDeptId(Integer deptId) \{

this.deptId = deptId;

public String getDeptName() \{

return deptName;

public void setDeptName(String deptName) \{

this.deptName = deptName;

@Override

public String toString() \{

return "Department \[deptId=" + deptId + ", deptName=" + deptName + "\]";

Department.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.myframe.ssh.pojo">

</id>

</property>

</class>

</hibernate-mapping>

# **编写实现CRUD功能** #

## 基本接口准备： ##

Dao 接口

package com.myframe.ssh.dao;

import java.util.List;

import com.myframe.ssh.pojo.Department;

import com.myframe.ssh.pojo.Employee;

public interface EmployeeDao \{

/\*\*

\* 获取所有员工

\* @return 包含所有员工list集合

\*/

public List<Employee> getAllEmp();

/\*\*

\* 获取所有部门

\* @return 包含所有部门的list集合

\*/

public List<Department> getAllDept();

/\*\*

\* 获取一个员工

\* @param id

\* @return 一个员工对象

\*/

public Employee getEmp(Integer empId);

/\*\*

\* 保存一个员工

\* @param employee

\*/

public void saveEmp(Employee employee);

/\*\*

\* 更新一个员工

\* @param employee

\*/

public void updateEmp(Employee employee);

/\*\*

\* 删除一个员工

\* @param employee

\*/

public void deleteEmp(Employee employee);

Dao接口实现（使用注解自动装配）

package com.myframe.ssh.dao;

import java.util.List;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Repository;

import com.myframe.ssh.pojo.Department;

import com.myframe.ssh.pojo.Employee;

@SuppressWarnings("unchecked")

@Repository

public class EmployeeDaoImpl implements EmployeeDao \{

@Autowired

private SessionFactory sessionFactory;

/\*\*

\* 提供一个获取session对象的方法

\* @return session对象

\*/

private Session getSession() \{

return sessionFactory.getCurrentSession();

@Override

public List<Employee> getAllEmp() \{

return getSession().createQuery(

"from Employee e left join fetch e.department").list();

@Override

public List<Department> getAllDept() \{

return getSession().createQuery("from Department").list();

@Override

public Employee getEmp(Integer EmpId) \{

return (Employee) getSession().get(Employee.class, EmpId);

@Override

public void saveEmp(Employee employee) \{

getSession().save(employee);

@Override

public void updateEmp(Employee employee) \{

getSession().update(employee);

@Override

public void deleteEmp(Employee employee) \{

getSession().delete(employee);

Service接口

package com.myframe.ssh.service;

import java.util.List;

import com.myframe.ssh.pojo.Department;

import com.myframe.ssh.pojo.Employee;

public interface EmployeeService \{

/\*\*

\* 获取所有员工

\* @return 包含所有员工list集合

\*/

public List<Employee> getAllEmp();

/\*\*

\* 获取所有部门

\* @return 包含所有部门的list集合

\*/

public List<Department> getAllDept();

/\*\*

\* 获取一个员工

\* @param id

\* @return 一个员工对象

\*/

public Employee getEmp(Integer EmpId);

/\*\*

\* 保存一个员工

\* @param employee

\*/

public void saveEmp(Employee employee);

/\*\*

\* 更新一个员工

\* @param employee

\*/

public void updateEmp(Employee employee);

/\*\*

\* 删除一个员工

\* @param employee

\*/

public void deleteEmp(Integer empId);

Service接口实现（使用注解配置事务）

package com.myframe.ssh.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import com.myframe.ssh.dao.EmployeeDao;

import com.myframe.ssh.pojo.Department;

import com.myframe.ssh.pojo.Employee;

@Transactional

@Service

public class EmployeeServiceImpl implements EmployeeService \{

@Autowired

private EmployeeDao employeeDao;

@Transactional(readOnly = true)

@Override

public List<Employee> getAllEmp() \{

return employeeDao.getAllEmp();

@Transactional(readOnly = true)

@Override

public List<Department> getAllDept() \{

// TODO Auto-generated method stub

return employeeDao.getAllDept();

@Transactional(readOnly = true)

@Override

public Employee getEmp(Integer EmpId) \{

return employeeDao.getEmp(EmpId);

@Override

public void saveEmp(Employee employee) \{

System.out.println(employee);

employeeDao.saveEmp(employee);

@Override

public void updateEmp(Employee employee) \{

employeeDao.updateEmp(employee);

@Override

public void deleteEmp(Integer empId) \{

Employee emp = employeeDao.getEmp(empId);

if (emp != null) \{

employeeDao.deleteEmp(emp);

对编写的接口进行测试（测试的时候创建数据库表）

## **编写action(CRUD)---使用增量式编码的方式对代码进行补充** ##

根据流程编写对应的action

编写页面：index.jsp,  list.jsp,  save.jsp,  update.jsp

### **查询所有员工** ###

实现步骤：

①页面发出请求getAll.action

<a href="$\{pageContext.request.contextPath \}/getAll.action">查询所有员工</a>

②struts.xml配置action（要由框架帮我们管理请求）

</action>

③写处理action的方法（注：要想在页面获取某域中的数据必须实现XxxAware）

在准备好的包结构中创建一个专门来管理所有action方法的类

@Controller

@Scope("prototype")

public class EmployeeAction\{

@Autowired

private EmployeeService employeeService;

添加一个获取所有员工的action

package com.myframe.ssh.action;

import java.util.List;

import java.util.Map;

import org.apache.struts2.interceptor.RequestAware;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Scope;

import org.springframework.stereotype.Controller;

import com.myframe.ssh.pojo.Department;

import com.myframe.ssh.pojo.Employee;

import com.myframe.ssh.service.EmployeeService;

@Controller

@Scope("prototype")

public class EmployeeAction implements RequestAware \{

@Autowired

private EmployeeService employeeService;

private Map<String, Object> request;

public String getAll() \{

// 要想保存到request中必须实现RequestAware

// 要想在页面获取必须实现XxxAware

List<Employee> empList = employeeService.getAllEmp();

request.put("empList", empList);

return "success";

@Override

public void setRequest(Map<String, Object> request) \{

this.request = request;

④list.jsp页面获取，并显示

<%@ page language="java" contentType="text/html; charset=UTF-8"

pageEncoding="UTF-8"%>

<%@ taglib prefix="s" uri="/struts-tags"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

<h1 align="center">显示所有员工信息</h1>

<s:if test="\#request.empList == null || \#request.empList.empty">

没有员工信息

</s:if>

<s:else>

<tr>

</tr>

<s:iterator value="\#request.empList">

<tr>

</tr>

</s:iterator>

</table>

</center>

</s:else>

</center>

</body>

</html>

测试

### **保存一名员工** ###

步骤：

①从list.jsp页面发送tosave.action（保存前做一些准备工作）

②配置action

</action>

③写处理action的方法（注：表单要可以显示部门的下拉列表，可以供选择）

public String tosave() \{

List<Department> deptList = employeeService.getAllDept();

request.put("deptList", deptList);

return "save";

④到save.jsp页面，填写信息，然后提交表单（注意：下拉列选的设置），发送 dosave.action请求

<s:form action="dosave">

<s:textfield name="empName" label="员工姓名"/>

<s:select list="\#request.deptList" label="部门" listKey="deptId" listValue="deptName" name="department.deptId" ></s:select>

<s:submit value="保存"></s:submit>

</s:form>

⑤ 配置dosave.action

<param name="actionName">getAll</param>

</result>

</action>

⑥编写 dosave的方法（使用模型对象接收表单提交的数据）

**实现** **ModelDriven<T>接口， Preparable接口（使用模型驱动封装表单数据）**

public class EmployeeAction implements RequestAware, ModelDriven<Employee>,

Preparable

声明模型对象

//模型对象，我们需要提前给模型对象赋初始值

private Employee employee;

/\*\*

\* 框架会将表单提交的数据自动封装到我们准备的模型对象中(使用参数拦截器)，同时也可以在页面获取模型对象中的值（因为getModel将模型对象保存在对象栈中）

\* 将模型对象压入栈中，注：对象不能是null，若是null不进行压栈工作

\* 因为getModel方法每次处理请求之前都会执行，因此不在这个方法中给模型对象赋值 使用前缀方法

\*/

@Override

public Employee getModel() \{

return employee;

/\*\*

\* 它也是每个请求都会执行，因此也不在这个里面赋值

\*/

@Override

public void prepare() throws Exception \{

System.out.println("prepare....");

使用前缀方法给模型对象赋值

public void prepareDosave() \{

employee = new Employee();

这样框架就会自动将我们从表单提交的数据封装到模型对象上，我们只需要保存这个对象即可。

public String dosave() \{

employeeService.saveEmp(employee);

return "list";

### **修改一名员工** ###

步骤：

①从list.jsp页面发送toupdate.action(这个操作是给update.jsp回显一些信息)

②配置action

<result name="update">update.jsp</result>

</action>

③编写action方法

//属性驱动

private Integer empId;

/\*\*

\* 需要在前缀方法执行之前，执行参数拦截器

\*/

public void prepareToupdate() \{

employee = employeeService.getEmp(empId);

public String toupdate() \{

List<Department> deptList = employeeService.getAllDept();

request.put("deptList", deptList);

return "update";

public Integer getEmpId() \{

return empId;

public void setEmpId(Integer empId) \{

this.empId = empId;

getModel()

getModel方法可以将前缀方法准备的对象压入对象栈，这样在页面就可以获取到

需要在执行前缀方法前执行参数拦截器，给empId赋值

需要在struts.xml中配置拦截器栈

<default-interceptor-ref name="paramsPrepareParamsStack"/>

④update.jsp

<s:form action="doupdate">

<s:hidden name="empId"/>

<s:textfield name="empName" label="员工姓名"/>

<s:select list="\#request.deptList" listKey="deptId" listValue="deptName" label="部门名称" name="department.deptId"></s:select>

<s:submit value="修改"></s:submit>

</s:form>

⑤修改后，提交doupdate.action，保存修改信息

<result type="redirectAction" name="list">getAll</result>

</action>

⑥真正执行保存的action

public void prepareDoupdate() \{

employee = new Employee();

//employee = employeeService.getEmp(empId);

public String doupdate() \{

employeeService.updateEmp(employee);;

return "list";

getModel()会将模型对象压栈，参数拦截器完成将表单数据包装成模型对象

**总结：保存和修改操作都需要发送两次请求，原因是在执行保存和修改操作前，编辑页面需要从数据库获取一些信息在页面显示。**

### **删除一名员工** ###

步骤：

① list.jsp页面发送delete.action

list.jsp

②配置action

<result type="redirectAction" name="list">getAll</result>

</action>

③ 编写action方法

public String delete() \{

employeeService.deleteEmp(empId);

return "list";

## **完整action类** ##

package com.myframe.ssh.action;

import java.util.List;

import java.util.Map;

import org.apache.struts2.interceptor.RequestAware;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Scope;

import org.springframework.stereotype.Controller;

import com.myframe.ssh.pojo.Department;

import com.myframe.ssh.pojo.Employee;

import com.myframe.ssh.service.EmployeeService;

import com.opensymphony.xwork2.ModelDriven;

import com.opensymphony.xwork2.Preparable;

@Controller

@Scope("prototype")

public class EmployeeAction implements RequestAware, ModelDriven<Employee>,

Preparable \{

@Autowired

private EmployeeService employeeService;

private Map<String, Object> request;

private Employee employee;

private Integer empId;

public String delete() \{

employeeService.deleteEmp(empId);

return "list";

public void prepareDoupdate() \{

//employee = new Employee();

employee = employeeService.getEmp(empId);

public String doupdate() \{

employeeService.updateEmp(employee);;

return "list";

/\*\*

\* 需要在前缀方法执行之前，执行参数拦截器

\*/

public void prepareToupdate() \{

employee = employeeService.getEmp(empId);

public String toupdate() \{

List<Department> deptList = employeeService.getAllDept();

request.put("deptList", deptList);

return "update";

public void prepareDosave() \{

employee = new Employee();

// 保存功能使用模型驱动

public String dosave() \{

employeeService.saveEmp(employee);

return "list";

public String tosave() \{

List<Department> deptList = employeeService.getAllDept();

request.put("deptList", deptList);

return "save";

public String getAll() \{

// 要想保存到request中必须实现RequestAware

// 要想在页面获取必须实现XxxAware

List<Employee> empList = employeeService.getAllEmp();

request.put("empList", empList);

return "success";

@Override

public void setRequest(Map<String, Object> request) \{

this.request = request;

/\*\*

\* 框架会将表单提交的数据自动封装到我们准备的模型对象中(使用参数拦截器)，同时也可以在页面获取模型对象中的值（它使用getModel保存在对象栈中）

\* 将模型对象压入栈中，注：对象不能是null，若是null不进行压栈工作

\* 因为getModel方法每次处理请求之前都会执行，因此不在这个方法中给模型对象赋值 使用前缀方法

\*/

@Override

public Employee getModel() \{

return employee;

/\*\*

\* 它也是每个请求都会执行，因此也不在这个里面赋值

\*/

@Override

public void prepare() throws Exception \{

System.out.println("prepare....");

public Integer getEmpId() \{

return empId;

public void setEmpId(Integer empId) \{

this.empId = empId;

## **完整action映射** ##

<?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">

<default-interceptor-ref name="paramsPrepareParamsStack"/>

</action>

</action>

<param name="actionName">getAll</param>

</result>

</action>

<result name="update">update.jsp</result>

</action>

<result type="redirectAction" name="list">getAll</result>

</action>

<result type="redirectAction" name="list">getAll</result>

</action>

</package>

</struts>

#  #

# **二级缓存配置** #

可以配置一个二级缓存对性能进行优化（hibernate配置文件中配置）

<property name="hibernate.cache.region.factory\_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

<class-cache usage="read-only" class="com.myframe.ssh.pojo.Department"/>

**SSH框架搭建完成，CRUD功能完成！！！**

[Center]: /images/20220715/470962f470834ae1a1d1868b750f0a44.png
[Image 1]: 
[Center 1]: /images/20220715/104a14c970a44b68803a671b52afe6a0.png
[Center 2]: /images/20220715/2c7ef57aa87642a7a17b1948f93ccdf7.png
[Center 3]: /images/20220715/be47eab55a3d45c98245525a67ceac82.png
[Center 4]: /images/20220715/86863198d1c4471999c406382f2a23cf.png