关于HibnernateDaoSupporrt(转载。备忘，不是很重要)

最新推荐文章于 2017-08-20 15:26:00 发布
最新推荐文章于 2017-08-20 15:26:00 发布
阅读量564 收藏
点赞数
分类专栏： spring

3。HibernateDaoSupport 基类：

一个回调实现能够有效地在任何Hibernate数据访问中使用。HibernateTemplate 会确保当前Hibernate的 Session 实例的正确打开和关闭，并直接参与到事务管理中去。 Template实例不仅是线程安全的，同时它也是可重用的。因而他们可以作为外部对象的实例变量而被持有。对于那些简单的诸如find、load、saveOrUpdate或者delete操作的调用，HibernateTemplate 提供可选择的快捷函数来替换这种回调的实现。 不仅如此，Spring还提供了一个简便的 HibernateDaoSupport 基类，这个类提供了 setSessionFactory(..) 方法来接受一个 SessionFactory 对象，同时提供了 getSessionFactory() 和 getHibernateTemplate() 方法给子类使用。实例如下：

Java代码 复制代码 收藏代码
  1. public class ProductDaoImpl extends HibernateDaoSupport implements ProductDao {
  3. public Collection loadProductsByCategory(String category) throws DataAccessException {
  4. return this.getHibernateTemplate().find(
  5. "from test.Product product where product.category=?", category);
  6. }
  7. } 
public class ProductDaoImpl extends HibernateDaoSupport implements ProductDao {

    public Collection loadProductsByCategory(String category) throws DataAccessException {
        return this.getHibernateTemplate().find(
            "from test.Product product where product.category=?", category);
    }
}

4。HibernateDaoSupport 基类使用技巧：

HibernateDaoSupport这也是使用HibernateTemplate的方法之一，只是需要dao继承这个类：

Java代码 复制代码 收藏代码
  1. public class LogDaoImpl extends HibernateDaoSupport implements LogDao {
  2. @Override
  3. public void save(Log log) {
  4. this.getHibernateTemplate().save(log);
  5. //this.save(log);
  6. System.out.println("log save...");
  7. }
  8. } 
public class LogDaoImpl extends HibernateDaoSupport implements LogDao {
	@Override
	public void save(Log log) {		
			this.getHibernateTemplate().save(log);
			//this.save(log);
		System.out.println("log save...");
	}
}

dao继承了HibernateDaoSupport类，而这个又拥有sessionFactory和hibernateTemplate的setXXX方法，只要我在初始化这个dao时，注入两个其中一个就可以了。但是这两个setXX方法都为final的，因为不可以重写，这样就不能使用annotation的方式了，只能使用xml的方法了。HibernateDaoSupport部分源代码如下：

Java代码 复制代码 收藏代码
  1. public abstract class HibernateDaoSupport extends DaoSupport{
  2. private HibernateTemplate hibernateTemplate;
  4. public final void setSessionFactory(SessionFactory sessionFactory) {
  5. //......
  6. }
  7. }
  9. public final void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
  10. this.hibernateTemplate = hibernateTemplate;
  11. }
  13. public final HibernateTemplate getHibernateTemplate() {
  14. return this.hibernateTemplate;
  15. }
  16. //.......其他方法
  17. } 
public abstract class HibernateDaoSupport extends DaoSupport{
      private HibernateTemplate hibernateTemplate;
    
     public final void setSessionFactory(SessionFactory sessionFactory) {
		//......
		}
	}

public final void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
		this.hibernateTemplate = hibernateTemplate;
	}

public final HibernateTemplate getHibernateTemplate() {
	  return this.hibernateTemplate;
	}
//.......其他方法
}

xml注入方法如下：

Java代码 复制代码 收藏代码
  1. <bean id="logDaoImpl" class="example.dao.impl.LogDaoImpl">
  2. <property name="hibernateTemplate" ref="hibernateTemplate"></property>
  3. </bean> 
<bean id="logDaoImpl" class="example.dao.impl.LogDaoImpl">
  	<property name="hibernateTemplate" ref="hibernateTemplate"></property>
  </bean>

但是问题又来了，如果dao有多个(甚至几个以上)，这样就会有大量的xml配置文件，每个dao需要一个配置一个bean，并且在这个bean中需要注入一个sessionFactory或是hibernateTemplate，这样的工作量是非常的大，并且容易出错。
针对有大量的dao我们提供一个解决方案：
我们可以创建一个类，并且这个类来继承hibernateDaoSupport这个类，由于hibernateDaoSupport类的sessionFactory和hibernateTemplate的setXXX方法是final的，因此不能重写，但我们可以在这个类中注入一个sessionFactory或hibernateTemplate但是setXXX方法名，用其它的。然后让dao来继承这个类，这就dao就可以使用annotation方式注解了。代码如下：

