Java 回调机制及其Spring 中HibernateTemplate的源码分析

在分析HibernateTemplate前，首先从网上了解下一些关于回调的一些概念。我相信在了解其原理实现的基础上，可以更好的进行开发和扩展，关键得理解其思想。
软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。
同步调用是一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用。（简单来说就是顺序执行啦。）
回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口。（个人觉得有点像模板方法的实现。）
异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。（差不多就是异步执行吧。）
回调和异步调用的关系非常紧密，通常我们使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。同步调用是三者当中最简单的，而回调又常常是异步调用的基础。
由于本文章主要关注的是Java 的回调机制，所以其他就不介绍了。下面来看看Java 是怎么来实现回调机制的。

packagecallback;
/**
*
*@authorzhxing
*@since2010.4.16
*
*/
publicclassTest{
privateCallbackcallback;
publicvoidsetCallback(Callbackcallback){
this.callback=callback;
}
//实际方法
publicvoidfoo(){
System.out.println("thisisfoo();");
//在这里调用回调函数
if(callback!=null){
callback.doSomething();
}
}
//测试
publicstaticvoidmain(String[]args){
Testt=newTest();
t.setCallback(newCallback(){
publicvoiddoSomething(){
System.out.println("thisiscallback.");
}
});

t.foo();
}

}
//回调函数
interfaceCallback{
voiddoSomething();
}

一般在我们数据库开发中，都会有打开和关闭数据、捕获异常等的一些固定的操作，写久了也就特别的反感了。是吧。。下面来利用回调简化数据库操作，例子很简单，对于数据的打开和关闭我只做了简单的描述。

packagecallback;

publicclassUserDao{
privateUserTemplatetemplate=newUserTemplate();

//这个实际上也是用回调方法，不过在UserTemplate进行了封装
publicvoidadd(finalStringname){
this.template.add(name);
}
//这个是用回调方法来实现的
publicStringgetName(){
return(String)this.template.execute(newUserCallback(){
publicObjectdoSomething(){
System.out.println("成功读取数据库。。。name=zhxing");
return"zhxing";
}
});
}

//测试
publicstaticvoidmain(String[]args){
UserDaou=newUserDao();
u.add("zhxing");
System.out.println(u.getName());
}
}

packagecallback;
//回调函数的实现
publicclassUserTemplate{
//调用回调函数，这里是不是有点像模板方法了，呵呵
publicObjectexecute(UserCallbackcallback){
System.out.println("打开数据库连接");
Objecto=callback.doSomething();
System.out.println("关闭数据库连接");
returno;
}

//这里用来简化常用的操作
publicvoidadd(finalStringname){
execute(newUserCallback(){
publicObjectdoSomething(){
System.out.println("name="+name+"成功加入数据库。。。");
returnnull;
}
});
}

}

packagecallback;
//回调函数接口
publicinterfaceUserCallback{
ObjectdoSomething();
}

好了，进入正题吧。。来研究下Spring 中HibernateTemplate 是怎么实现了。。其实上面的那个例子已经可以说明全部了，呵呵。。下面我们按照开发的流程来进行一些源码分析。
当我们用Spring+Hibernate实现Dao层的时候，一般会去继承HibernateDaoSupport这个类。
来分析下这个HibernateDaoSupport类（具体方法细节请查看源码）：

publicabstractclassHibernateDaoSupportextendsDaoSupport{

privateHibernateTemplatehibernateTemplate;
//SettheHibernateSessionFactorytobeusedbythisDAO.
publicfinalvoidsetSessionFactory(SessionFactorysessionFactory){
}
protectedHibernateTemplatecreateHibernateTemplate(SessionFactorysessionFactory){
}
//返回这个HiberanteTemplate中的成员变量SessionFactory
publicfinalSessionFactorygetSessionFactory(){

}

publicfinalvoidsetHibernateTemplate(HibernateTemplatehibernateTemplate){
this.hibernateTemplate=hibernateTemplate;
}
publicfinalHibernateTemplategetHibernateTemplate(){
returnthis.hibernateTemplate;
}
//检查HibernateTemplate是否为空,如果类中的HibernateTemplate未设置则会报错
protectedfinalvoidcheckDaoConfig(){
if(this.hibernateTemplate==null){
thrownewIllegalArgumentException("'sessionFactory'or'hibernateTemplate'isrequired");
}
}


//获得Hibernate中的session，可以在HibernateTemplate中配置是否在Session没创建时新创建一个，在事务处理中很有用
protectedfinalSessiongetSession()
throwsDataAccessResourceFailureException,IllegalStateException{

returngetSession(this.hibernateTemplate.isAllowCreate());
}

//这里是获得Hibernate的session的主要方法
protectedfinalSessiongetSession(booleanallowCreate)
throwsDataAccessResourceFailureException,IllegalStateException{

return(!allowCreate?
SessionFactoryUtils.getSession(getSessionFactory(),false):
SessionFactoryUtils.getSession(
getSessionFactory(),
this.hibernateTemplate.getEntityInterceptor(),
this.hibernateTemplate.getJdbcExceptionTranslator()));
}

//把HibernateException异常转换成DataAccessException异常
protectedfinalDataAccessExceptionconvertHibernateAccessException(HibernateExceptionex){
returnthis.hibernateTemplate.convertHibernateAccessException(ex);
}

//释放Hibernate的session
protectedfinalvoidreleaseSession(Sessionsession){
SessionFactoryUtils.releaseSession(session,getSessionFactory());
}

}

