Spring源代码解析（八）：Spring驱动Hibernate的实现
O/R工具出现之后，简化了许多复杂的信息持久化的开发。Spring应用开发者可以通过Spring提供的O/R方案更方便的使用各种持久化工具，比如Hibernate；下面我们就Spring+Hibernate中的Spring实现做一个简单的剖析。
Spring对Hinberanate的配置是通过LocalSessionFactoryBean来完成的，这是一个工厂Bean的实现，在基类AbstractSessionFactoryBean中：

/**   * 这是FactoryBean需要实现的接口方法，直接取得当前的sessionFactory的值   */  public Object getObject() {       return this.sessionFactory;   }      /**     * 这是FactoryBean需要实现的接口方法，直接取得当前的sessionFactory的值     */    public Object getObject() {        return this.sessionFactory;    }这个值在afterPropertySet中定义： Java代码 public void afterPropertiesSet() throws Exception {       //这个buildSessionFactory是通过配置信息得到SessionFactory的地方       SessionFactory rawSf = buildSessionFactory();       //这里使用了Proxy方法插入对getCurrentSession的拦截，得到和事务相关的session       this.sessionFactory = wrapSessionFactoryIfNecessary(rawSf);   }      public void afterPropertiesSet() throws Exception {        //这个buildSessionFactory是通过配置信息得到SessionFactory的地方        SessionFactory rawSf = buildSessionFactory();        //这里使用了Proxy方法插入对getCurrentSession的拦截，得到和事务相关的session        this.sessionFactory = wrapSessionFactoryIfNecessary(rawSf);    }我们先看看SessionFactory是怎样创建的，这个方法很长，包含了创建Hibernate的SessionFactory的详尽步骤： Java代码 protected SessionFactory buildSessionFactory() throws Exception {       SessionFactory sf = null;         // Create Configuration instance.       Configuration config = newConfiguration();         //这里配置数据源，事务管理器，LobHander到Holder中，这个Holder是一个ThreadLocal变量,这样这些资源就和线程绑定了       if (this.dataSource != null) {           // Make given DataSource available for SessionFactory configuration.           configTimeDataSourceHolder.set(this.dataSource);       }         if (this.jtaTransactionManager != null) {           // Make Spring-provided JTA TransactionManager available.           configTimeTransactionManagerHolder.set(this.jtaTransactionManager);       }         if (this.lobHandler != null) {           // Make given LobHandler available for SessionFactory configuration.           // Do early because because mapping resource might refer to custom types.           configTimeLobHandlerHolder.set(this.lobHandler);       }         //这里是使用Hibernate的各个属性的配置，这里使用了Configuration类来抽象这些数据       try {           // Set connection release mode "on_close" as default.           // This was the case for Hibernate 3.0; Hibernate 3.1 changed           // it to "auto" (i.e. "after_statement" or "after_transaction").           // However, for Spring's resource management (in particular for           // HibernateTransactionManager), "on_close" is the better default.           config.setProperty(Environment.RELEASE_CONNECTIONS, ConnectionReleaseMode.ON_CLOSE.toString());             if (!isExposeTransactionAwareSessionFactory()) {               // Not exposing a SessionFactory proxy with transaction-aware               // getCurrentSession() method -> set Hibernate 3.1 CurrentSessionContext               // implementation instead, providing the Spring-managed Session that way.               // Can be overridden by a custom value for corresponding Hibernate property.               config.setProperty(Environment.CURRENT_SESSION_CONTEXT_CLASS,                       "org.springframework.orm.hibernate3.SpringSessionContext");           }             if (this.entityInterceptor != null) {               // Set given entity interceptor at SessionFactory level.               config.setInterceptor(this.entityInterceptor);           }             if (this.namingStrategy != null) {               // Pass given naming strategy to Hibernate Configuration.               config.setNamingStrategy(this.namingStrategy);           }             if (this.typeDefinitions != null) {               // Register specified Hibernate type definitions.               Mappings mappings = config.createMappings();               for (int i = 0; i < this.typeDefinitions.length; i++) {                   TypeDefinitionBean typeDef = this.typeDefinitions[i];                   mappings.addTypeDef(typeDef.getTypeName(), typeDef.getTypeClass(), typeDef.getParameters());               }           }             if (this.filterDefinitions != null) {               // Register specified Hibernate FilterDefinitions.               for (int i = 0; i < this.filterDefinitions.length; i++) {                   config.addFilterDefinition(this.filterDefinitions[i]);               }           }             if (this.configLocations != null) {               for (int i = 0; i < this.configLocations.length; i++) {                   // Load Hibernate configuration from given location.                   config.configure(this.configLocations[i].getURL());               }           }             if (this.hibernateProperties != null) {               // Add given Hibernate properties to Configuration.               config.addProperties(this.hibernateProperties);           }             if (this.dataSource != null) {               boolean actuallyTransactionAware =                       (this.useTransactionAwareDataSource || this.dataSource instanceof TransactionAwareDataSourceProxy);               // Set Spring-provided DataSource as Hibernate ConnectionProvider.               config.setProperty(Environment.CONNECTION_PROVIDER,                       actuallyTransactionAware ?                       TransactionAwareDataSourceConnectionProvider.class.getName() :                       LocalDataSourceConnectionProvider.class.getName());           }             if (this.jtaTransactionManager != null) {               // Set Spring-provided JTA TransactionManager as Hibernate property.               config.setProperty(                       Environment.TRANSACTION_MANAGER_STRATEGY, LocalTransactionManagerLookup.class.getName());           }             if (this.mappingLocations != null) {               // Register given Hibernate mapping definitions, contained in resource files.               for (int i = 0; i < this.mappingLocations.length; i++) {                   config.addInputStream(this.mappingLocations[i].getInputStream());               }           }             if (this.cacheableMappingLocations != null) {               // Register given cacheable Hibernate mapping definitions, read from the file system.               for (int i = 0; i < this.cacheableMappingLocations.length; i++) {                   config.addCacheableFile(this.cacheableMappingLocations[i].getFile());               }           }             if (this.mappingJarLocations != null) {               // Register given Hibernate mapping definitions, contained in jar files.               for (int i = 0; i < this.mappingJarLocations.length; i++) {                   Resource resource = this.mappingJarLocations[i];                   config.addJar(resource.getFile());               }           }             if (this.mappingDirectoryLocations != null) {               // Register all Hibernate mapping definitions in the given directories.               for (int i = 0; i < this.mappingDirectoryLocations.length; i++) {                   File file = this.mappingDirectoryLocations[i].getFile();                   if (!file.isDirectory()) {                       throw new IllegalArgumentException(                               "Mapping directory location [" + this.mappingDirectoryLocations[i] +                               "] does not denote a directory");                   }                   config.addDirectory(file);               }           }             if (this.entityCacheStrategies != null) {               // Register cache strategies for mapped entities.               for (Enumeration classNames = this.entityCacheStrategies.propertyNames(); classNames.hasMoreElements();) {                   String className = (String) classNames.nextElement();                   String[] strategyAndRegion =                           StringUtils.commaDelimitedListToStringArray(this.entityCacheStrategies.getProperty(className));                   if (strategyAndRegion.length > 1) {                       config.setCacheConcurrencyStrategy(className, strategyAndRegion[0], strategyAndRegion[1]);                   }                   else if (strategyAndRegion.length > 0) {                       config.setCacheConcurrencyStrategy(className, strategyAndRegion[0]);                   }               }           }             if (this.collectionCacheStrategies != null) {               // Register cache strategies for mapped collections.               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]);                   }               }           }             if (this.eventListeners != null) {               // Register specified Hibernate event listeners.               for (Iterator it = this.eventListeners.entrySet().iterator(); it.hasNext();) {                   Map.Entry entry = (Map.Entry) it.next();                   Assert.isTrue(entry.getKey() instanceof String, "Event listener key needs to be of type String");                   String listenerType = (String) entry.getKey();                   Object listenerObject = entry.getValue();                   if (listenerObject instanceof Collection) {                       Collection listeners = (Collection) listenerObject;                       EventListeners listenerRegistry = config.getEventListeners();                       Object[] listenerArray =                               (Object[]) Array.newInstance(listenerRegistry.getListenerClassFor(listenerType), listeners.size());                       listenerArray = listeners.toArray(listenerArray);                       config.setListeners(listenerType, listenerArray);                   }                   else {                       config.setListener(listenerType, listenerObject);                   }               }           }             // Perform custom post-processing in subclasses.           postProcessConfiguration(config);             // 这里是根据Configuration配置创建SessionFactory的地方           logger.info("Building new Hibernate SessionFactory");           this.configuration = config;           sf = newSessionFactory(config);       }       //最后把和线程绑定的资源清空       finally {           if (this.dataSource != null) {               // Reset DataSource holder.               configTimeDataSourceHolder.set(null);           }             if (this.jtaTransactionManager != null) {               // Reset TransactionManager holder.               configTimeTransactionManagerHolder.set(null);           }             if (this.lobHandler != null) {               // Reset LobHandler holder.               configTimeLobHandlerHolder.set(null);           }       }         // Execute schema update if requested.       if (this.schemaUpdate) {           updateDatabaseSchema();       }         return sf;   }      protected SessionFactory buildSessionFactory() throws Exception {        SessionFactory sf = null;        // Create Configuration instance.        Configuration config = newConfiguration();        //这里配置数据源，事务管理器，LobHander到Holder中，这个Holder是一个ThreadLocal变量,这样这些资源就和线程绑定了        if (this.dataSource != null) {            // Make given DataSource available for SessionFactory configuration.            configTimeDataSourceHolder.set(this.dataSource);        }        if (this.jtaTransactionManager != null) {            // Make Spring-provided JTA TransactionManager available.            configTimeTransactionManagerHolder.set(this.jtaTransactionManager);        }        if (this.lobHandler != null) {            // Make given LobHandler available for SessionFactory configuration.            // Do early because because mapping resource might refer to custom types.            configTimeLobHandlerHolder.set(this.lobHandler);        }        //这里是使用Hibernate的各个属性的配置，这里使用了Configuration类来抽象这些数据        try {            // Set connection release mode "on_close" as default.            // This was the case for Hibernate 3.0; Hibernate 3.1 changed            // it to "auto" (i.e. "after_statement" or "after_transaction").            // However, for Spring's resource management (in particular for            // HibernateTransactionManager), "on_close" is the better default.            config.setProperty(Environment.RELEASE_CONNECTIONS, ConnectionReleaseMode.ON_CLOSE.toString());            if (!isExposeTransactionAwareSessionFactory()) {                // Not exposing a SessionFactory proxy with transaction-aware                // getCurrentSession() method -> set Hibernate 3.1 CurrentSessionContext                // implementation instead, providing the Spring-managed Session that way.                // Can be overridden by a custom value for corresponding Hibernate property.                config.setProperty(Environment.CURRENT_SESSION_CONTEXT_CLASS,                        "org.springframework.orm.hibernate3.SpringSessionContext");            }            if (this.entityInterceptor != null) {                // Set given entity interceptor at SessionFactory level.                config.setInterceptor(this.entityInterceptor);            }            if (this.namingStrategy != null) {                // Pass given naming strategy to Hibernate Configuration.                config.setNamingStrategy(this.namingStrategy);            }            if (this.typeDefinitions != null) {                // Register specified Hibernate type definitions.                Mappings mappings = config.createMappings();                for (int i = 0; i < this.typeDefinitions.length; i++) {                    TypeDefinitionBean typeDef = this.typeDefinitions[i];                    mappings.addTypeDef(typeDef.getTypeName(), typeDef.getTypeClass(), typeDef.getParameters());                }            }            if (this.filterDefinitions != null) {                // Register specified Hibernate FilterDefinitions.                for (int i = 0; i < this.filterDefinitions.length; i++) {                    config.addFilterDefinition(this.filterDefinitions[i]);                }            }            if (this.configLocations != null) {                for (int i = 0; i < this.configLocations.length; i++) {                    // Load Hibernate configuration from given location.                    config.configure(this.configLocations[i].getURL());                }            }            if (this.hibernateProperties != null) {                // Add given Hibernate properties to Configuration.                config.addProperties(this.hibernateProperties);            }            if (this.dataSource != null) {                boolean actuallyTransactionAware =                        (this.useTransactionAwareDataSource || this.dataSource instanceof TransactionAwareDataSourceProxy);                // Set Spring-provided DataSource as Hibernate ConnectionProvider.                config.setProperty(Environment.CONNECTION_PROVIDER,                        actuallyTransactionAware ?                        TransactionAwareDataSourceConnectionProvider.class.getName() :                        LocalDataSourceConnectionProvider.class.getName());            }            if (this.jtaTransactionManager != null) {                // Set Spring-provided JTA TransactionManager as Hibernate property.                config.setProperty(                        Environment.TRANSACTION_MANAGER_STRATEGY, LocalTransactionManagerLookup.class.getName());            }            if (this.mappingLocations != null) {                // Register given Hibernate mapping definitions, contained in resource files.                for (int i = 0; i < this.mappingLocations.length; i++) {                    config.addInputStream(this.mappingLocations[i].getInputStream());                }            }            if (this.cacheableMappingLocations != null) {                // Register given cacheable Hibernate mapping definitions, read from the file system.                for (int i = 0; i < this.cacheableMappingLocations.length; i++) {                    config.addCacheableFile(this.cacheableMappingLocations[i].getFile());                }            }            if (this.mappingJarLocations != null) {                // Register given Hibernate mapping definitions, contained in jar files.                for (int i = 0; i < this.mappingJarLocations.length; i++) {                    Resource resource = this.mappingJarLocations[i];                    config.addJar(resource.getFile());                }            }            if (this.mappingDirectoryLocations != null) {                // Register all Hibernate mapping definitions in the given directories.                for (int i = 0; i < this.mappingDirectoryLocations.length; i++) {                    File file = this.mappingDirectoryLocations[i].getFile();                    if (!file.isDirectory()) {                        throw new IllegalArgumentException(                                "Mapping directory location [" + this.mappingDirectoryLocations[i] +                                "] does not denote a directory");                    }                    config.addDirectory(file);                }            }            if (this.entityCacheStrategies != null) {                // Register cache strategies for mapped entities.                for (Enumeration classNames = this.entityCacheStrategies.propertyNames(); classNames.hasMoreElements();) {                    String className = (String) classNames.nextElement();                    String[] strategyAndRegion =                            StringUtils.commaDelimitedListToStringArray(this.entityCacheStrategies.getProperty(className));                    if (strategyAndRegion.length > 1) {                        config.setCacheConcurrencyStrategy(className, strategyAndRegion[0], strategyAndRegion[1]);                    }                    else if (strategyAndRegion.length > 0) {                        config.setCacheConcurrencyStrategy(className, strategyAndRegion[0]);                    }                }            }            if (this.collectionCacheStrategies != null) {                // Register cache strategies for mapped collections.                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]);                    }                }            }            if (this.eventListeners != null) {                // Register specified Hibernate event listeners.                for (Iterator it = this.eventListeners.entrySet().iterator(); it.hasNext();) {                    Map.Entry entry = (Map.Entry) it.next();                    Assert.isTrue(entry.getKey() instanceof String, "Event listener key needs to be of type String");                    String listenerType = (String) entry.getKey();                    Object listenerObject = entry.getValue();                    if (listenerObject instanceof Collection) {                        Collection listeners = (Collection) listenerObject;                        EventListeners listenerRegistry = config.getEventListeners();                        Object[] listenerArray =                                (Object[]) Array.newInstance(listenerRegistry.getListenerClassFor(listenerType), listeners.size());                        listenerArray = listeners.toArray(listenerArray);                        config.setListeners(listenerType, listenerArray);                    }                    else {                        config.setListener(listenerType, listenerObject);                    }                }            }            // Perform custom post-processing in subclasses.            postProcessConfiguration(config);            // 这里是根据Configuration配置创建SessionFactory的地方            logger.info("Building new Hibernate SessionFactory");            this.configuration = config;            sf = newSessionFactory(config);        }        //最后把和线程绑定的资源清空        finally {            if (this.dataSource != null) {                // Reset DataSource holder.                configTimeDataSourceHolder.set(null);            }            if (this.jtaTransactionManager != null) {                // Reset TransactionManager holder.                configTimeTransactionManagerHolder.set(null);            }            if (this.lobHandler != null) {                // Reset LobHandler holder.                configTimeLobHandlerHolder.set(null);            }        }        // Execute schema update if requested.        if (this.schemaUpdate) {            updateDatabaseSchema();        }        return sf;    }而直接调用org.hibernate.cfg.Configuration来得到需要的SessionFactory: Java代码 protected SessionFactory newSessionFactory(Configuration config) throws HibernateException {       return config.buildSessionFactory();   }      protected SessionFactory newSessionFactory(Configuration config) throws HibernateException {        return config.buildSessionFactory();    }所以我们这里看到LocalSessionFactory大致起到的一个读取资源配置然后生成SessionFactory的作用；当然这里在得到 SessionFactory之后，还需要对session的事务管理作一些处理 - 使用了一个Proxy模式对getCurrentSession方法进行了拦截； Java代码 //这里先根据当前的SessionFactory的类型得到Proxy，然后插入Spring定义好的getCurrentSession拦截器       protected SessionFactory getTransactionAwareSessionFactoryProxy(SessionFactory target) {           Class sfInterface = SessionFactory.class;           if (target instanceof SessionFactoryImplementor) {               sfInterface = SessionFactoryImplementor.class;           }           return (SessionFactory) Proxy.newProxyInstance(sfInterface.getClassLoader(),                   new Class[] {sfInterface}, new TransactionAwareInvocationHandler(target));       }  //这里先根据当前的SessionFactory的类型得到Proxy，然后插入Spring定义好的getCurrentSession拦截器    protected SessionFactory getTransactionAwareSessionFactoryProxy(SessionFactory target) {        Class sfInterface = SessionFactory.class;        if (target instanceof SessionFactoryImplementor) {            sfInterface = SessionFactoryImplementor.class;        }        return (SessionFactory) Proxy.newProxyInstance(sfInterface.getClassLoader(),                new Class[] {sfInterface}, new TransactionAwareInvocationHandler(target));    }

拦截器的实现如下：

private static class TransactionAwareInvocationHandler implements InvocationHandler {         private final SessionFactory target;         public TransactionAwareInvocationHandler(SessionFactory target) {           this.target = target;       }         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {           // Invocation on SessionFactory/SessionFactoryImplementor interface coming in...           // 这里对getCurrentSession方法进行拦截，得到一个和当前事务绑定的session交给用户           if (method.getName().equals("getCurrentSession")) {               // Handle getCurrentSession method: return transactional Session, if any.               try {                   return SessionFactoryUtils.doGetSession((SessionFactory) proxy, false);               }               catch (IllegalStateException ex) {                   throw new HibernateException(ex.getMessage());               }           }           else if (method.getName().equals("equals")) {               // Only consider equal when proxies are identical.               return (proxy == args[0] ? Boolean.TRUE : Boolean.FALSE);           }           else if (method.getName().equals("hashCode")) {               // Use hashCode of SessionFactory proxy.               return new Integer(hashCode());           }             // 这里是需要运行的SessionFactory的目标方法           try {               return method.invoke(this.target, args);           }           catch (InvocationTargetException ex) {               throw ex.getTargetException();           }       }   }      private static class TransactionAwareInvocationHandler implements InvocationHandler {        private final SessionFactory target;        public TransactionAwareInvocationHandler(SessionFactory target) {            this.target = target;        }        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {            // Invocation on SessionFactory/SessionFactoryImplementor interface coming in...            // 这里对getCurrentSession方法进行拦截，得到一个和当前事务绑定的session交给用户            if (method.getName().equals("getCurrentSession")) {                // Handle getCurrentSession method: return transactional Session, if any.                try {                    return SessionFactoryUtils.doGetSession((SessionFactory) proxy, false);                }                catch (IllegalStateException ex) {                    throw new HibernateException(ex.getMessage());                }            }            else if (method.getName().equals("equals")) {                // Only consider equal when proxies are identical.                return (proxy == args[0] ? Boolean.TRUE : Boolean.FALSE);            }            else if (method.getName().equals("hashCode")) {                // Use hashCode of SessionFactory proxy.                return new Integer(hashCode());            }            // 这里是需要运行的SessionFactory的目标方法            try {                return method.invoke(this.target, args);            }            catch (InvocationTargetException ex) {                throw ex.getTargetException();            }        }    }

我们看看getCurrentSession的实现，在SessionFactoryUtils中：

private static Session doGetSession(               SessionFactory sessionFactory, Interceptor entityInterceptor,               SQLExceptionTranslator jdbcExceptionTranslator, boolean allowCreate)               throws HibernateException, IllegalStateException {             Assert.notNull(sessionFactory, "No SessionFactory specified");             //这个TransactionSynchronizationManager的Resource是一个ThreadLocal变量,sessionFactory是一个单例，但ThreadLocal是和线程绑定的           //这样就实现了Hiberante中常用的通过ThreadLocal的session管理机制           SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);           if (sessionHolder != null && !sessionHolder.isEmpty()) {               // pre-bound Hibernate Session               Session session = null;               if (TransactionSynchronizationManager.isSynchronizationActive() &&                       sessionHolder.doesNotHoldNonDefaultSession()) {                   // Spring transaction management is active ->                   // register pre-bound Session with it for transactional flushing.                   session = sessionHolder.getValidatedSession();                   if (session != null && !sessionHolder.isSynchronizedWithTransaction()) {                       logger.debug("Registering Spring transaction synchronization for existing Hibernate Session");                       TransactionSynchronizationManager.registerSynchronization(                               new SpringSessionSynchronization(sessionHolder, sessionFactory, jdbcExceptionTranslator, false));                       sessionHolder.setSynchronizedWithTransaction(true);                       // Switch to FlushMode.AUTO, as we have to assume a thread-bound Session                       // with FlushMode.NEVER, which needs to allow flushing within the transaction.                       FlushMode flushMode = session.getFlushMode();                       if (flushMode.lessThan(FlushMode.COMMIT) &&                               !TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {                           session.setFlushMode(FlushMode.AUTO);                           sessionHolder.setPreviousFlushMode(flushMode);                       }                   }               }               else {                   // No Spring transaction management active -> try JTA transaction synchronization.                   session = getJtaSynchronizedSession(sessionHolder, sessionFactory, jdbcExceptionTranslator);               }               if (session != null) {                   return session;               }           }           //这里直接打开一个Session           logger.debug("Opening Hibernate Session");           Session session = (entityInterceptor != null ?                   sessionFactory.openSession(entityInterceptor) : sessionFactory.openSession());             // Use same Session for further Hibernate actions within the transaction.           // Thread object will get removed by synchronization at transaction completion.           // 把新打开的Session放到SessionHolder,然后放到ThreadLocal里面去和线程绑定起来，这个ThreadLocal是在 TransactionSynchronizationManager中配置好的，可以根据sessionFactory来索取           // 同时根据事务处理的状态来配置session的属性,比如把FlushMode设置为Never，同时把session和事务处理关联起来           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 {               // No Spring transaction management active -> try JTA transaction synchronization.               registerJtaSynchronization(session, sessionFactory, jdbcExceptionTranslator, sessionHolder);           }             // Check whether we are allowed to return the 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");           }             return session;       }  private static Session doGetSession(            SessionFactory sessionFactory, Interceptor entityInterceptor,            SQLExceptionTranslator jdbcExceptionTranslator, boolean allowCreate)            throws HibernateException, IllegalStateException {        Assert.notNull(sessionFactory, "No SessionFactory specified");        //这个TransactionSynchronizationManager的Resource是一个ThreadLocal变量,sessionFactory是一个单例，但ThreadLocal是和线程绑定的        //这样就实现了Hiberante中常用的通过ThreadLocal的session管理机制        SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);        if (sessionHolder != null && !sessionHolder.isEmpty()) {            // pre-bound Hibernate Session            Session session = null;            if (TransactionSynchronizationManager.isSynchronizationActive() &&                    sessionHolder.doesNotHoldNonDefaultSession()) {                // Spring transaction management is active ->                // register pre-bound Session with it for transactional flushing.                session = sessionHolder.getValidatedSession();                if (session != null && !sessionHolder.isSynchronizedWithTransaction()) {                    logger.debug("Registering Spring transaction synchronization for existing Hibernate Session");                    TransactionSynchronizationManager.registerSynchronization(                            new SpringSessionSynchronization(sessionHolder, sessionFactory, jdbcExceptionTranslator, false));                    sessionHolder.setSynchronizedWithTransaction(true);                    // Switch to FlushMode.AUTO, as we have to assume a thread-bound Session                    // with FlushMode.NEVER, which needs to allow flushing within the transaction.                    FlushMode flushMode = session.getFlushMode();                    if (flushMode.lessThan(FlushMode.COMMIT) &&                            !TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {                        session.setFlushMode(FlushMode.AUTO);                        sessionHolder.setPreviousFlushMode(flushMode);                    }                }            }            else {                // No Spring transaction management active -> try JTA transaction synchronization.                session = getJtaSynchronizedSession(sessionHolder, sessionFactory, jdbcExceptionTranslator);            }            if (session != null) {                return session;            }        }        //这里直接打开一个Session        logger.debug("Opening Hibernate Session");        Session session = (entityInterceptor != null ?                sessionFactory.openSession(entityInterceptor) : sessionFactory.openSession());        // Use same Session for further Hibernate actions within the transaction.        // Thread object will get removed by synchronization at transaction completion.        // 把新打开的Session放到SessionHolder,然后放到ThreadLocal里面去和线程绑定起来，这个ThreadLocal是在 TransactionSynchronizationManager中配置好的，可以根据sessionFactory来索取        // 同时根据事务处理的状态来配置session的属性,比如把FlushMode设置为Never，同时把session和事务处理关联起来        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 {            // No Spring transaction management active -> try JTA transaction synchronization.            registerJtaSynchronization(session, sessionFactory, jdbcExceptionTranslator, sessionHolder);        }        // Check whether we are allowed to return the 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");        }        return session;    }

这里就是在Spring中为使用Hiberante的SessionFactory以及Session做的准备工作，在这个基础上，用户可以通过使用 HibernateTemplate来使用Hibernate的O/R功能，和以前看到的一样这是一个execute的回调：

public Object execute(HibernateCallback action, boolean exposeNativeSession) throws DataAccessException {       Assert.notNull(action, "Callback object must not be null");       //这里得到配置好的Hibernate的Session       Session session = getSession();       boolean existingTransaction = 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 = (exposeNativeSession ? 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);               }           } //否则把Session关闭           else {               // Never use deferred close for an explicitly new Session.               if (isAlwaysUseNewSession()) {                   SessionFactoryUtils.closeSession(session);               }               else {                   SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, getSessionFactory());               }           }       }   }      public Object execute(HibernateCallback action, boolean exposeNativeSession) throws DataAccessException {        Assert.notNull(action, "Callback object must not be null");        //这里得到配置好的Hibernate的Session        Session session = getSession();        boolean existingTransaction = 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 = (exposeNativeSession ? 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);                }            } //否则把Session关闭            else {                // Never use deferred close for an explicitly new Session.                if (isAlwaysUseNewSession()) {                    SessionFactoryUtils.closeSession(session);                }                else {                    SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, getSessionFactory());                }            }        }    }

我们看看怎样得到对应的Session的，仍然使用了SessionFactoryUtils的方法doGetSession:

protected Session getSession() {       if (isAlwaysUseNewSession()) {           return SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor());       }       else if (!isAllowCreate()) {           return SessionFactoryUtils.getSession(getSessionFactory(), false);       }       else {           return SessionFactoryUtils.getSession(                   getSessionFactory(), getEntityInterceptor(), getJdbcExceptionTranslator());       }   }      protected Session getSession() {        if (isAlwaysUseNewSession()) {            return SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor());        }        else if (!isAllowCreate()) {            return SessionFactoryUtils.getSession(getSessionFactory(), false);        }        else {            return SessionFactoryUtils.getSession(                    getSessionFactory(), getEntityInterceptor(), getJdbcExceptionTranslator());        }    }

这样我们就可以和其他的Template那样使用Hibernate的基本功能了，使用的时候Spring已经为我们对Session的获取和关闭，事务处理的绑定做好了封装 - 从这个角度看也大大方便了用户的使用。