Spring与Hibernate结合的细节源码分析（一）

本文基于SPRING2.56，HIBERANTE3.25及Oracle10g classes14.jar驱动，介绍SPRING与HIBERNATE是如何配合的细节，如SESSION、 事务、数据库连接何时打开与关闭；如果调用不是发自请求，不经过FILTER（如定时器对SERVICE调用），如何做到从头到尾只用一个SESSION？ 此时SESSION需不需要手动关闭？从SESSION取得的数据库连接需不需要关闭，  看完本文，你会清楚里面每一个细节。
两种访问系统的路径：
1、request-->filters(spring and struts)-->actions-->AOP(transaction)-->services-->dao-->db
2、timer(run)->AOP(transaction)-->services-->dao-->db
在WEB.XML配置了OpenSessionInViewFilter，整个请求只用一个SESSION，
在ACTION与SERVICE之间使用SPRING的AOP配置事务拦截器，所以事务范围涵盖整个SERVICE的方法调用，
DAO中一般使用SPRING的HibernateTemplate对象操作数据库
首先看OpenSessionInViewFilter在web.xml和事务拦截器相关配置

Xml代码
复制代码

<!--web.xml-->
<filter>
<filter-name>openSessionInViewFilter</filter-name>
<filter-class>
org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
</filter-class>
<init-param>
<param-name>singleSession</param-name>
<param-value>true</param-value>
</init-param>
</filter>

/////SRPING配置文件中事务拦截器相关配置
<!-- hibernate 事务管理者 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!-- hibernate 事务拦截器 -->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!--   注入事务管理者 -->
<property name="transactionManager" ref="transactionManager" />
<property name="transactionAttributes">
<!--   定义事务属性-->
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="add*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="search*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="noTran*">PROPAGATION_NOT_SUPPORTED,readOnly</prop>
</props>
</property>
</bean>
/////配置service自动代理
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<!--   代理所有Service   -->
<list>
<value>*Service</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>

//下面从FILTER开始分析代码
Java代码
复制代码

//这是OpenSessionInViewFilter类的方法，请求到来时，此方法由父类OncePerRequestFilter的doFilter()方法调用，
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {

//取得SessionFactory实例，实际上就是调用WebApplicationContext.getBean("beanName")，
SessionFactory sessionFactory = lookupSessionFactory(request);
//在lookupSessionFactory方法里看到原来此FILTER还支持配置sessionFactory为的名字，默认就叫sessionFactory，如果想改成其它名字具体配置方式：
//在web.xml中，<init-param><param-name>sessionFactoryBeanName</param-name><param-value>sessionFactory</param-value></init-param>

//此次调用有无打开SESSION，有的话在finally块关闭
boolean participate = false;
//是否单SESSION模式（上文web.xml中配置了），注意这并不意味着每个请求只用一个connection，下文详解
if (isSingleSession()) {//这里我只分析单SESSION的情况，因为另一种情况不是此filter推荐的用法，就懒得看了
// 单SESSION模式

// 是否已经打开了SESSION，一般来说每个请求一开始是没有打开的，除非在打开SESSION之后进行forward跳转并再次被拦截
if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
participate = true;
}
else {
logger.debug("Opening single Hibernate Session in OpenSessionInViewFilter");
//打开session，注意想在整个请求内部都用SESSION，这一句还不够，还必须有下面一句。getSession方法如何打开SESSION接下来讲解
Session session = getSession(sessionFactory);
//把SESSION放入SessionHolder，再用sessionFactory作为KEY，SessionHolder作为VALUE放入MAP，再把此MAP放入ThreadLocal
//------不熟ThreadLocal看这，其他人跳过，ThreadLocal有两个主要的方法，get()和set(value)，用法和MAP差不多，只是不需要提供KEY，
//KEY就是当前线程，这样对于每个线程，只能往ThreadLocal里放入一个对象，在此放入了一个MAP。
//不同的线程可以同时操作这个ThreadLocal对象，放入内容，因为各自有着不同的KEY------//
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
}
}
else {//非单Session模式，本文不讨论此情况
// deferred close mode
if (SessionFactoryUtils.isDeferredCloseActive(sessionFactory)) {
// Do not modify deferred close: just set the participate flag.
participate = true;
}else {
SessionFactoryUtils.initDeferredClose(sessionFactory);
}
}

try {//SESSION已打开，往下调用，-->action-->aop-->service-->dao-->db
filterChain.doFilter(request, response);
}

finally {//目标调用完成，关闭SESSION
if (!participate) {//如果上文打开了SESSION
if (isSingleSession()) {
//从ThreadLocal里面把上面放入的MAP移除
SessionHolder sessionHolder =
(SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
logger.debug("Closing single Hibernate Session in OpenSessionInViewFilter");
//关闭SESSION
closeSession(sessionHolder.getSession(), sessionFactory);
}
else {
// deferred close mode
SessionFactoryUtils.processDeferredClose(sessionFactory);
}
}
}
}