Java代码 复制代码 收藏代码
  1. @Component
  2. public class SuperDao extends HibernateDaoSupport {
  3. @Resource(name="hibernateTemplate")
  4. public void setSuperHibernateTemplate(HibernateTemplate hibernateTemplate ){
  5. //在这里为父类HibernateDaoSuppport注入hibernateTemplate或是sessionFactory
  6. super.setHibernateTemplate(hibernateTemplate);
  7. }
  8. } 
@Component
public class SuperDao extends HibernateDaoSupport {
	@Resource(name="hibernateTemplate")
	public void setSuperHibernateTemplate(HibernateTemplate hibernateTemplate ){
		//在这里为父类HibernateDaoSuppport注入hibernateTemplate或是sessionFactory
		super.setHibernateTemplate(hibernateTemplate);
	}
}

其它的dao继承这个就可以了，如下所示：

Java代码 复制代码 收藏代码
  1. @Component
  2. public class LogDaoImpl extends SuperDao implements LogDao {
  3. @Override
  4. public void save(Log log) {
  5. this.getHibernateTemplate().save(log);
  6. //this.save(log);
  7. System.out.println("log save...");
  8. }
  9. } 
@Component
public class LogDaoImpl extends SuperDao implements LogDao {
	@Override
	public void save(Log log) {
			this.getHibernateTemplate().save(log);
			//this.save(log);
		System.out.println("log save...");
	}
}

其他的用法不在这里累述,请参看Spring的参考文档.下面重点说说Spring HibernateTemplate模板方法与Callback机制.

二。HibernateTemplate源码分析

下面以save()方法为例进行说明,先看源代码:

HibernateCallback接口的代码如下, 它只有一个方法doInHibernate方法:

Java代码 复制代码 收藏代码
  1. public interface HibernateCallback {
  2. Object doInHibernate(Session session) throws HibernateException, SQLException;
  3. } 
public interface HibernateCallback {
       Object doInHibernate(Session session) throws HibernateException, SQLException;
}

HibernateTemplate中的具体操作的方法，如save(),update()的具体实现都采用匿名类的方式实现了该接口，在doInHibernate中完成具体的操作。以save()方法为例：

Java代码 复制代码 收藏代码
  1. public Serializable save(final Object entity) throws DataAccessException {
  2. return (Serializable) executeWithNativeSession(new HibernateCallback() {
  3. public Object doInHibernate(Session session) throws HibernateException {
  4. checkWriteOperationAllowed(session);
  5. return session.save(entity);
  6. }
  7. });
  8. } 
public Serializable save(final Object entity) throws DataAccessException {
		return (Serializable) executeWithNativeSession(new HibernateCallback() {
			public Object doInHibernate(Session session) throws HibernateException {
				checkWriteOperationAllowed(session);
				return session.save(entity);
			}
		});
	}

这段代码重点注意以匿名类的方式实现了 HibernateCallback接口.

然后是executeWithNativeSession()方法如下,在此方法中调用核心方法doExecute,如下所示:

Java代码 复制代码 收藏代码
  1. public Object executeWithNativeSession(HibernateCallback action) {
  2. return doExecute(action, false, true);
  3. } 
public Object executeWithNativeSession(HibernateCallback action) {
		return doExecute(action, false, true);
	}

在这个方法中使用本地已存在的Session去执行此次save操作,doExecute代码如下所示:

