Struts2+Hibernate+Spring 整合示例

Spring整合Struts2、Hibernate原理概述：

从用户角度来看，用户发出HTTP请求，当MVC框架的控制器组件拦截到用户请求时，将调用系统的业务逻辑组件，业务逻辑组件则调用系统的DAO组件，而DAO组件则依赖于SessionFactory和DataSource等底层组件实现数据库访问。

从系统实现角度看，Ioc容器先创建SessionFactory和DataSource等底层组件，然后将这些底层组件注入给DAO组件，提供一个完整的DAO组件，并将此DAO组件注入给业务逻辑组件，从而提供一个完整的业务逻辑组件，而业务逻辑组件又被注入给控制器组件，控制器组件负责拦截用户请求，并将处理结果呈现给用户——这一系列的衔接，都由Spring的IoC容器提供实现。

简单来说，Spring通过IoC容器上管（Struts2）Action的创建并依赖注入给控制器，下管（Hibernate）SessionFactory的创建并依赖注入给DAO组件，是一个巨大的工厂。（个人理解）

源代码下载：Regist_S2SH.rar

1.项目结构：

2.web.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 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_2_5.xsd">
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
	<!-- 使用ContextLoaderListener初始化Spring容器 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<!-- 定义Struts 2的FilterDispathcer的Filter -->
	<filter>
		<filter-name>struts2</filter-name>
		<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
	</filter>
	<!-- FilterDispatcher用来初始化Struts 2并且处理所有的WEB请求。 -->
	<filter-mapping>
		<filter-name>struts2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
</web-app>

3.applicationContext.xml配置

<?xml version="1.0" encoding="GBK"?>
<!-- 指定Spring配置文件的Schema信息 -->
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	<!-- 定义数据源Bean，使用C3P0数据源实现 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<!-- 指定连接数据库的驱动 -->
		<property name="driverClass" value="com.mysql.jdbc.Driver"/>
		<!-- 指定连接数据库的URL -->
		<property name="jdbcUrl" value="jdbc:mysql://localhost/javaee"/>
		<!-- 指定连接数据库的用户名 -->
		<property name="user" value="root"/>
		<!-- 指定连接数据库的密码 -->
		<property name="password" value="1120"/>
		<!-- 指定连接数据库连接池的最大连接数 -->
		<property name="maxPoolSize" value="40"/>
		<!-- 指定连接数据库连接池的最小连接数 -->
		<property name="minPoolSize" value="1"/>
		<!-- 指定连接数据库连接池的初始化连接数 -->
		<property name="initialPoolSize" value="1"/>
		<!-- 指定连接数据库连接池的连接的最大空闲时间 -->
		<property name="maxIdleTime" value="20"/>
	</bean>
	<!-- 定义Hibernate的SessionFactory -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<!-- 依赖注入数据源，注入正是上面定义的dataSource -->
		<property name="dataSource" ref="dataSource"/>
		<!-- mappingResouces属性用来列出全部映射文件 -->
		<property name="mappingResources">
			<list>
				<!-- 以下用来列出Hibernate映射文件 -->
				<value>com/xqh/model/Person.hbm.xml</value>
			</list>
		</property>
		<!-- 定义Hibernate的SessionFactory的属性 -->
		<property name="hibernateProperties">
			<!-- 配置Hibernate属性 -->
			<value>
			hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect
			hibernate.hbm2ddl.auto=update
			hibernate.show_sql=true
			hibernate.format_sql=true;
			</value>
		</property>
	</bean>
	<!-- 定义DAO Bean-->
	<bean id="personDao" class=
	"com.xqh.dao.impl.PersonDaoHibernate">
		<!-- 注入持久化操作所需的SessionFactory -->
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
	<!-- 配置一个业务逻辑组件 -->
	<bean id="service" class=
	"com.xqh.service.impl.ServiceImpl">
		<!-- 注入持久化访问所需的DAO组件 -->
		<property name="personDao" ref="personDao"/>
	</bean>


	<!-- 配置Hibernate的局部事务管理器，使用HibernateTransactionManager类 -->
	<!-- 该类实现PlatformTransactionManager接口，是针对Hibernate的特定实现-->
	<bean id="transactionManager" 
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<!-- 配置HibernateTransactionManager时需要依注入SessionFactory的引用 -->
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
	<!-- 配置事务增强处理,指定事务管理器 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<!-- 用于配置详细的事务语义 -->
		<tx:attributes>
			<!-- 所有以'get'开头的方法是read-only的 -->
			<tx:method name="get*" read-only="true"/>
			<!-- 其他方法使用默认的事务设置 -->
			<tx:method name="*"/>
		</tx:attributes>
	</tx:advice>
	<aop:config>
		<!-- 配置一个切入点 -->
		<aop:pointcut id="pointcut"
			expression="bean(service)"/>
		<!-- 指定在pointcut切入点应用txAdvice事务增强处理 -->
		<aop:advisor advice-ref="txAdvice" 
			pointcut-ref="pointcut"/>
	</aop:config>