getSession方法
Java代码
复制代码

//OpenSessionInViewFilter类，还是上面那个FILTER类
protected Session getSession(SessionFactory sessionFactory) throws DataAccessResourceFailureException {
//取SESSION，下文讲解
Session session = SessionFactoryUtils.getSession(sessionFactory, true);
//设置提交方式，getFlushMode默认返回FlushMode.NEVER，
//NEVER看名字好像是永不提交，其实是外部显式调用FLUSH时才提交的意思，也许是因为名字不好，此变量已过时了，新的名字是FlushMode.MANUAL
//如果请求是写操作，会在打开事务时被改成AUTO，
FlushMode flushMode = getFlushMode();
if (flushMode != null) {
session.setFlushMode(flushMode);
}
return session;
}

SessionFactoryUtils.doGetSession方法

Java代码
复制代码

//SessionFactoryUtils类，取SESSION，此工具方法在以下两种情况被调用：在FILTER层开SESSION和在DAO层取SESSION去查数据库
//在FILTER层调用时，没有事务（执行此方法的后半部份），在DAO层调用时，由于经过了AOP，开启了事务（执行方法的前半部份）
//在没有JTA事务的环境中，此方法只是打开或取得一个SESSION，关于事务的事什么也没有做。
private static Session doGetSession(
SessionFactory sessionFactory, Interceptor entityInterceptor,
SQLExceptionTranslator jdbcExceptionTranslator, boolean allowCreate)
throws HibernateException, IllegalStateException {

Assert.notNull(sessionFactory, "No SessionFactory specified");
//上文放入的sessionHolder在这里被取出来，如果调用来源于FILTER，则还没有放入，取出空，如果DAO层的调用，那么就不为空了
SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
///--------------前半部份-------------------//////////////
if (sessionHolder != null && !sessionHolder.isEmpty()) {// DAO中的调用，取得非空值，
Session session = null;

//如果：事务是否已开始 && sessionHolder中没有SESSION或只有一个默认SESSION
if (TransactionSynchronizationManager.isSynchronizationActive() &&
sessionHolder.doesNotHoldNonDefaultSession()) {
//取出SESSION，里面主要判断一下SESSION有没有被关闭
session = sessionHolder.getValidatedSession();
//session不为空 && 事务没有开始,
if (session != null && !sessionHolder.isSynchronizedWithTransaction()) {
//在AOP中开始事务时，会将这个标志设为真，所以这里不会被执行，至少我还没有发现哪一次执行经过这里了
logger.debug("Registering Spring transaction synchronization for existing Hibernate Session");
TransactionSynchronizationManager.registerSynchronization(//注册一个SESSION
new SpringSessionSynchronization(sessionHolder, sessionFactory, jdbcExceptionTranslator, false));
sessionHolder.setSynchronizedWithTransaction(true);
// 取出当前SESSION的提交方式
FlushMode flushMode = session.getFlushMode();
if (flushMode.lessThan(FlushMode.COMMIT) &&
!TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
//如果是小于COMMIT，就是NEVER，那么改成自动
session.setFlushMode(FlushMode.AUTO);
//设置之前的提交模式
sessionHolder.setPreviousFlushMode(flushMode);
}
}
}
else {//这里也是一般都不会被执行，因为AOP中已经开启了事务
// No Spring transaction management active -> try JTA transaction synchronization.
session = getJtaSynchronizedSession(sessionHolder, sessionFactory, jdbcExceptionTranslator);
}
if (session != null) {
return session;
}
}
////////-------------------后半部份--------------------------

//来自FILTER的调用，一般sessionHolder为空（同一请求forward后被再次拦截就不会空，执行不到这里），
logger.debug("Opening Hibernate Session");
//调用HIBERNATE打开SESSION
Session session = (entityInterceptor != null ?
sessionFactory.openSession(entityInterceptor) : sessionFactory.openSession());

// 当前请求是否已开启事务，FILTER中的调用，还没有到AOP层，事务没有打开,一般会执行ELSE
if (TransactionSynchronizationManager.isSynchronizationActive()) {
// We're within a Spring-managed transaction, possibly from JtaTransactionManager.
logger.debug("Registering Spring transaction synchronization for new Hibernate Session");
SessionHolder holderToUse = sessionHolder;
if (holderToUse == null) {
holderToUse = new SessionHolder(session);
}
else {
holderToUse.addSession(session);
}
if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
session.setFlushMode(FlushMode.NEVER);
}
TransactionSynchronizationManager.registerSynchronization(
new SpringSessionSynchronization(holderToUse, sessionFactory, jdbcExceptionTranslator, true));
holderToUse.setSynchronizedWithTransaction(true);
if (holderToUse != sessionHolder) {
TransactionSynchronizationManager.bindResource(sessionFactory, holderToUse);
}
}
else {
// 上面没有找到事务，从sessionFactory中找，如果sessionFactory有配置JTA事务，则注册事务
// 本文也没有配置JTA事务，所以里面什么也没有干，还是没有注册事务
registerJtaSynchronization(session, sessionFactory, jdbcExceptionTranslator, sessionHolder);
}