Java代码 复制代码 收藏代码
  1. /**
  2. * Execute the action specified by the given action object within a Session.
  3. * @param action callback object that specifies the Hibernate action
  4. * @param enforceNewSession whether to enforce a new Session for this template
  5. * even if there is a pre-bound transactional Session
  6. * @param enforceNativeSession whether to enforce exposure of the native
  7. * Hibernate Session to callback code
  8. * @return a result object returned by the action, or <code>null</code>
  9. * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
  10. */
  11. protected Object doExecute(HibernateCallback action, boolean enforceNewSession, boolean enforceNativeSession)
  12. throws DataAccessException {
  14. Assert.notNull(action, "Callback object must not be null");
  16. Session session = (enforceNewSession ?
  17. SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor()) : getSession());
  18. boolean existingTransaction = (!enforceNewSession &&
  19. (!isAllowCreate() || SessionFactoryUtils.isSessionTransactional(session, getSessionFactory())));
  20. if (existingTransaction) {
  21. logger.debug("Found thread-bound Session for HibernateTemplate");
  22. }
  24. FlushMode previousFlushMode = null;
  25. try {
  26. previousFlushMode = applyFlushMode(session, existingTransaction);
  27. enableFilters(session);
  28. Session sessionToExpose =
  29. (enforceNativeSession || isExposeNativeSession() ? session : createSessionProxy(session));
  30. Object result = action.doInHibernate(sessionToExpose);
  31. flushIfNecessary(session, existingTransaction);
  32. return result;
  33. }
  34. catch (HibernateException ex) {
  35. throw convertHibernateAccessException(ex);
  36. }
  37. catch (SQLException ex) {
  38. throw convertJdbcAccessException(ex);
  39. }
  40. catch (RuntimeException ex) {
  41. // Callback code threw application exception...
  42. throw ex;
  43. }
  44. finally {
  45. if (existingTransaction) {
  46. logger.debug("Not closing pre-bound Hibernate Session after HibernateTemplate");
  47. disableFilters(session);
  48. if (previousFlushMode != null) {
  49. session.setFlushMode(previousFlushMode);
  50. }
  51. }
  52. else {
  53. // Never use deferred close for an explicitly new Session.
  54. if (isAlwaysUseNewSession()) {
  55. SessionFactoryUtils.closeSession(session);
  56. }
  57. else {
  58. SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, getSessionFactory());
  59. }
  60. }
  61. }
  62. } 
/**
	 * Execute the action specified by the given action object within a Session.
	 * @param action callback object that specifies the Hibernate action
	 * @param enforceNewSession whether to enforce a new Session for this template
	 * even if there is a pre-bound transactional Session
	 * @param enforceNativeSession whether to enforce exposure of the native
	 * Hibernate Session to callback code
	 * @return a result object returned by the action, or <code>null</code>
	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
	 */
	protected Object doExecute(HibernateCallback action, boolean enforceNewSession, boolean enforceNativeSession)
			throws DataAccessException {

		Assert.notNull(action, "Callback object must not be null");

		Session session = (enforceNewSession ?
				SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor()) : getSession());
		boolean existingTransaction = (!enforceNewSession &&
				(!isAllowCreate() || SessionFactoryUtils.isSessionTransactional(session, getSessionFactory())));
		if (existingTransaction) {
			logger.debug("Found thread-bound Session for HibernateTemplate");
		}

		FlushMode previousFlushMode = null;
		try {
			previousFlushMode = applyFlushMode(session, existingTransaction);
			enableFilters(session);
			Session sessionToExpose =
					(enforceNativeSession || isExposeNativeSession() ? session : createSessionProxy(session));
			Object result = action.doInHibernate(sessionToExpose);
			flushIfNecessary(session, existingTransaction);
			return result;
		}
		catch (HibernateException ex) {
			throw convertHibernateAccessException(ex);
		}
		catch (SQLException ex) {
			throw convertJdbcAccessException(ex);
		}
		catch (RuntimeException ex) {
			// Callback code threw application exception...
			throw ex;
		}
		finally {
			if (existingTransaction) {
				logger.debug("Not closing pre-bound Hibernate Session after HibernateTemplate");
				disableFilters(session);
				if (previousFlushMode != null) {
					session.setFlushMode(previousFlushMode);
				}
			}
			else {
				// Never use deferred close for an explicitly new Session.
				if (isAlwaysUseNewSession()) {
					SessionFactoryUtils.closeSession(session);
				}
				else {
					SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, getSessionFactory());
				}
			}
		}
	}

doExecute这个方法有点过于复杂,不容易理解,现在我用差不多是伪代码的形式来把doExecute这个方法的大概意思写出为，以便大家理解：

Java代码 复制代码 收藏代码
  1. public class MyHibernateTemplate {
  3. public Object executeWithNativeSession(HibernateCallback action) {
  4. return doExecute(action, false, true);
  5. }
  7. protected Object doExecute(HibernateCallback action, boolean enforceNewSession, boolean enforceNativeSession){
  8. Session session = null;
  9. try {
  10. session = getSession();
  11. session.beginTransaction();
  12. action.doInHibernate(session);
  13. session.getTransaction().commit();
  14. } catch (Exception e) {
  15. session.getTransaction().rollback();
  16. }finally{
  17. //....进行额外处理
  18. }
  19. return null;
  20. }
  22. private Session getSession() {
  23. // TODO Auto-generated method stub
  24. return new Session();
  25. }
  26. } 
