共享社区

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

• /**
• * 这是FactoryBean需要实现的接口方法，直接取得当前的sessionFactory的值
• */
  
• public Object getObject() {
•     return
  this.sessionFactory;
• } 
  

这个值在afterPropertySet中定义：

• public
  void afterPropertiesSet() throws Exception {
•     //这个buildSessionFactory是通过配置信息得到SessionFactory的地方
  
•     SessionFactory rawSf = buildSessionFactory();
•     //这里使用了Proxy方法插入对getCurrentSession的拦截，得到和事务相关的session
  
•     this.sessionFactory = wrapSessionFactoryIfNecessary(rawSf);
• } 
  

我们先看看SessionFactory是怎样创建的，这个方法很长，包含了创建Hibernate的SessionFactory的详尽步骤：

• 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; 
•                 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); 
•             } 
•         } 
• 
  
•         if (this.configLocations != null) { 
•             for (int i = 0; i < this.configLocations.length; i++) { 
•                 // Load Hibernate configuration from given location.
  
•                 config.configure(this.configLocations.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.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.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; 
•                 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.getFile(); 
•                 if (!file.isDirectory()) { 
•                     throw
  new IllegalArgumentException( 
•                             "Mapping directory location [" + this.mappingDirectoryLocations + 
•                             "] 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:

• protected SessionFactory newSessionFactory(Configuration config) throws HibernateException { 
•     return config.buildSessionFactory(); 
• } 
  

所以我们这里看到LocalSessionFactory大致起到的一个读取资源配置然后生成SessionFactory的作用；当然这里在得到SessionFactory之后，还需要对session的事务管理作一些处理 -使用了一个Proxy模式对getCurrentSession方法进行了拦截；

• //这里先根据当前的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(); 
•         } 
•     } 
• } 
  

我们看看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; 
•     } 
  

这里就是在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()); 
•             } 
•         } 
•     } 
• } 
  

我们看看怎样得到对应的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()); 
•     } 
• } 
  

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