这篇文章将为大家详细讲解有关Spring+Hibernate+Struts框架整合的示例分析，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。
创新互联建站是一家朝气蓬勃的网站建设公司。公司专注于为企业提供信息化建设解决方案。从事网站开发，网站制作，网站设计，网站模板，微信公众号开发，软件开发，小程序设计，十余年建站对OPP胶袋等多个行业，拥有丰富的网站维护经验。
SSH框架整合
前言：有人说，现在还是流行主流框架，SSM都出来很久了，更不要说SSH。我不以为然。现在许多公司所用的老项目还是ssh，如果改成主流框架，需要成本。再说比如金融IT这一块，数据库dao层还是推荐使用的是hibernate，因为能够快速开发上手，除非是互联网，因涉及到高并发，dao层用的是mybatis，数据交互效率较快。所以，SSH不容忽略。
一、什么是SSH
SSH是 struts+spring+hibernate的一个集成框架，是目前比较流行的一种Web应用程序开源框架。
集成SSH框架的系统从职责上分为四层：表示层、业务逻辑层、数据持久层和域模块层，以帮助开发人员在短期内搭建结构清晰、可复用性好、维护方便的Web应用程序。其中使用Struts作为系统的整体基础架构，负责MVC的分离，在Struts框架的模型部分，控制业务跳转，利用Hibernate框架对持久层提供支持，Spring做管理，管理struts和hibernate。具体做法是：用面向对象的分析方法根据需求提出一些模型，将这些模型实现为基本的Java对象，然后编写基本的DAO(Data Access Objects)接口，并给出Hibernate的DAO实现，采用Hibernate架构实现的DAO类来实现Java类与数据库之间的转换和访问，最后由Spring做管理，管理struts和hibernate。
---------百度百科
二、SSH所涉及的部分
三、快速部署环境
这里利用保存客户的小Demo来演示整合SSH
1.导入所需jar包
1）. Struts2框架
* struts-2.3.24\apps\struts2-blank\WEB-INF\lib\*.jar -- Struts2需要的所有jar包
* struts2-spring-plugin-2.3.24.jar ---Struts2整合Spring的插件包
2）. Hibernate框架
* hibernate-release-5.0.7.Final\lib\required\*.jar -- Hibernate框架需要的jar包
* slf4j-api-1.6.1.jar -- 日志接口
* slf4j-log4j12-1.7.2.jar -- 日志实现
* MySQL-connector-java-5.1.7-bin.jar -- MySQL的驱动包
3）. Spring框架
* IOC核心包
* AOP核心包
* JDBC模板和事务核心包
* Spring整合JUnit测试包
* Spring整合Hibernate核心包
* Spring整合Struts2核心包
2、在web.xml中配置spring与struts的相关代码
1）配置struts2核心过滤器
这里定义为拦截所有
struts2
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
struts2
/*
2）配置spring的监听器
当服务启动时，就会先加载spring的配置文件
org.springframework.web.context.ContextLoaderListener
3）配置默认加载路径
contextConfigLocation
classpath:applicationContext.xml
总结：web.xml全部代码为
org.springframework.web.context.ContextLoaderListener
contextConfigLocation
classpath:applicationContext.xml
struts2
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
struts2
/*
2、src下编写相关配置文件
1)spring:applicationContext.xml
导入相关约束
2）hibernate:hibernate.cfg.xml
导入相关约束，并配置数据库
com.mysql.jdbc.Driver
jdbc:mysql://192.168.174.130:3306/SSH
root
root
org.hibernate.dialect.MySQLDialect
true
true
update
org.hibernate.connection.C3P0ConnectionProvider
3）配置log4j.properties
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 'debug' ###
log4j.rootLogger=info, stdout4)struts2:struts.xml
导入相关约束
总结：src所需配置文件如图
3、配置dao层
定义一个接口和其实现类
public interface CustomerDao {
public void save(Customer customer);
}public class CustomerDaoImpl implements CustomerDao {
public void save(Customer customer) {
}
}4、定义业务层接口和实现类
package com.clj.service;
import com.clj.domain.Customer;
public interface CustomerService {
public void save(Customer customer);
}package com.clj.service;
import org.springframework.transaction.annotation.Transactional;
import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
* 客户的业务层
* @author Administrator
*
*/
public class CustomerServiceImpl implements CustomerService{//用来保存客户
public void save(Customer customer) {
}
}5、定义pojo类
hibernate通过操作pojo类来操作数据库表，做到对象关系映射
package com.clj.domain;
public class Customer {
private Long cust_id;
private String cust_name;
private Long cust_user_id;
private Long cust_create_id;
private String cust_source;
private String cust_industry;
private String cust_level;
private String cust_linkman;
private String cust_phone;
private String cust_mobile;
public Long getCust_id() {
return cust_id;
}
public void setCust_id(Long cust_id) {
this.cust_id = cust_id;
}
public String getCust_name() {
return cust_name;
}
public void setCust_name(String cust_name) {
this.cust_name = cust_name;
}
public Long getCust_user_id() {
return cust_user_id;
}
public void setCust_user_id(Long cust_user_id) {
this.cust_user_id = cust_user_id;
}
public Long getCust_create_id() {
return cust_create_id;
}
public void setCust_create_id(Long cust_create_id) {
this.cust_create_id = cust_create_id;
}
public String getCust_source() {
return cust_source;
}
public void setCust_source(String cust_source) {
this.cust_source = cust_source;
}
public String getCust_industry() {
return cust_industry;
}
public void setCust_industry(String cust_industry) {
this.cust_industry = cust_industry;
}
public String getCust_level() {
return cust_level;
}
public void setCust_level(String cust_level) {
this.cust_level = cust_level;
}
public String getCust_linkman() {
return cust_linkman;
}
public void setCust_linkman(String cust_linkman) {
this.cust_linkman = cust_linkman;
}
public String getCust_phone() {
return cust_phone;
}
public void setCust_phone(String cust_phone) {
this.cust_phone = cust_phone;
}
public String getCust_mobile() {
return cust_mobile;
}
public void setCust_mobile(String cust_mobile) {
this.cust_mobile = cust_mobile;
}
@Override
public String toString() {
return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name
+ ", cust_user_id=" + cust_user_id + ", cust_create_id="
+ cust_create_id + ", cust_source=" + cust_source
+ ", cust_industry=" + cust_industry + ", cust_level="
+ cust_level + ", cust_linkman=" + cust_linkman
+ ", cust_phone=" + cust_phone + ", cust_mobile=" + cust_mobile
+ "]";
}
}6、定义Customer.hbm.xml
此配置文件关乎Customer这个pojo类，此文件需放在Customer pojo类同个包下
项目构建大致图
四、demo之保存客户初步演示
这里先初略的定义持久层交给heibernate，业务层交个struts2，创建实例交给spring
1、定义一个保存客户的界面，利用form表单进行数据的提交
根据域名可知，这里利用的是struts2的通配符方式进行访问
2、在struts.xml中配置接受请求，根据action名和方法跳转指定的action，执行指定的方法
spring整合struts2方式一：action由struts2框架管理
* 因为导入的struts2-spring-plugin-2.3.24.jar 包自带一个配置文件 struts-plugin.xml ，该配置文件中有如下代码
* 开启一个常量，如果该常量开启，那么下面的常量就可以使用
* struts.objectFactory.spring.autoWire = name，该常量是可以让Action的类来自动装配Bean对象！
3、在spring的applicationContext.xml中配置相对应的bean以及事务
这里利用spring中IOC(控制反转)的特性，将创建实例的任务交给spring框架管理
4、编写持久层实现类相关代码
这里利用hibernate提供的模板类，内部封转了session，从而可以调用session中的方法
/**
* 持久层
*
* @author Administrator
*
*/
public class CustomerDaoImpl implements CustomerDao {
//将数据保存到数据库中(调用模板类(hibernate提供，内部封装了session))
private HibernateTemplate hibernateTemplate;
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
/**
* 保存客户
*/
public void save(Customer customer) {
System.out.println("持久层：保存客户");
hibernateTemplate().save(customer);
}
}5、编写业务层实现类相关代码
package com.clj.service;
import org.springframework.transaction.annotation.Transactional;
import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
* 客户的业务层
* @author Administrator
*
*/
@Transactional
public class CustomerServiceImpl implements CustomerService{
private CustomerDao customerDao;
public void setCustomerDao(CustomerDao customerDao) {
this.customerDao = customerDao;
}
//用来保存客户
public void save(Customer customer) {
System.out.println("业务层，保存客户");
customerDao.save(customer);
}
}6、编写action相关代码
这里通过struts2的模板类
package com.clj.web.action;
import org.apache.struts2.ServletActionContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import com.clj.domain.Customer;
import com.clj.service.CustomerService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
/**
* 客户的控制层
* @author Administrator
*
*/
public class CustomerAction extends ActionSupport implements ModelDriven{
//不要忘记手动new
private Customer customer=new Customer();
public Customer getModel() {
return customer;
}
//提供service成员属性，提供set方法
private CustomerService customerService;
public void setCustomerService(CustomerService customerService) {
this.customerService = customerService;
}
/**
* 保存客户
* @return
*/
public String add(){
System.out.println("WEB层，保存客户");
//方式一：创建web的工厂（action由struts2创建）
WebApplicationContext context=WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
CustomerService cs=(CustomerService) context.getBean("customerService");
//调用方法
cs.save(customer);return NONE;
}
}
五、项目优化之整合
1、 spring整合struts2方式二：action由spring框架管理
把具体的 Action类配置文件applicatonContext.xml的配置文件中，但是注意：struts.xml需要做修改
2、在applicationContext.xml中配置Action类
注意：1）Spring框架默认生成CustomerAction是单例的，而Struts2框架是多例的。所以需要配置 scope="prototype"
2）此时没有struts2的自动装配，在action需要手动配置customerService属性，并在action类中生成set方法
3、.配置事务
spring整合hibernate方式一： （带有 hibernate.cfg.xml的配置文件。强调：不能加绑定当前线程的配置）
以前玩hibernate时，hibernate.cfg.xml都是由hibernate框架管理，其配置文件能生成sessionFactory,持久层加载此配置文件获取sessionFactory，从而创建工厂生成session，进行数据的增删改成，此时其配置文件应该交给spring管理，充分利用spring的IOC特性
Spring框架提供了一个HibernateDaoSupport的工具类，以后DAO都可以继承该类！！在引入hibernate核心配置文件之前，得让dao层继承一个父类HibernateDaoSupport，此父类内部封装了事务模板
看源码：
1）修改相对应的持久层实现类，让他继承HibernateDaoSupport
package com.clj.dao;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.clj.domain.Customer;
/**
* 持久层
* 继承HibernateDaoSupport，内部封装了HibernateTemplate
* @author Administrator
*
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
//将数据保存到数据库中(调用模板类(hibernate提供，内部封装了session))
/*private HibernateTemplate hibernateTemplate;
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}*/
/**
* 保存客户
*/
public void save(Customer customer) {
System.out.println("持久层：保存客户");
this.getHibernateTemplate().save(customer);
}
}2）修改业务层让，开启事务注解
package com.clj.service;
import org.springframework.transaction.annotation.Transactional;
import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
* 客户的业务层
* @author Administrator
*
*/
@Transactional
public class CustomerServiceImpl implements CustomerService{
private CustomerDao customerDao;
public void setCustomerDao(CustomerDao customerDao) {
this.customerDao = customerDao;
}
//用来保存客户
public void save(Customer customer) {
System.out.println("业务层，保存客户");
customerDao.save(customer);
}
}3）修改applicationContext.xml文件
先引入hibernate配置文件
配置平台事务管理：用来管理事务， 注意现在使用的是 Hibernate框架，所以需要使用Hibernate框架的事务管理器
开启事务注解
去除模板类配置，并为持久层配置sessionFactory
全部代码如下
4）修改action类
因为注入了业务层实现类，所以此时可以直接调用业务层方法，无须加载bean
package com.clj.web.action;
import org.apache.struts2.ServletActionContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import com.clj.domain.Customer;
import com.clj.service.CustomerService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
/**
* 客户的控制层
* @author Administrator
*
*/
public class CustomerAction extends ActionSupport implements ModelDriven{
//不要忘记手动new
private Customer customer=new Customer();
public Customer getModel() {
return customer;
}
//提供service成员属性，提供set方法
private CustomerService customerService;
public void setCustomerService(CustomerService customerService) {
this.customerService = customerService;
}
/**
* 保存客户
* @return
*/
public String add(){
System.out.println("WEB层，保存客户");
//方式一：创建web的工厂（action由struts2创建）
/*WebApplicationContext context=WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
CustomerService cs=(CustomerService) context.getBean("customerService");
//调用方法
cs.save(customer);*/
customerService.save(customer);
return NONE;
}
}
spring整合hibernate方式二： （不带有 hibernate.cfg.xml的配置文件）
这里准备删除hibernate的核心配置文件，在删除之前，需要将其配置文件中的相关内容配置到spring的applicatioinContext.xml文件中取
1、查看hibernate.cfg.xml文件中的相关内容
* 数据库连接基本参数（4大参数）
* Hibernate相关的属性
* 连接池
* 映射文件
2、引入配置
引入连接池
修改对应的sessionFactory: 因为已经没有了 hibernate.cfg.xml的配置文件，所以需要修改该配置，注入连接池
引入对象映射文件：因为已经没有了hibernate.cfg.xml的配置文件，不会扫描到该配置文件，需要注入
org.hibernate.dialect.MySQLDialect
true
true
update
com/clj/domain/Customer.hbm.xml
现在：applicationContext.xml全部代码如下
org.hibernate.dialect.MySQLDialect
true
true
update
com/clj/domain/Customer.hbm.xml
此时可以安心的删除hibernate.cfg.xml文件了
这样SSH整合完毕
六、Hibernate模板常用方法
注意：以下代码省略了接口中的演示(偷了个懒，相信初学者不会看不懂)
1）插入：
持久层
package com.clj.dao;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.clj.domain.Customer;
/**
* 持久层
* 继承HibernateDaoSupport，内部封装了HibernateTemplate
* @author Administrator
*
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
@Override
public void update(Customer customer) {
// TODO Auto-generated method stub
this.getHibernateTemplate().update(customer);
}
}业务层
package com.clj.service;
import java.util.List;
import org.springframework.transaction.annotation.Transactional;
import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
* 客户的业务层
* @author Administrator
*
*/
@Transactional
public class CustomerServiceImpl implements CustomerService{
private CustomerDao customerDao;
public void setCustomerDao(CustomerDao customerDao) {
this.customerDao = customerDao;
}
@Override
public void update(Customer customer) {
// TODO Auto-generated method stub
customerDao.update(customer);
}
}测试类
package com.clj.test;
import java.util.List;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.clj.domain.Customer;
import com.clj.service.CustomerService;
/**
* 测试Hiberante模板类的简单方法
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
@Resource(name="customerService")
private CustomerService customerService;
/**
* 测试插入
*/
@Test
public void run1(){
Customer customer=new Customer();
customer.setCust_id(1L);
customer.setCust_name("测试");
customerService.update(customer);
}
}2）以下为指定查询、查询所有、离线查询代码
持久层
package com.clj.dao;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.clj.domain.Customer;
/**
* 持久层
* 继承HibernateDaoSupport，内部封装了HibernateTemplate
* @author Administrator
*
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
//将数据保存到数据库中(调用模板类(hibernate提供，内部封装了session))
/*private HibernateTemplate hibernateTemplate;
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}*/
/**
* 保存客户
*/
public void save(Customer customer) {
System.out.println("持久层：保存客户");
this.getHibernateTemplate().save(customer);
}
@Override
public void update(Customer customer) {
// TODO Auto-generated method stub
this.getHibernateTemplate().update(customer);
}
/**
* 通过主键查询
*/
public Customer getById(Long id) {
return this.getHibernateTemplate().get(Customer.class, id);
}
/**
* 查询所有
*/
@Override
public List findAll() {
String sql="from Customer";
List list=(List) this.getHibernateTemplate().find(sql);
return list;
}
/**
* QBC离线查询
*/
@Override
public List findAllByQBC() {
DetachedCriteria criteria=DetachedCriteria.forClass(Customer.class);
List list=(List) this.getHibernateTemplate().findByCriteria(criteria);
return list;
}
}业务层
package com.clj.service;
import java.util.List;
import org.springframework.transaction.annotation.Transactional;
import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
* 客户的业务层
* @author Administrator
*
*/
@Transactional
public class CustomerServiceImpl implements CustomerService{
private CustomerDao customerDao;
public void setCustomerDao(CustomerDao customerDao) {
this.customerDao = customerDao;
}
//用来保存客户
public void save(Customer customer) {
System.out.println("业务层，保存客户");
customerDao.save(customer);
}
@Override
public void update(Customer customer) {
// TODO Auto-generated method stub
customerDao.update(customer);
}
@Override
public Customer getById(Long id) {
// TODO Auto-generated method stub
return customerDao.getById(id);
}
@Override
public List findAll() {
return customerDao.findAll();
}
@Override
public List findAllByQBC() {
// TODO Auto-generated method stub
return customerDao.findAllByQBC();
}
}测试类
package com.clj.test;
import java.util.List;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.clj.domain.Customer;
import com.clj.service.CustomerService;
/**
* 测试Hiberante模板类的简单方法
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
@Resource(name="customerService")
private CustomerService customerService;
/**
* 测试插入
*/
@Test
public void run1(){
Customer customer=new Customer();
customer.setCust_id(1L);
customer.setCust_name("测试");
customerService.update(customer);
}
/**
* 测试查询指定的客户
*/
@Test
public void run2(){
Customer customer=customerService.getById(2L);
System.out.println(customer);
}
/**
* 查询所有的客户
*/
@Test
public void run3(){
List list=customerService.findAll();
System.out.println(list);
}
/**
* QBC(离线查询)
*/
@Test
public void run4(){
List list=customerService.findAllByQBC();
System.out.println(list);
}
}七、关于SSH延迟加载问题
1. 使用延迟加载的时候，再WEB层查询对象的时候程序会抛出异常！
* 原因是延迟加载还没有发生SQL语句，在业务层session对象就已经销毁了，所以查询到的JavaBean对象已经变成了托管态对象！
* 注意：一定要先删除javassist-3.11.0.GA.jar包（jar包冲突了）
2. 解决办法
Spring框架提供了一个过滤器，让session对象在WEB层就创建，在WEB层销毁。只需要配置该过滤器即可
* 但是：要注意需要在struts2的核心过滤器之前进行，spring监听器之后配置
OpenSessionInViewFilter
org.springframework.orm.hibernate5.support.OpenSessionInViewFilter
OpenSessionInViewFilter
/*
3、演示延迟加载
持久层：调用load方法，此方法时延迟加载的
/**
* 延迟加载
*/
@Override
public Customer loadById(long id) {
// TODO Auto-generated method stub
return this.getHibernateTemplate().load(Customer.class, id);
}业务层
@Override
public Customer loadById(long id) {
// TODO Auto-generated method stub
return customerDao.loadById(id);
}测试类
@Test
public void run5(){
Customer customer=customerService.loadById(2L);
System.out.println(customer);
}关于“Spring+Hibernate+Struts框架整合的示例分析”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。
当前文章：Spring+Hibernate+Struts框架整合的示例分析
浏览路径：
http://chengdu.cdxwcx.cn/article/gohjeh.html