public class MyHibernateTemplate {

	public Object executeWithNativeSession(HibernateCallback action) {
		return doExecute(action, false, true);
	}
	
	protected Object doExecute(HibernateCallback action, boolean enforceNewSession, boolean enforceNativeSession){
		Session session = null;
		try {
			session = getSession();
			session.beginTransaction();
			action.doInHibernate(session);
			session.getTransaction().commit();
		} catch (Exception e) {
			session.getTransaction().rollback();
		}finally{
			//....进行额外处理
		}
		return null;
	}

	private Session getSession() {
		// TODO Auto-generated method stub
		return new Session();
	}
}

如果你觉得使用匿名内部类传参的方式不好理解，你可以先写一个特定针对save操作的实现类来帮助理解它，如下所示：

Java代码 复制代码 收藏代码
  1. public class HibernateSaveCallbackImpl implements HibernateCallback {
  3. private Object object ;
  4. public HibernateSaveCallbackImpl(){}
  5. public HibernateSaveCallbackImpl(Object object){
  6. this.object = object;
  7. }
  8. public Object doInHibernate(Session session) throws HibernateException,
  9. SQLException {
  10. session.save(object);
  11. return null;
  12. }
  13. } 
public class HibernateSaveCallbackImpl implements HibernateCallback {

	private Object object ;
	public HibernateSaveCallbackImpl(){}
	public HibernateSaveCallbackImpl(Object object){
		this.object = object;
	}
	public Object doInHibernate(Session session) throws HibernateException,
			SQLException {
		session.save(object);
		return null;
	}
}

然后再实例化一个HibernateSaveCallbackImpl对象传给MyHibernateTemplate进行使用,如下所示：

Java代码 复制代码 收藏代码
  1. public static void main(String[] args) {
  2. HibernateCallback callback = new HibernateSaveCallbackImpl();
  3. HibernateCallback callback2 = new HibernateSaveCallbackImpl("save this object");
  4. new MyHibernateTemplate().executeWithNativeSession(callback);
  5. } 
public static void main(String[] args) {
		HibernateCallback callback = new HibernateSaveCallbackImpl();
		HibernateCallback callback2 = new HibernateSaveCallbackImpl("save this object");
		new MyHibernateTemplate().executeWithNativeSession(callback);
	}

当MyHibernateTemplate中的doExecute方法执行时，执行到

Java代码 复制代码 收藏代码
  1. action.doInHibernate(session); 
action.doInHibernate(session);

时，它会先去执行你传入的引用（也就是你自己）的方法。所以称为回调，这与模板模式中的钩子函数基本是一样的。其实回调，简单的可以说是：将自己的引用传给别的方法，在别的方法里面，通过自己的引用调用自己的方法。

千年祸害万年牢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
新三板关于员工股权激励计划的备忘录.docx
04-27
新三板/IPO:关于员工股权激励计划的备忘录 一、基本概况 （一）股权激励对象 公司拟对核心员工进行股权激励，既包括对公司发展作出突出贡献的老员工，也包括公司认为应当激励的其他员工。贵司可以根据企业自身...
Spring HibernateTemplate与Callback
xx510long的博客
08-27 108
     Spring中 Callback模式和Template模式合用 随处可见。下面以常用的HibernateTemplate为例进行简要简述。      在HibernateTemplate模板类中有一个核心的方法:doExecute，这个核心的方法采用模板方法 完成相关的固定 操作（建立连接，执行操作，释放连接） ，其中的具体步骤通过回调传入的对象（这个对象就是实现了C...