</beans>

4.struts.xml配置：

<?xml version="1.0" encoding="GBK"?>
<!-- 指定Struts 2配置文件的DTD信息 -->
<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN"
	"http://struts.apache.org/dtds/struts-2.1.7.dtd">
<!-- Struts 2配置文件的根元素 -->
<struts>
	<!-- 配置了系列常量 -->
	<constant name="struts.i18n.encoding" value="GBK"/>	
	<constant name="struts.devMode" value="true"/>	
	<package name="xqh" extends="struts-default">
		<!-- 定义处理用户请求的Action，指定该Action的实现类-->
		<action name="registPro" 
			class="com.xqh.action.RegistAction">
			<!-- 为两个逻辑视图配置视图页面 -->
			<result name="error">/error.jsp</result>
			<result name="success">/welcome.jsp</result>
		</action>
		<!-- 让用户直接访问该应用时列出所有视图页面 -->
		<action name="*">
			<result>/{1}.jsp</result>
		</action>
	</package>
</struts>

5.RegistAction.java代码清单：

package com.xqh.action;

import com.opensymphony.xwork2.Action;
import com.xqh.model.Person;
import com.xqh.service.Service;

public class RegistAction
	implements Action
{
	//下面是用于封装用户请求参数的属性
	private Person person;
	//用于封装处理结果的属性
	private String tip;
	//系统所用的业务逻辑组件
	private Service service;
	//设置注入业务逻辑组件所必需的setter方法
	public void setService(Service service)
	{
		this.service = service;
	}

	//person属性的setter和getter方法
	public void setPerson(Person person)
	{
		this.person = person;
	}
	public Person getPerson()
	{
		return this.person;
	}

	//tip属性的setter和getter方法
	public void setTip(String tip)
	{
		this.tip = tip;
	}
	public String getTip()
	{
		return this.tip;
	}

	//处理用户请求的execute方法
	public String execute()
		throws Exception
	{
		//调用业务逻辑组件的regist方法来处理请求
		if (service.regist(person))
		{
			setTip("哈哈，注册成功！");
			return SUCCESS;
		}
		else
		{
			return ERROR;
		}
	}
}

6.personDao.java 代码清单：

package com.xqh.dao;


import java.util.List;

import com.xqh.model.Person;

public interface PersonDao 
{
	/**
	 * 加载Person实例
	 * @param id 需要加载的Person实例的主键值
	 * @return 返回加载的Person实例
	 */ 
	Person get(Integer id);
	 
	/**
	 * 保存Person实例
	 * @param person 需要保存的Person实例
	 * @return 刚刚保存的Person实例的标识属性值
	 */	
	Integer save(Person person);
	
	/**
	 * 修改Person实例
	 * @param person 需要修改的Person实例
	 */
	void update(Person person);
	
	/**
	 * 删除Person实例
	 * @param id 需要删除的Person实例的标识属性值
	 */
	void delete(Integer id);
	
	/**
	 * 删除Person实例
	 * @param person 需要删除的Person实例
	 */
	void delete(Person person);
	
	/**
	 * 根据用户名查找Person
	 * @param name 查询的人名
	 * @return 指定用户名对应的全部Person
	 */
	List<Person> findByName(String name);
	
