《Spring技术内幕》学习笔记12——HibernateTemplate对Hibernate的封装

1.Spring中，不提供具体的ORM实现，而只是为应用提供对ORM产品的集成环境和使用平台，Spring将Hibernate的会话工厂通过IoC容器管理起来，并且将数据源注入，同时Spring为Hibernate提供了更上层的API封装，方便应用调用，本文通过分析相应源码了解Spring对Hibernate支持的实现。

2.AbstractSessionFactoryBean管理Hibernate会话工厂：

使用过Hibernate的人都知道，Hibernate的SessionFactory(会话工厂)是Hibernate的基础，SessionFactory管理Hibernate的相关配置和映射资源，Spring中通过AbstractSessionFactoryBean抽象类来管理Hibernate的会话工厂，AbstractSessionFactoryBean实现Spring的工厂Bean(FactoryBean)接口，因此AbstractSessionFactoryBean是一个Spring的工厂Bean，即Spring管理Hibernate的IoC容器，AbstractSessionFactoryBean的源码如下：

public abstract class AbstractSessionFactoryBeanimplements FactoryBean<SessionFactory>, InitializingBean, DisposableBean, PersistenceExceptionTranslator {protected final Log logger = LogFactory.getLog(getClass());//数据源private DataSource dataSource;//Hibernate会话使用Spring事务管理器包装的数据源private boolean useTransactionAwareDataSource = false;//从Hibernate会话工厂中获取的当前会话是否暴露给Spring事务来包装private boolean exposeTransactionAwareSessionFactory = true;//Hibernate SQL相关异常转换器private SQLExceptionTranslator jdbcExceptionTranslator;//Hibernate会话工厂private SessionFactory sessionFactory;//为会话工厂设置数据源，如果设置，则覆盖Hibernate配置文件中的数据源设置public void setDataSource(DataSource dataSource) {this.dataSource = dataSource;}public DataSource getDataSource() {return this.dataSource;}//设置Hibernate会话工厂是否使用Spring事务(jdbc事务)包装的数据源，//true，则使用Spring的jdbc事务；false，则使用Hibernate事务或者JTApublic void setUseTransactionAwareDataSource(boolean useTransactionAwareDataSource) {this.useTransactionAwareDataSource = useTransactionAwareDataSource;}protected boolean isUseTransactionAwareDataSource() {return this.useTransactionAwareDataSource;}//为通过Hibernate会话工厂getCurrentSession()方法获得的当前会话设置//是否使用Spring会话包装public void setExposeTransactionAwareSessionFactory(boolean exposeTransactionAwareSessionFactory) {this.exposeTransactionAwareSessionFactory = exposeTransactionAwareSessionFactory;}protected boolean isExposeTransactionAwareSessionFactory() {return this.exposeTransactionAwareSessionFactory;}//为Hibernate会话工厂设置JDBC异常转换器，当Hibernate产生的任何由jdbc异常//引起的SQL异常时，使用jdbc异常覆盖Hibernate默认的SQL方言(Dialect)异常public void setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator) {this.jdbcExceptionTranslator = jdbcExceptionTranslator;}//创建Hibernate会话工厂，IoC容器初始化回调方法public void afterPropertiesSet() throws Exception {//委托模式，调用AbstractSessionFactoryBean子类//LocalSessionFactoryBean实现的方法SessionFactory rawSf = buildSessionFactory();//如果需要，将给定的会话工厂使用代理包装this.sessionFactory = wrapSessionFactoryIfNecessary(rawSf);//钩子方法，Hibernate会话工厂创建成功后，应用自定义处理afterSessionFactoryCreation();}//如果有需要，将给定的Hibernate会话工厂用代理封装protected SessionFactory wrapSessionFactoryIfNecessary(SessionFactory rawSf) {return rawSf;}//应用从Spring管理Hibernate会话工厂的IoC容器中获取SessionFactoryprotected final SessionFactory getSessionFactory() {if (this.sessionFactory == null) {throw new IllegalStateException("SessionFactory not initialized yet");}return this.sessionFactory;}//当Spring管理Hibernate会话工厂的IoC容器关闭时关闭所创建的会话工厂public void destroy() throws HibernateException {logger.info("Closing Hibernate SessionFactory");try {beforeSessionFactoryDestruction();}finally {this.sessionFactory.close();}}//获取单态模式的Hibernate会话工厂public SessionFactory getObject() {return this.sessionFactory;}//获取Hibernate会话工厂的对象类型public Class<? extends SessionFactory> getObjectType() {return (this.sessionFactory != null ? this.sessionFactory.getClass() : SessionFactory.class);}public boolean isSingleton() {return true;}//转换异常public DataAccessException translateExceptionIfPossible(RuntimeException ex) {//如果异常时Hibernate异常类型if (ex instanceof HibernateException) {//转换Hibernate异常return convertHibernateAccessException((HibernateException) ex);}//如果不是Hibernate异常，则返回nullreturn null;}//转换Hibernate异常protected DataAccessException convertHibernateAccessException(HibernateException ex) { //如果Hibernate会话工厂设置了Jdbc异常转换器，且给定的异常是jdbc异常类型， //则使用设置的jdbc异常转换器转换给定的Hibernate异常if (this.jdbcExceptionTranslator != null && ex instanceof JDBCException) {JDBCException jdbcEx = (JDBCException) ex;return this.jdbcExceptionTranslator.translate("Hibernate operation: " + jdbcEx.getMessage(), jdbcEx.getSQL(), jdbcEx.getSQLException());}//如果Hibernate会话工厂没有设置jdbc异常转换器，或者给定异常不是jdbc异常//类型，则使用Hibernate默认的异常转换器转换return SessionFactoryUtils.convertHibernateAccessException(ex);}//创建Hibernate会话工厂protected abstract SessionFactory buildSessionFactory() throws Exception;//钩子方法，Hibernate会话工厂成功创建后操作处理protected void afterSessionFactoryCreation() throws Exception {}//钩子方法，Hibernate会话工厂关闭前操作处理protected void beforeSessionFactoryDestruction() {}}

通过分析Spring对Hibernate会话工厂管理的IoC容器AbstractSessionFactoryBean的源码，我们可以了解到，AbstractSessionFactoryBean继承了InitializingBean接口，并实现了其afterPropertiesSet方法，该方法是在Spring IoC容器初始化完成之后由IoC容器回调的方法，分析AbstractSessionFactoryBean的工作流程如下：

(1).Spring管理Hibernate会话工厂的IoC容器AbstractSessionFactoryBean初始化完成，IoC容器回调afterPropertiesSet方法创建单态模式的Hivbernate会话工厂。

(2).应用通过getObject方法向Spring管理Hibernate会话工厂的IoC容器AbstractSessionFactoryBean索取Hibernate会话工厂。

下面我们继续分析AbstractSessionFactoryBean子类LocalSessionFactoryBean创建Hibernate会话工厂的过程。

3.LocalSessionFactoryBean创建SessionFactory：

Spring中管理Hibernate会话工厂的IoC容器AbstractSessionFactoryBean通过委派模式调用其子类LocalSessionFactoryBean的buildSessionFactory创建Hibernate会话工厂，源码如下：

//创建Hibernate会话工厂protected SessionFactory buildSessionFactory() throws Exception {//获取Hibernate配置Configuration config = newConfiguration();//获取数据源DataSource dataSource = getDataSource();//配置数据源，事务管理器，缓存等等，将这些配置设置当对应的线程局部变量中，//使资源和当前线程绑定起来if (dataSource != null) {//配置数据源configTimeDataSourceHolder.set(dataSource);}if (this.jtaTransactionManager != null) {//配置jta事务管理器configTimeTransactionManagerHolder.set(this.jtaTransactionManager);}if (this.cacheRegionFactory != null) {//配置缓存区域工厂configTimeRegionFactoryHolder.set(this.cacheRegionFactory);}if (this.cacheProvider != null) {//配置缓存提供者configTimeCacheProviderHolder.set(this.cacheProvider);}if (this.lobHandler != null) {//配置lob处理器，用于处理clob/blob等大字段类型映射configTimeLobHandlerHolder.set(this.lobHandler);}//Hibernate不允许显示设置类加载器，因此需要暴露相应的线程上下文类加载器Thread currentThread = Thread.currentThread();ClassLoader threadContextClassLoader = currentThread.getContextClassLoader();boolean overrideClassLoader =(this.beanClassLoader != null && !this.beanClassLoader.equals(threadContextClassLoader));//用当前类加载器覆盖当前线程上下文类加载器if (overrideClassLoader) {currentThread.setContextClassLoader(this.beanClassLoader);}//配置Hibernate相关属性try {//如果Hibernate会话工厂暴露一个会话包装的代理if (isExposeTransactionAwareSessionFactory()) {//使用Spring管理的Session作为Hibernate当前会话config.setProperty(Environment.CURRENT_SESSION_CONTEXT_CLASS, SpringSessionContext.class.getName());}//如果Hibernate会话工厂指定了事务管理器，则使用Hibernate的事务管理器if (this.jtaTransactionManager != null) {config.setProperty(Environment.TRANSACTION_STRATEGY, JTATransactionFactory.class.getName());config.setProperty(Environment.TRANSACTION_MANAGER_STRATEGY, LocalTransactionManagerLookup.class.getName());}//如果Hibernate会话工厂没有指定事务管理器，则使用Spring管理的事务else {config.setProperty(Environment.TRANSACTION_STRATEGY, SpringTransactionFactory.class.getName());}//设置SessionFactory级别的实体拦截器if (this.entityInterceptor != null) {config.setInterceptor(this.entityInterceptor);}//设置命名规则if (this.namingStrategy != null) {config.setNamingStrategy(this.namingStrategy);}//注册指定的Hibernate类型定义if (this.typeDefinitions != null) {//通过JDK反射机制，获取Hibernate配置文件中的createMappings方法Method createMappings = Configuration.class.getMethod("createMappings");//通过JDK反射，获取createMappings方法返回的org.hibernate.cfg.Mappings对//象的addTypeDef方法，该方法的三个参数类型为：String,String和PropertiesMethod addTypeDef = createMappings.getReturnType().getMethod("addTypeDef", String.class, String.class, Properties.class);//通过JDK反射机制调用Hibernate配置中的createMappings方法，//返回org.hibernate.cfg.Mappings对象Object mappings = ReflectionUtils.invokeMethod(createMappings, config);//遍历Hibernate中所有注册的类型定义for (TypeDefinitionBean typeDef : this.typeDefinitions) {//通过反射机制，调用org.hibernate.cfg.Mappings对象的//addTypeDef方法，该方法的三个参数分别为：类型名称，类型实//现类，类型参数，为Hibernate添加类型定义ReflectionUtils.invokeMethod(addTypeDef, mappings,typeDef.getTypeName(), typeDef.getTypeClass(), typeDef.getParameters());}}//注册Hibernate过滤器if (this.filterDefinitions != null) {for (FilterDefinition filterDef : this.filterDefinitions) {config.addFilterDefinition(filterDef);}}//从给定资源路径加载Hibernate配置if (this.configLocations != null) {for (Resource resource : this.configLocations) {config.configure(resource.getURL());}}//添加Hibernate属性if (this.hibernateProperties != null) {config.addProperties(this.hibernateProperties);}//配置数据源if (dataSource != null) {//Spring中默认的Hibernate数据源连接提供类Class providerClass = LocalDataSourceConnectionProvider.class;//如果使用了事务包装数据源或者使用事务包装数据源代理，则使用//TransactionAwareDataSourceConnectionProvider作为连接提供类if (isUseTransactionAwareDataSource() || dataSource instanceof TransactionAwareDataSourceProxy) {providerClass = TransactionAwareDataSourceConnectionProvider.class;}//如果Hibernate配置文件中指定事务管理策略，则使用//LocalJtaDataSourceConnectionProvider作为数据源连接提供类else if (config.getProperty(Environment.TRANSACTION_MANAGER_STRATEGY) != null) {providerClass = LocalJtaDataSourceConnectionProvider.class;}//设置Hibernate的数据源连接提供类config.setProperty(Environment.CONNECTION_PROVIDER, providerClass.getName());}//如果Hibernate配置中指定了缓存区域工厂，则使用Spring提供的Hibernate//缓存区域工厂if (this.cacheRegionFactory != null) {config.setProperty(Environment.CACHE_REGION_FACTORY,"org.springframework.orm.hibernate3.LocalRegionFactoryProxy");}//如果Hibernate配置中指定了缓存提供类，则使用Spring提供的//LocalCacheProviderProxy作为Hibernate缓存提供者else if (this.cacheProvider != null) {config.setProperty(Environment.CACHE_PROVIDER, LocalCacheProviderProxy.class.getName());}//如果Hibernate配置中指定了实体映射资源，则注册给定的Hibernate映射if (this.mappingResources != null) {//遍历给定的Hibernate映射资源for (String mapping : this.mappingResources) {//定位classpath中的Hibernate映射资源Resource resource = new ClassPathResource(mapping.trim(), this.beanClassLoader);//将Hibernate映射资源输入流添加到Hibernate配置输入流中config.addInputStream(resource.getInputStream());}}//如果Hibernate配置中指定了实体映射文件路径if (this.mappingLocations != null) {//遍历给定的路径，将Hibernate实体映射文件输入流添加到Hibernate//配置输入流中for (Resource resource : this.mappingLocations) {config.addInputStream(resource.getInputStream());}}//如果Hibernate配置中指定了缓存映射路径if (this.cacheableMappingLocations != null) {//将给定的缓存映射文件添加到Hibernate配置的缓存文件中for (Resource resource : this.cacheableMappingLocations) {config.addCacheableFile(resource.getFile());}}//如果Hibernate配置中指定了包含在jar文件中的映射文件路径if (this.mappingJarLocations != null) {//将包含在jar文件中的映射文件添加到Hibernate配置中for (Resource resource : this.mappingJarLocations) {config.addJar(resource.getFile());}}//如果Hibernate配置中指定了包含映射文件的目录路径if (this.mappingDirectoryLocations != null) {//将包含映射文件的给定目录添加到Hibernate配置中for (Resource resource : this.mappingDirectoryLocations) {File file = resource.getFile();if (!file.isDirectory()) {throw new IllegalArgumentException("Mapping directory location [" + resource + "] does not denote a directory");}config.addDirectory(file);}}//编译Hibernate需要的映射信息postProcessMappings(config);config.buildMappings();//如果Hibernate配置中指定了实体缓存策略if (this.entityCacheStrategies != null) {//为映射实体设置缓存策略for (Enumeration classNames = this.entityCacheStrategies.propertyNames(); classNames.hasMoreElements();) {String className = (String) classNames.nextElement();//获取缓存策略属性值，将csv格式数据转换为字符串数组String[] strategyAndRegion =StringUtils.commaDelimitedListToStringArray(this.entityCacheStrategies.getProperty(className));//如果缓存策略属性值多于2个，则只给Hibernate设置前两个值if (strategyAndRegion.length > 1) {//获取Hibernate配置中的setCacheConcurrencyStrategy方法Method setCacheConcurrencyStrategy = Configuration.class.getMethod("setCacheConcurrencyStrategy", String.class, String.class, String.class);//通过反射机制调用Hibernate配置对象的setCacheConcurrencyStrategy方法ReflectionUtils.invokeMethod(setCacheConcurrencyStrategy, config,className, strategyAndRegion[0], strategyAndRegion[1]);}//缓存策略属性值只有一个，则只需设置一个else if (strategyAndRegion.length > 0) {config.setCacheConcurrencyStrategy(className, strategyAndRegion[0]);}}}//如果Hibernate配置了集合缓存策略if (this.collectionCacheStrategies != null) {//为映射的集合注册缓存策略for (Enumeration collRoles = this.collectionCacheStrategies.propertyNames(); collRoles.hasMoreElements();) {String collRole = (String) collRoles.nextElement();String[] strategyAndRegion =StringUtils.commaDelimitedListToStringArray(this.collectionCacheStrategies.getProperty(collRole));if (strategyAndRegion.length > 1) {config.setCollectionCacheConcurrencyStrategy(collRole, strategyAndRegion[0], strategyAndRegion[1]);}else if (strategyAndRegion.length > 0) {config.setCollectionCacheConcurrencyStrategy(collRole, strategyAndRegion[0]);}}}//注册Hibernate事件监听器if (this.eventListeners != null) {for (Map.Entry<String, Object> entry : this.eventListeners.entrySet()) {//监听事件类型String listenerType = entry.getKey();//监听类对象Object listenerObject = entry.getValue();//如果监听类对象类型是集合if (listenerObject instanceof Collection) {Collection<Object> listeners = (Collection<Object>) listenerObject;EventListeners listenerRegistry = config.getEventListeners();//获取给定监听类型的所有监听类Object[] listenerArray =(Object[]) Array.newInstance(listenerRegistry.getListenerClassFor(listenerType), listeners.size());listenerArray = listeners.toArray(listenerArray);//Hibernate配置设置集合类型的监听类config.setListeners(listenerType, listenerArray);}// Hibernate配置设置普通的监听类else {config.setListener(listenerType, listenerObject);}}}//Hibernate配置完成，客户自定义处理postProcessConfiguration(config);logger.info("Building new Hibernate SessionFactory");this.configuration = config;//根据Hibernate配置创建SessionFactory对象return newSessionFactory(config);}//清空线程绑定的资源finally {if (dataSource != null) {configTimeDataSourceHolder.remove();}if (this.jtaTransactionManager != null) {configTimeTransactionManagerHolder.remove();}if (this.cacheRegionFactory != null) {configTimeCacheProviderHolder.remove();}if (this.cacheProvider != null) {configTimeCacheProviderHolder.remove();}if (this.lobHandler != null) {configTimeLobHandlerHolder.remove();}if (overrideClassLoader) {currentThread.setContextClassLoader(threadContextClassLoader);}}}//根据Hibernate配置创建SessionFactoryprotected SessionFactory newSessionFactory(Configuration config) throws HibernateException {return config.buildSessionFactory();}

上述代码非常的长，但是所做的工作非常的清楚，即获取Hibernate的配置，然后设置Hibernate配置，最后生成SessionFactory的过程。

4.HibernateTemplate实现：

和Spring对jdbc封装类似，Spring使用HibernateTemplate对Hibernate也进行了一下API封装，通过execute回调来调用Hibernate的相关操作处理，接下来简单分析HibernateTemplate的核心实现。

(1). execute相关方法的实现：

与JdbcTemplate类似，execute相关方法也是HibernateTemplate的基础核心方法，在execute相关方法中，Spring提供获取Hibernate Session，为当前的Session进行事务处理等通用的操作，源码如下：

//最基础的execute方法public <T> T execute(HibernateCallback<T> action) throws DataAccessException {return doExecute(action, false, false);} //需要在新的Hibernate Session中执行的execute方法public <T> T executeWithNewSession(HibernateCallback<T> action) {return doExecute(action, true, false);} //需要在Hibernate本地Session中执行的execute方法public <T> T executeWithNativeSession(HibernateCallback<T> action) {return doExecute(action, false, true);} //真正调用Hibernate API的地方protected <T> T doExecute(HibernateCallback<T> action, boolean enforceNewSession, boolean enforceNativeSession)throws DataAccessException {Assert.notNull(action, "Callback object must not be null");//获取Hibernate会话，判断是否需要新的SessionSession 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 {//根据Hibernate Session和事务类型应用相应的刷新模式previousFlushMode = applyFlushMode(session, existingTransaction);//对Session开启过滤器enableFilters(session);//判断Hibernate Session是否需要代理包装Session sessionToExpose =(enforceNativeSession || isExposeNativeSession() ? session : createSessionProxy(session));//对HibernateCallBack中回调函数的调用，真正调用Hibernate APIT result = action.doInHibernate(sessionToExpose);flushIfNecessary(session, existingTransaction);return result;}catch (HibernateException ex) {throw convertHibernateAccessException(ex);}catch (SQLException ex) {throw convertJdbcAccessException(ex);}catch (RuntimeException ex) {throw ex;}finally {//如果存在事务，则调用完毕之后不关闭Sessionif (existingTransaction) {logger.debug("Not closing pre-bound Hibernate Session after HibernateTemplate");//对Session禁用过滤器disableFilters(session);if (previousFlushMode != null) {session.setFlushMode(previousFlushMode);}}//如果不存在事务，则关闭当前的Sessionelse {if (isAlwaysUseNewSession()) {SessionFactoryUtils.closeSession(session);}else {SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, getSessionFactory());}}}}

(2).HibernateTemplate中增删改查操作的简单实现：

以查询为例，分析HibernateTemplate如何通过execute方法回调Hibernate相应的API，源码如下：

//查询指定Id的实体public Object get(String entityName, Serializable id) throws DataAccessException {return get(entityName, id, null);}//真正调用Hibernate API查询的方法public Object get(final String entityName, final Serializable id, final LockMode lockMode)throws DataAccessException {//调用Hibernate本地查询方法，参数是一个实现HibernateCallback接口的//匿名内部类，用于execute方法回调return executeWithNativeSession(new HibernateCallback<Object>() {//execute方法回调，真正调用Hibernate查询的方法public Object doInHibernate(Session session) throws HibernateException {if (lockMode != null) {return session.get(entityName, id, lockMode);}else {return session.get(entityName, id);}}});}

其他的load，update等等调用Hibernate的方法类似，各自提供不同的HibernateCallback回调来真正调用Hibernate相应方法。

5.Hibernate管理Session：

在4分析HibernateTemplate的doExecute法源码时我们看到，Spring根据是否需要新Session的判断，使用getSession和getNewSession两种不同的获取Session的方法，Spring中通过SessionFactoryUtils来管理HibernateSession，分析SessionFactoryUtils管理Session的实现源码：

(1).getNewSession实现：

//获取新Sessionpublic static Session getNewSession(SessionFactory sessionFactory, Interceptor entityInterceptor) {Assert.notNull(sessionFactory, "No SessionFactory specified");try {//获取事务管理器中的sessionFactory线程局部变量SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);//如果当前线程绑定了SessionFactory资源if (sessionHolder != null && !sessionHolder.isEmpty()) {//如果有实体拦截器，则打开一个有实体拦截器的Session连接if (entityInterceptor != null) {return sessionFactory.openSession(sessionHolder.getAnySession().connection(), entityInterceptor);}//如果没有实体拦截器，则直接打开当前线程中绑定的Session连接else {return sessionFactory.openSession(sessionHolder.getAnySession().connection());}}//如果当前线程没有绑定SessionFactory资源else {//如果有实体拦截器if (entityInterceptor != null) {//打开一个包含给定实体拦截器的Sessionreturn sessionFactory.openSession(entityInterceptor);}//如果没有实体拦截器，则直接打开一个新的Sessionelse {return sessionFactory.openSession();}}}catch (HibernateException ex) {throw new DataAccessResourceFailureException("Could not open Hibernate Session", ex);}}

(2).getSession实现：

//获取Hibernate Session的入口方法public static Session getSession(SessionFactory sessionFactory, boolean allowCreate)throws DataAccessResourceFailureException, IllegalStateException {try {//通过调用doGetSession来获取Hibernate Sessionreturn doGetSession(sessionFactory, null, null, allowCreate);}catch (HibernateException ex) {throw new DataAccessResourceFailureException("Could not open Hibernate Session", ex);}} //获取Hibernate Sessionprivate static Session doGetSession(SessionFactory sessionFactory, Interceptor entityInterceptor,SQLExceptionTranslator jdbcExceptionTranslator, boolean allowCreate)throws HibernateException, IllegalStateException {Assert.notNull(sessionFactory, "No SessionFactory specified");//获取和当前线程绑定的Session资源SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);//如果当前线程有绑定了Session的资源，即已经有创建了的Sessionif (sessionHolder != null && !sessionHolder.isEmpty()) {Session session = null;//如果Spring事务管理是activate的if (TransactionSynchronizationManager.isSynchronizationActive() &&sessionHolder.doesNotHoldNonDefaultSession()) {//获取当前线程绑定的有效Sessionsession = sessionHolder.getValidatedSession();//如果获取了当前线程绑定的有效Session，并且当前线程绑定的Session//资源是事务同步的if (session != null && !sessionHolder.isSynchronizedWithTransaction()) {logger.debug("Registering Spring transaction synchronization for existing Hibernate Session");//为已有的Hibernate Session注册Spring事务同步TransactionSynchronizationManager.registerSynchronization(new SpringSessionSynchronization(sessionHolder, sessionFactory, jdbcExceptionTranslator, false));sessionHolder.setSynchronizedWithTransaction(true);//根据实现级别设置Session刷新模式FlushMode flushMode = session.getFlushMode();if (flushMode.lessThan(FlushMode.COMMIT) &&!TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {session.setFlushMode(FlushMode.AUTO);sessionHolder.setPreviousFlushMode(flushMode);}}}//如果没有Spring管理的事务else {//使用jta事务同步session = getJtaSynchronizedSession(sessionHolder, sessionFactory, jdbcExceptionTranslator);}if (session != null) {return session;}}logger.debug("Opening Hibernate Session");//当前线程没有绑定Session资源，则需要创建新SessionSession session = (entityInterceptor != null ?sessionFactory.openSession(entityInterceptor) : sessionFactory.openSession());//如果Spring管理的事务是activate的if (TransactionSynchronizationManager.isSynchronizationActive()) {logger.debug("Registering Spring transaction synchronization for new Hibernate Session");SessionHolder holderToUse = sessionHolder;//将新创建的Session添加到当前线程局部变量中if (holderToUse == null) {holderToUse = new SessionHolder(session);}else {holderToUse.addSession(session);}//设置Session刷新模式if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {session.setFlushMode(FlushMode.MANUAL);}//为新创建的Hibernate Session注册Spring事务TransactionSynchronizationManager.registerSynchronization(new SpringSessionSynchronization(holderToUse, sessionFactory, jdbcExceptionTranslator, true));holderToUse.setSynchronizedWithTransaction(true);//将新创建的Session与当前线资源程绑定if (holderToUse != sessionHolder) {TransactionSynchronizationManager.bindResource(sessionFactory, holderToUse);}}//如果没有Spring事务else {//为Session设置JTA事务registerJtaSynchronization(session, sessionFactory, jdbcExceptionTranslator, sessionHolder);}//判断是否允许返回给定的Sessionif (!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");}return session;}

通过上面Spring对Hibernate Session管理的源码分析，我们了解到Spring已经将Hibernate Session的获取与关闭，Session的事务处理，以及Session与线程资源绑定等操作做了封装统一管理，为应用使用Hibernate提供了方便。