从上面可知道，HibernateDaoSupport 的主要作用是获取Hibernate 的Session （如果直接用HibernateTemplate是没有办法获得Session 的）和管理HibernateTemplate。在Spring 中可以对直接继承该类，然后在Dao 的配置上就可以直接进行注入SessionFactory了，还可以直接从Dao中获取Hibernate的Session进行操作。
现在回到正题，进行分析下HibernateTemplate，先看下他的成员变量有哪些。

publicclassHibernateTemplateextendsHibernateAccessorimplementsHibernateOperations{
//是否在Session不存在的时候进行创建
privatebooleanallowCreate=true;
//是否每次都生成新的Session
privatebooleanalwaysUseNewSession=false;
//是不是用原生的Hibernate的session而不是用它的代理
privatebooleanexposeNativeSession=false;
//检查Hibernate的session是否为只读模式
privatebooleancheckWriteOperations=true;
//缓存Query
privatebooleancacheQueries=false;
//设置Query缓存的名称
privateStringqueryCacheRegion;
//设置批量获取的大小
privateintfetchSize=0;
//设置最大的数据集
privateintmaxResults=0;
}

HibernateTemplate 封装了很多Hibernate 的原始的操作，但把Hibernate 的session设置为了protected，而不能在它的子类外进行获取。下面来看看我们最常用get 和save 方法。

publicObjectget(ClassentityClass,Serializableid)throwsDataAccessException{
returnget(entityClass,id,null);
}
//实际get调用这个方法，增加了一个锁模式。
publicObjectget(finalClassentityClass,finalSerializableid,finalLockModelockMode)
throwsDataAccessException{
//这里就是我们上面讨论的回调方法了。。
returnexecuteWithNativeSession(newHibernateCallback(){
publicObjectdoInHibernate(Sessionsession)throwsHibernateException{
if(lockMode!=null){
returnsession.get(entityClass,id,lockMode);
}
else{
returnsession.get(entityClass,id);
}
}
});
}

publicSerializablesave(finalObjectentity)throwsDataAccessException{
//这里也是用了回调，和上面一样的。
return(Serializable)executeWithNativeSession(newHibernateCallback(){
publicObjectdoInHibernate(Sessionsession)throwsHibernateException{
checkWriteOperationAllowed(session);
returnsession.save(entity);
}
});
}

下面来看看这个回调函数的方法。

protectedObjectdoExecute(HibernateCallbackaction,booleanenforceNewSession,booleanenforceNativeSession)
throwsDataAccessException{

Assert.notNull(action,"Callbackobjectmustnotbenull");
//判断是否强制新建Session
Sessionsession=(enforceNewSession?
SessionFactoryUtils.getNewSession(getSessionFactory(),getEntityInterceptor()):getSession());
//判断是否设置了事务且是否强制新建session
booleanexistingTransaction=(!enforceNewSession&&
(!isAllowCreate()||SessionFactoryUtils.isSessionTransactional(session,getSessionFactory())));
if(existingTransaction){
logger.debug("Foundthread-boundSessionforHibernateTemplate");
}

FlushModepreviousFlushMode=null;
try{
//设置并返回FlushMode
previousFlushMode=applyFlushMode(session,existingTransaction);
//设置过滤器
enableFilters(session);
//是否创建session代理
SessionsessionToExpose=
(enforceNativeSession||isExposeNativeSession()?session:createSessionProxy(session));
//这里调用回调函数了
Objectresult=action.doInHibernate(sessionToExpose);
flushIfNecessary(session,existingTransaction);
returnresult;
}
catch(HibernateExceptionex){
throwconvertHibernateAccessException(ex);
}
catch(SQLExceptionex){
throwconvertJdbcAccessException(ex);
}
catch(RuntimeExceptionex){
//Callbackcodethrewapplicationexception...
throwex;
}
finally{
if(existingTransaction){
logger.debug("Notclosingpre-boundHibernateSessionafterHibernateTemplate");
disableFilters(session);
if(previousFlushMode!=null){
session.setFlushMode(previousFlushMode);
}
}
else{
//NeverusedeferredcloseforanexplicitlynewSession.
if(isAlwaysUseNewSession()){
SessionFactoryUtils.closeSession(session);
}
else{
//把session绑定到线程变量中（ThreadLocal）SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session,getSessionFactory());
}
}
}
}

到这里基本就简单分析完了，关于HibernateTemplate的其他操作，其实都差不多的，对Hibernate的一些常用操作进行了回调封装，可以自己分析下。