	/**
	 * 查询全部Person实例
	 * @return 全部Person实例
	 */
	public List<Person> findAllPerson();
}

7.personDaoHibernate.java代码清单：

package com.xqh.dao.impl;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.xqh.dao.PersonDao;
import com.xqh.model.Person;

import java.util.*;

public class PersonDaoHibernate
	extends HibernateDaoSupport implements PersonDao
{
	/**
	 * 加载Person实例
	 * @param id 需要加载的Person实例的标识属性值
	 * @return 指定id对应的Person实例
	 */ 
	public Person get(Integer id)
	{
		return getHibernateTemplate()
			.get(Person.class, id); 
	}
	
	/**
	 * 保存Person实例
	 * @param person 需要保存的Person实例
	 * @return 刚刚保存的Person实例的标识属性值
	 */   
	public Integer save(Person person)
	{
		return (Integer)getHibernateTemplate()
			.save(person);
	}
	
	/**
	 * 修改Person实例
	 * @param person 需要修改的Person实例
	 */
	public void update(Person person)
	{
		getHibernateTemplate().update(person);
	}
	
	/**
	 * 删除Person实例
	 * @param id 需要删除的Person实例的标识属性值
	 */
	public void delete(Integer id)
	{
		getHibernateTemplate().delete(get(id));
	}
	
	/**
	 * 删除Person实例
	 * @param person 需要删除的Person实例
	 */
	public void delete(Person person)
	{
		getHibernateTemplate().delete(person);
	}
	
	/**
	 * 根据用户名查找Person
	 * @param name 查询的人名
	 * @return 指定用户名对应的全部Person
	 */
	@SuppressWarnings("unchecked")
	public List<Person> findByName(String name)
	{
		return (List<Person>)getHibernateTemplate()
			.find("from Person p where p.name like ?" , name);
	}
	
	/**
	 * 查询全部Person实例
	 * @return 全部Person实例
	 */
	@SuppressWarnings("unchecked")
	public List<Person> findAllPerson()
	{
		return (List<Person>)getHibernateTemplate()
			.find("from Person");
	}
}

8.Person.java代码清单：

package com.xqh.model;

public class Person
{
	private Integer id;
	private String name;
	private int age;
	
	//无参数的构造器
	public Person()
	{
	}
	//初始化全部属性的构造器
	public Person(String name , int age)
	{
		this.name = name;
		this.age = age;
	}
	
	//id属性的setter和getter方法
	public void setId(Integer id)
	{
		this.id = id;
	}
	public Integer getId()
	{
		return this.id;
	}
	
	//name属性的setter和getter方法
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}	//age属性的setter和getter方法
	public void setAge(int age)
	{
		this.age = age;
	}
	public int getAge()
	{
		return this.age;
	}
}

9.Person.hbm.xml配置：

<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.xqh.model">
	<class name="Person" table="tb_person">
		<!-- 映射标识属性 -->
		<id name="id" column="Id"
			type="int">
			<!-- 指定主键生成器策略 -->
			<generator class="increment"/>
		</id>
		<!-- 映射普通属性 -->
		<property name="name" type="string"/>
		<property name="age" type="int"/>
	</class>
</hibernate-mapping>

10.Service.java代码清单：

package com.xqh.service;

import com.xqh.model.Person;

public interface Service 
{
	//注册用户
	boolean regist(Person person);
}

11.ServiceImpl.java代码清单：

package com.xqh.service.impl;

import com.xqh.dao.PersonDao;
import com.xqh.model.Person;
import com.xqh.service.Service;

public class ServiceImpl
	implements Service
{
	private PersonDao personDao;
	//依赖注入DAO组件所需的setter方法
	public void setPersonDao(PersonDao personDao)
	{
		this.personDao = personDao;
	}
	//注册用户
	public boolean regist(Person person)
	{
		//调用DAO组件的方法来实现业务逻辑
		int result = personDao.save(person);
		if (result > 0)
		{
			return true;
		}
		return false;
	}
}

12.运行结果：