O/R工具出现之后，简化了许多复杂的信息持久化的开发。Spring应用开发者可以通过 Spring提供的O/R方案更方便的使用各种持久化工具，比如Hibernate；下面我们就 Spring+Hibernate中的Spring实现做一个简单的剖析。
Spring对Hinberanate的配置是通过LocalSessionFacToryBean来完成的，这是一个工 厂Bean的实现，在基类AbstractSessionFacToryBean中：
Java代码
/** * 这是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); }
我们先看看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 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(); }
所以我们这里看到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)); }
拦截器的实现如下：
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(); } } }
我们看看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 != 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的回调：
Java代码
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:
Java代码
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的获取和关闭，事务处理的绑定做好了封装 – 从这个角度看 也大大方便了用户的使用。
宁愿停歇在你门前的那棵树上，看着你，守护你。