// 如果不自动创建 && sessionHolder中没有session，则关闭SESSION
if (!allowCreate && !isSessionTransactional(session, sessionFactory)) {
closeSession(session);
throw new IllegalStateException("No Hibernate Session bound to thread, " +
"and configuration does not allow creation of non-transactional one here");
}
//到此就在FILTER中取得了（或者说打开了）SESSION，下面就从ACTION调用SERVICE这一节了。
return session;
}

//下面开始到了ACTION的操作，action调用service，此service实际上是Spring动态生成的代理类，此代理类调用
//目标SERVICE类对应的方法前，要经过AOP拦截，下面我们对ACTION到SERVICE这中间经过的所有类方法代码分析一遍。
//我的应用在AOP层配置了一个事务拦截器，所以这中间的代码主要操作事务相关。
//动态生成的代理类代码看不到，从动态代理类下面的那个类（JdkDynamicAopProxy）开始吧

Java代码
复制代码

//JdkDynamicAopProxy类，此方法被动态代理类调用
//参数说明：proxy动态代理类对象，method目标方法，args目标方法参数
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation = null;
Object oldProxy = null;
boolean setProxyContext = false;

//targetSource对象包含目标SERVICE对象
TargetSource targetSource = this.advised.targetSource;
Class targetClass = null;
Object target = null;

try {
//如果目标类没有重载equals方法 && 目前正在调用目标类的equals方法,那直接调本类重载方法，
//这样就不需要再往下走，不需要再开启事务等等多余的操作以至于浪费性能了，下面的几个IF都是做类似的事
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return (equals(args[0]) ? Boolean.TRUE : Boolean.FALSE);
}
if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return new Integer(hashCode());
}
if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}

Object retVal = null;

//ProxyConfig类的exposeProxy属性，表示是否要将当前的代理对象放入AopContext中，
//这样在你的Service中可以用AopContext.currentProxy()取得当前代理，相当于this引用，
//不同于this引用的是，调用当前代理会被AOP拦截，而this不会。
//此属性默认为FALSE，如果要打开，
//在BeanNameAutoProxyCreator等代理类BEAN的配置中加入<property name="exposeProxy" value="true" />
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}

// 取得目标（真实SERVICE对象）
target = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}

// 取得所有拦截器
List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

// 如果没有拦截器
if (chain.isEmpty()) {
// 直接调用目标
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {//有拦截器
// 创建一个调用器对象
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// 通过调用器往下调用目标或第一个拦截器
retVal = invocation.proceed();
}

// 调用的返回结果目标类对象本身，就把它替换成代理类对象
if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
retVal = proxy;
}
return retVal;
}
finally {//释放资源
//主要是从当前线程清除代理类对象
if (target != null && !targetSource.isStatic()) {
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}

递归调用拦截器

Java代码
复制代码

//ReflectiveMethodInvocation类，上面执行retVal = invocation.proceed();就进入到了这个方法
//这个方法主要是递归调用各个拦截器，最后调用目标类
public Object proceed() throws Throwable {
//  判断是否还有拦截器要调用，
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
//没有拦截器了，调用目标
return invokeJoinpoint();
}

//取出拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

//判断拦截器型，对不同类型的调用方法不一样，SPRING事务拦截器TransactionInterceptor是MethodInterceptor实现类，
//不属于InterceptorAndDynamicMethodMatcher，执行ELSE
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {//方法匹配失败，跳过，继续递归
return proceed();
}
}
else {
// 调用事务拦截器等，MethodInterceptor--林信良的SPRING手册介绍过个这接口如何使用
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}

事务拦截器

Java代码
复制代码