Hibernate的复杂用法HibernateCallback
kewb的专栏
10-01 204
HibernateTemplate还提供一种更加灵活的方式来操作数据库，通过这种方式可以完全使用Hibernate的操作方式。HibernateTemplate的灵活访问方式是通过如下两个方法完成： q      Object execute(HibernateCallback action) q      List execute(HibernateCallback action) 这两个方法都...
HibernateTemplate 详解
daxue_yingyu的专栏
03-31 497
private HibernateTemplate hibernateTemplate;   使用HbernateTemplate HibernateTemplate提供持久层访问模板化，使用HibernateTemplate无须实现特定接口，它只需要提供一个SessionFactory的引用，就可执行持久化操作。SessionFactoyr对象可通过构造参数传入，或通过设值方式传入。如下：
Spring 里 回调函数 HibernateCallback 的理解
冷血封情
11-03 198
在dao里经常有这样的语句 代码 [code="java"]public E findById(Serializable id) { return (E) getHibernateTemplate().get(clazz, id); } HibernateTemplate类源码 [/cod...
HibernateTemplate
平平淡淡的专栏
05-27 1245
HibernateTemplate源码 [java] view plaincopyprint?       package org.springframework.orm.hibernate3;      import java.io.Serializable;   import java.lang.reflect.InvocationHandler;   import java.l
一款记录工作备忘很好的软件
09-20
一款记录工作备忘很好的软件，整理、记录日常经验所得
vue实现日历备忘录功能
01-19
用vue写了个日历备忘录的功能，省略了备忘录的增删改查功能。    直接上代码 <!DOCTYPE html> <html lang=en> <head> <meta charset=UTF-8> <title>备忘录</title> <...
13关于备忘录的实验报告
最新发布
07-16
13关于备忘录的实验报告
android备忘录app源码.zip
04-12
android备忘录app源码
HibernateTemplate 理解（对Callback继续理解）
abc123maxiaolong的专栏
10-30 213
    经常使用spring封装hibernate的同学，在写dao的具体实现类的时候，一般都会让dao实现类继承HibernateDaoSupport， 这样，在我们的dao实现类中就可以直接获得HibernateTemplate对象来直接使用，HibernateTemplate封装Hibernate的基本操作，    通过HibernateTemplate源码可知，我们需要给hiber...
Java 回调机制及其Spring 中HibernateTemplate的源码分析
zhxing
04-22 118
   在分析HibernateTemplate前，首先从网上了解下一些关于回调的一些概念。我相信在了解其原理实现的基础上，可以更好的进行开发和扩展，关键得理解其思想。   软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。   同步调用是一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用。（简单来说就是顺序执行啦。）回调是一种双向调用模式，...
为什么Spring的HibernateTemplate一般情况下不支持数据的惰性加载的源码分析
jimmee的专栏
03-10 4051
1.                                  HibernateTemplate template = (MyHibernateTemplate) context.getBean("hibernateTemplate");        Emp emp = (Emp) template.load(Emp.class, new Long(7369));       
Sping学习之HibernateTemplate源码
逆风奔跑。。不要去考虑什么天赋异禀，一切都来自经历和渴望。
03-03 7044
对Spring和Hibernate整合过程中，一直不太懂原理，感觉看着API用，实在是不踏实，于是上网找到了这个HibernateDaoSupport中提供的模版方法的源码，代码如下：/* * Copyright 2002-2008 the original author or authors. * * Licensed under the Apache License, Version 2
结合HibernateTemplate学习回调模式
xtfmtjf的专栏
11-27 537
学习了spring的HibernateTemplate类部分源码，总结一下自己对回调模式的理解。在dao里经常有这样的语句 代码   public E findById(Serializable id)        {            return (E) getHibernateTemplate().get(clazz, id);  
10.Spring整合Hibernate_3_HibernateTemplate
weixin_33860553的博客
08-20 96
将sessionFactory 注入给 hibernateTemplate，让hibernateTemplate帮我们完成一些模板代码 1 2 <!-- 使用HibernateTemplate --> 3 <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.Hib...
spring管理hibernate session的问题探究
jamen001的博客
09-17 168
我们再用spring管理hibernate的时候, 我们会继承HibernateDaoSupport 或者HibernateTemplate类. 我们不知道这两个类之间有什么关系. 也没有去关闭session. 让我很是心不安,他可没有关闭session呀.如果..真的是后果不堪设想.百度了好久, 谷歌了好多. 都没有一个像样的说法. 说spring中HibernateDaoSupport会自...
Spring的事务管理难点剖析：联合军种作战的混乱
yztezhl的专栏
07-29 971
引述：Spring给我们带来的最大的一个便利是透明地实现事务管理，但是一般开发者仅仅是了解如何配置，在实际应用过程中却往往遇到很多问题，存在很多困惑。有有鉴于此，我特意总结了各种实际应用中遇到的Spring事务管理的困惑，这些文章摘自于我的《Spring 3.x企业应用开发实战》的第10章，我将通过连载的方式，陆续在此发出。欢迎大家讨论。  -------------------------
写一份关于备忘录管理系统的系统介绍
05-17
备忘录管理系统是一种基于网络的应用程序，旨在帮助用户记录和管理日常生活中的各种事项和任务，以提高生产力和组织能力。该系统具有以下特征： 1. 用户注册和登录：用户可以在系统中注册并创建一个帐户。登录后，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值