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的获取和关闭，事务处理的绑定做好了封装 - 从这个角度看也大大方便了用户的使用。