Spring整合Hibernate
就Hibernate的持久层访问技术而言，Spring提供了如下三个工具类（或接口）来支持DAO组件的实现：HibernateDaoSupport，HibernateTemplate，HibernateCallback。
1.使用HibernateTemplate对象
1.1定义实体
Person.java：
packagetest.domain;
publicclassPerson{
privateIntegerid;
privateStringname;
privateintage;
publicPerson(){
}
//初始化全部属性的构造器
publicPerson(Stringname,intage){
this.name=name;
this.age=age;
}
publicvoidsetId(Integerid){
this.id=id;
}
publicIntegergetId(){
returnthis.id;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicStringgetName(){
returnthis.name;
}
publicvoidsetAge(intage){
this.age=age;
}
publicintgetAge(){
returnthis.age;
}
}
1.2增加映射Person.hbm.xml：
<?xmlversion="1.0"encoding="GBK"?>
<!DOCTYPEhibernate-mappingPUBLIC
"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mappingpackage="test.domain">
<classname="Person"table="person_inf">
<idname="id"column="person_id"type="int">
<generatorclass="identity"/>
</id>
<propertyname="name"type="string"/>
<propertyname="age"type="int"/>
</class>
</hibernate-mapping>
1.3定义DAO
PersonDao.java：
packagetest.dao;
importjava.util.List;
importtest.domain.*;
publicinterfacePersonDao{
/**
*加载Person实例
*@paramid需要加载的Person实例的主键值
*@return返回加载的Person实例
*/
Personget(Integerid);
/**
*保存Person实例
*@paramperson需要保存的Person实例
*@return刚刚保存的Person实例的标识属性值
*/
Integersave(Personperson);
/**
*修改Person实例
*@paramperson需要修改的Person实例
*/
voidupdate(Personperson);
/**
*删除Person实例
*@paramid需要删除的Person实例的标识属性值
*/
voiddelete(Integerid);
/**
*删除Person实例
*@paramperson需要删除的Person实例
*/
voiddelete(Personperson);
/**
*根据用户名查找Person
*@paramname查询的人名
*@return指定用户名对应的全部Person
*/
List<Person>findByName(Stringname);
/**
*查询全部Person实例
*@return全部Person实例
*/
publicListfindAllPerson();
/**
*查询数据表中Person实例的总数
*@return数据表中Person实例的总数
*/
longgetPersonNumber();
}
PersonDaoImpl.java：
packagetest.dao.impl;
importjava.util.List;
importorg.hibernate.SessionFactory;
importorg.springframework.orm.hibernate3.HibernateTemplate;
importtest.dao.*;
importtest.domain.*;
publicclassPersonDaoImplimplementsPersonDao{
//定义一个HibernateTemplate对象，用于执行持久化操作
privateHibernateTemplateht=null;
//Hibernate持久化操作所需的SessionFactory
privateSessionFactorysessionFactory;
publicvoidsetSessionFactory(SessionFactorysessionFactory){
this.sessionFactory=sessionFactory;
}
privateHibernateTemplategetHibernateTemplate(){
if(ht==null){
ht=newHibernateTemplate(sessionFactory);
}
returnht;
}
publicPersonget(Integerid){
returngetHibernateTemplate().get(Person.class,id);
}
publicIntegersave(Personperson){
return(Integer)getHibernateTemplate().save(person);
}
publicvoidupdate(Personperson){
getHibernateTemplate().update(person);
}
publicvoiddelete(Integerid){
getHibernateTemplate().delete(get(id));
}
publicvoiddelete(Personperson){
getHibernateTemplate().delete(person);
}
publicList<Person>findByName(Stringname){
return(List<Person>)getHibernateTemplate().find(
"fromPersonpwherep.name=?",name);
}
publicListfindAllPerson(){
return(List<Person>)getHibernateTemplate().find("fromPerson");
}
publiclonggetPersonNumber(){
return(Long)getHibernateTemplate().find(
"selectcount(*)fromPersonasp").get(0);
}
}
1.4编写Spring配置文件bean.xml
当通过Hibernate进行持久层访问时，必须先获得SessionFactory对象，它是单个数据库映射关系编译后的内存镜像。一旦在Spring容器的IoC容器中配置了SessionFactoryBean，它将随应用的启动而加载，并可以充分利用IoC容器的功能，将SessionFactoryBean注入任何Bean，比如DAO组件。如下：
<?xmlversion="1.0"encoding="GBK"?>
<!--Spring配置文件的根元素，使用spring-beans-3.0.xsd语义约束-->
<beansxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!--定义数据源Bean，使用C3P0数据源实现-->
<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<!--指定连接数据库的驱动-->
<propertyname="driverClass"value="com.mysql.jdbc.Driver"/>
<!--指定连接数据库的URL-->
<propertyname="jdbcUrl"value="jdbc:mysql://localhost/aaa"/>
<!--指定连接数据库的用户名-->
<propertyname="user"value="root"/>
<!--指定连接数据库的密码-->
<propertyname="password"value="root"/>
<!--指定连接数据库连接池的最大连接数-->
<propertyname="maxPoolSize"value="40"/>
<!--指定连接数据库连接池的最小连接数-->
<propertyname="minPoolSize"value="1"/>
<!--指定连接数据库连接池的初始化连接数-->
<propertyname="initialPoolSize"value="1"/>
<!--指定连接数据库连接池的连接的最大空闲时间-->
<propertyname="maxIdleTime"value="20"/>
</bean>
<!--定义Hibernate的SessionFactory-->
<beanid="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!--依赖注入数据源，注入正是上面定义的dataSource-->
<propertyname="dataSource"ref="dataSource"/>
<!--mappingResouces属性用来列出全部映射文件-->
<propertyname="mappingResources">
<list>
<!--以下用来列出Hibernate映射文件，可使用classpath*:/test/domain/*.xml统一引用-->
<value>test/domain/Person.hbm.xml</value>
</list>
</property>
<!--定义Hibernate的SessionFactory的属性-->
<propertyname="hibernateProperties">
<!--配置Hibernate属性-->
<value>
hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect
hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=true;
</value>
</property>
</bean>
<!--定义DAOBean-->
<beanid="personDao"
class="test.dao.impl.PersonDaoImpl">
<!--注入持久化操作所需的SessionFactory-->
<propertyname="sessionFactory"ref="sessionFactory"/>
</bean>
</beans>
1.5测试
packagetest;
importorg.springframework.context.*;
importorg.springframework.context.support.*;
importtest.dao.*;
importtest.domain.*;
publicclassHibernateTest{
publicstaticvoidmain(String[]args){
//创建Spring容器
ApplicationContextctx=newClassPathXmlApplicationContext("bean.xml");
//获取DAO组件
PersonDaopdao=(PersonDao)ctx.getBean("personDao");
//循环插入10条记录
for(inti=0;i<10;i++){
pdao.save(newPerson(i+"",i+10));
}
//调用DAO组件的方法
System.out.println(pdao.getPersonNumber());
}
}
2.使用HibernateCallback实例
packagetest;
importorg.springframework.orm.hibernate3.HibernateCallback;
importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;
importorg.hibernate.Session;
importorg.hibernate.Query;
importorg.hibernate.HibernateException;
importjava.sql.SQLException;
importjava.util.List;
publicclassYeekuHibernateDaoSupportextendsHibernateDaoSupport{
/**
*使用hql语句进行分页查询
*
*@paramhql需要查询的hql语句
*@paramoffset第一条记录索引
*@parampageSize每页需要显示的记录数
*@return当前页的所有记录
*/
publicListfindByPage(finalStringhql,finalintoffset,
finalintpageSize){
//通过一个HibernateCallback对象来执行查询
Listlist=getHibernateTemplate().executeFind(newHibernateCallback(){
//实现HibernateCallback接口必须实现的方法
publicObjectdoInHibernate(Sessionsession)
throwsHibernateException,SQLException{
//执行Hibernate分页查询
Listresult=session.createQuery(hql).setFirstResult(offset)
.setMaxResults(pageSize).list();
returnresult;
}
});
returnlist;
}
/**
*使用hql语句进行分页查询
*@paramhql需要查询的hql语句
*@paramvalue如果hql有一个参数需要传入，value就是传入hql语句的参数
*@paramoffset第一条记录索引
*@parampageSize每页需要显示的记录数
*@return当前页的所有记录
*/
publicListfindByPage(finalStringhql,finalObjectvalue,
finalintoffset,finalintpageSize){
//通过一个HibernateCallback对象来执行查询
Listlist=getHibernateTemplate().executeFind(newHibernateCallback(){
//实现HibernateCallback接口必须实现的方法
publicObjectdoInHibernate(Sessionsession)
throwsHibernateException,SQLException{
//执行Hibernate分页查询
Listresult=session.createQuery(hql)
//为hql语句传入参数
.setParameter(0,value).setFirstResult(offset)
.setMaxResults(pageSize).list();
returnresult;
}
});
returnlist;
}
/**
*使用hql语句进行分页查询
*@paramhql需要查询的hql语句
*@paramvalues如果hql有多个个参数需要传入，values就是传入hql的参数数组
*@paramoffset第一条记录索引
*@parampageSize每页需要显示的记录数
*@return当前页的所有记录
*/
publicListfindByPage(finalStringhql,finalObject[]values,
finalintoffset,finalintpageSize){
//通过一个HibernateCallback对象来执行查询
Listlist=getHibernateTemplate().executeFind(newHibernateCallback(){
//实现HibernateCallback接口必须实现的方法
publicObjectdoInHibernate(Sessionsession)
throwsHibernateException,SQLException{
//执行Hibernate分页查询
Queryquery=session.createQuery(hql);
//为hql语句传入参数
for(inti=0;i<values.length;i++){
query.setParameter(i,values[i]);
}
Listresult=query.setFirstResult(offset).setMaxResults(
pageSize).list();
returnresult;
}
});
returnlist;
}
}
3.使用HibernateDaoSupport工具类
PersonDaoImpl.java（其它代码同上面一样）
packagetest.dao.impl;
importjava.util.List;
importorg.springframework.orm.hibernate3.support.*;
importtest.dao.*;
importtest.domain.*;
publicclassPersonDaoImplextendsHibernateDaoSupportimplementsPersonDao{
/**
*加载Person实例
*@paramid需要加载的Person实例的标识属性值
*@return指定id对应的Person实例
*/
publicPersonget(Integerid){
returngetHibernateTemplate().get(Person.class,id);
}
/**
*保存Person实例
*@paramperson需要保存的Person实例
*@return刚刚保存的Person实例的标识属性值
*/
publicIntegersave(Personperson){
return(Integer)getHibernateTemplate().save(person);
}
/**
*修改Person实例
*@paramperson需要修改的Person实例
*/
publicvoidupdate(Personperson){
getHibernateTemplate().update(person);
}
/**
*删除Person实例
*@paramid需要删除的Person实例的标识属性值
*/
publicvoiddelete(Integerid){
getHibernateTemplate().delete(get(id));
}
/**
*删除Person实例
*@paramperson需要删除的Person实例
*/
publicvoiddelete(Personperson){
getHibernateTemplate().delete(person);
}
/**
*根据用户名查找Person
*@paramname查询的人名
*@return指定用户名对应的全部Person
*/
publicList<Person>findByName(Stringname){
return(List<Person>)getHibernateTemplate().find(
"fromPersonpwherep.name=?",name);
}
/**
*查询全部Person实例
*@return全部Person实例
*/
publicListfindAllPerson(){
return(List<Person>)getHibernateTemplate().find("fromPerson");
}
/**
*查询数据表中Person实例的总数
*@return数据表中Person实例的总数
*/
publiclonggetPersonNumber(){
return(Long)getHibernateTemplate().find(
"selectcount(*)fromPersonasp").get(0);
}
}
4.使用声明式事务
<?xmlversion="1.0"encoding="GBK"?>
<!--指定Spring配置文件的Schema信息-->
<beansxmlns="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数据源实现-->
<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<!--指定连接数据库的驱动-->
<propertyname="driverClass"value="com.mysql.jdbc.Driver"/>
<!--指定连接数据库的URL-->
<propertyname="jdbcUrl"value="jdbc:mysql://localhost/javaee"/>
<!--指定连接数据库的用户名-->
<propertyname="user"value="root"/>
<!--指定连接数据库的密码-->
<propertyname="password"value="32147"/>
<!--指定连接数据库连接池的最大连接数-->
<propertyname="maxPoolSize"value="40"/>
<!--指定连接数据库连接池的最小连接数-->
<propertyname="minPoolSize"value="1"/>
<!--指定连接数据库连接池的初始化连接数-->
<propertyname="initialPoolSize"value="1"/>
<!--指定连接数据库连接池的连接的最大空闲时间-->
<propertyname="maxIdleTime"value="20"/>
</bean>
<!--定义Hibernate的SessionFactory-->
<beanid="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!--依赖注入数据源，注入正是上面定义的dataSource-->
<propertyname="dataSource"ref="dataSource"/>
<!--mappingResouces属性用来列出全部映射文件-->
<propertyname="mappingResources">
<list>
<!--以下用来列出Hibernate映射文件-->
<value>org/crazyit/app/domain/Person.hbm.xml</value>
</list>
</property>
<!--定义Hibernate的SessionFactory的属性-->
<propertyname="hibernateProperties">
<!--配置Hibernate属性-->
<value>
hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect
hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=true;
</value>
</property>
</bean>
<!--定义DAOBean-->
<beanid="personDao"class=
"org.crazyit.app.dao.impl.PersonDaoHibernate">
<!--注入持久化操作所需的SessionFactory-->
<propertyname="sessionFactory"ref="sessionFactory"/>
</bean>
<!--配置一个业务逻辑组件-->
<beanid="leeService"class=
"org.crazyit.app.service.impl.LeeServiceImpl">
<!--注入持久化访问所需的DAO组件-->
<propertyname="personDao"ref="personDao"/>
</bean>
<!--配置Hibernate的局部事务管理器，使用HibernateTransactionManager类-->
<!--该类实现PlatformTransactionManager接口，是针对Hibernate的特定实现-->
<beanid="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!--配置HibernateTransactionManager时需要依注入SessionFactory的引用-->
<propertyname="sessionFactory"ref="sessionFactory"/>
</bean>
<!--配置事务增强处理,指定事务管理器-->
<tx:adviceid="txAdvice"transaction-manager="transactionManager">
<!--用于配置详细的事务语义-->
<tx:attributes>
<!--所有以'get'开头的方法是read-only的-->
<tx:methodname="get*"read-only="true"/>
<!--其他方法使用默认的事务设置-->
<tx:methodname="*"/>
</tx:attributes>
</tx:advice>
<aop:config>
<!--配置一个切入点-->
<aop:pointcutid="leePointcut"
expression="bean(leeService)"/>
<!--指定在leePointcut切入点应用txAdvice事务增强处理，即在leeService里所有的方法织入事务控制-->
<aop:advisoradvice-ref="txAdvice"
pointcut-ref="leePointcut"/>
</aop:config>
</beans>