Spring源代码解析(八)：Spring驱动Hibernate的实现

最新推荐文章于 2024-07-07 16:49:34 发布

lhb739921140

最新推荐文章于 2024-07-07 16:49:34 发布

阅读量95

点赞数

分类专栏： SPRING 文章标签： Spring Hibernate 配置管理 Cache ORM

SPRING 专栏收录该内容

26 篇文章 1 订阅

订阅专栏

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

Java代码

/**
* 这是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));
    }

拦截器的实现如下：

Java代码

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中：

Java代码

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 != se