//TransactionInterceptor--SPRING的事务拦截器实现类，这个方法可以根据事务管理器的种类分类if和else上下两部分，
//如果配置的是org.springframework.orm.hibernate3.HibernateTransactionManager等非CallbackPreferringPlatformTransactionManager接口实现类
//则看只需要看if部份
//了解这里工作原理很重要：
//1、如果是请求发起的调用，流程路线为--FILTER打开Session，并且绑定到了线程信息中(TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session)))，
//在此方法里标志为旧SESSION，开始事务，调用目标，提交或回滚事务，判断如果是旧SESSION，则事务结束释放连接但不关闭SESSION，如果还用此SESSION再开启事务，再绑定另外的连接（所以上文说单SESSION并不等于同一个连接），最后在FILTER关闭SESSION。
//2、如果不是请求发起的调用，如计划任务Timer.schedule(...)发起的SERVICE调用，流程为--在此方法打开SESSION，标志为新连接，开启事务，调用目标，提交或回滚事务，释放数据库连接，判断如果是新SESSION，则关闭SESSION。
//总结如下：
//1、只要有配置了此事务拦截器，底层使用SPRING的HibernateTemplate.getSession()或其提供的各种查询，那么SESSION和数据库连接的关闭不需要你操心。
//2、如果要在Timer的run方法中多次调用SERVICE时，也要实现OpenSessionInViewFilter这样的效果，那么使用如这句，结束时要记得自已关闭SESSION。
//打开SESSION后：TransactionSynchronizationManager.bindResource(getSessionFactory(), new SessionHolder(session));
//最后关闭SESSION：
//SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.unbindResource(getSessionFactory());
//SessionFactoryUtils.closeSession(sessionHolder.getSession());
public Object invoke(final MethodInvocation invocation) throws Throwable {
// 取得目标类名
Class targetClass = (invocation.getThis() != null ? invocation.getThis().getClass() : null);

// 通过类名及方法名，取得事务属性，即<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>这些内容
final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(invocation.getMethod(), targetClass);
//取得类名+方法名全称
final String joinpointIdentification = methodIdentification(invocation.getMethod());
//没有事务属性 || 事务管理者不是CallbackPreferringPlatformTransactionManager类型（事务采用回调方法实现的方式）
if (txAttr == null || !(getTransactionManager() instanceof CallbackPreferringPlatformTransactionManager)) {
//开始事务并创建事务信息对象（此对象主要包括事务属性和事务状态等信息），就是在这里调用了session.beginTransaction()方法
//将事务信息以当前线程为KEY放入了TransactionAspectSupport.transactionInfoHolder对象中
//注意：到这里如果当前取得到SessionHolder，那么SESSION就被标记成老SESSION，提交事务时就不会关闭之，反之那么session会在打开，并被标为新SESSION，提交事务时会把此SESSION关闭
TransactionInfo txInfo = createTransactionIfNecessary(txAttr, joinpointIdentification);
Object retVal = null;
try {
// 调用下一下拦截器，如果没有下一个拦截器，那么目标类会被调用
retVal = invocation.proceed();
}
catch (Throwable ex) {
// 发生异常时，在这里回滚,回滚时，除了rollBack，还执行session.clear(),setFlushMode(NEVER)等动作
// 新SESSION会在此被关闭，老的则不会
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
//清理当前线程对应的事务信息，
cleanupTransactionInfo(txInfo);
}
//未发生异常，提交事务，如果是新SESSION，会在此被关闭，老的则不会
commitTransactionAfterReturning(txInfo);
return retVal;
}

else {
// 回调式的事务管理器，SPRING中只提供了一个WebSphereUowTransactionManager的具体实现，
/**CallbackPreferringPlatformTransactionManager接口的注释
* Extension of the {@link org.springframework.transaction.PlatformTransactionManager}
* interface, exposing a method for executing a given callback within a transaction.
* <p>Implementors of this interface automatically express a preference for
* callbacks over programmatic <code>getTransaction</code>, <code>commit</code>
* and <code>rollback</code> calls. Calling code may check whether a given
* transaction manager implements this interface to choose to prepare a
* callback instead of explicit transaction demarcation control.*/
// 大意应该是可以由此接口的具体实现来决定事务的控制，我的E文一般般,有错的就砸砖
try {
Object result = ((CallbackPreferringPlatformTransactionManager) getTransactionManager()).execute(txAttr,
new TransactionCallback() {
public Object doInTransaction(TransactionStatus status) {
TransactionInfo txInfo = prepareTransactionInfo(txAttr, joinpointIdentification, status);
try {
//往下调用
return invocation.proceed();
}
catch (Throwable ex) {
if (txAttr.rollbackOn(ex)) {
// A RuntimeException: will lead to a rollback.
if (ex instanceof RuntimeException) {
throw (RuntimeException) ex;
}
else {
throw new ThrowableHolderException(ex);
}
}
else {
// A normal return value: will lead to a commit.
return new ThrowableHolder(ex);
}
}
finally {
cleanupTransactionInfo(txInfo);
}
}
});

// Check result: It might indicate a Throwable to rethrow.
if (result instanceof ThrowableHolder) {
throw ((ThrowableHolder) result).getThrowable();
}
else {
return result;
}
}
catch (ThrowableHolderException ex) {
throw ex.getCause();
}
}
}