## org.springframework.orm.hibernate3
Class AbstractSessionFactoryBean

    java.lang.Object
      org.springframework.orm.hibernate3.AbstractSessionFactoryBean

All Implemented Interfaces:
  DisposableBean, FactoryBean<org.hibernate.SessionFactory>, InitializingBean, PersistenceExceptionTranslator

Direct Known Subclasses:
  LocalSessionFactoryBean

    public abstract class AbstractSessionFactoryBean

extends Object
implements FactoryBean<org.hibernate.SessionFactory>, InitializingBean, DisposableBean, PersistenceExceptionTranslator

Abstract `FactoryBean` that creates a Hibernate `SessionFactory` within a Spring application context, providing general infrastructure not related to Hibernate's specific configuration API.

This class implements the `PersistenceExceptionTranslator` interface, as autodetected by Spring's `PersistenceExceptionTranslationPostProcessor`, for AOP-based translation of native exceptions to Spring DataAccessExceptions. Hence, the presence of e.g. LocalSessionFactoryBean automatically enables a PersistenceExceptionTranslationPostProcessor to translate Hibernate exceptions.

This class mainly serves as common base class for `LocalSessionFactoryBean`. For details on typical SessionFactory setup, see the LocalSessionFactoryBean javadoc.

Since:
  2.0
Author:
  Juergen Hoeller
See Also:
  `setExposeTransactionAwareSessionFactory(boolean)`, `SessionFactory.getCurrentSession()`, `PersistenceExceptionTranslationPostProcessor`

Field Summary
`protected Log` `logger` Logger available to subclasses

Constructor Summary
`AbstractSessionFactoryBean()`

Method Summary
`void` `afterPropertiesSet()` Build and expose the SessionFactory.
`protected void` `afterSessionFactoryCreation()` Hook that allows post-processing after the SessionFactory has been successfully created.
`protected void` `beforeSessionFactoryDestruction()` Hook that allows shutdown processing before the SessionFactory will be closed.
`protected abstract org.hibernate.SessionFactory` `buildSessionFactory()` Build the underlying Hibernate SessionFactory.
`protected DataAccessException` `convertHibernateAccessException(org.hibernate.HibernateException ex)` Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.
`void` `destroy()` Close the SessionFactory on bean factory shutdown.
`DataSource` `getDataSource()` Return the DataSource to be used by the SessionFactory.
`org.hibernate.SessionFactory` `getObject()` Return the singleton SessionFactory.
`Class<? extends org.hibernate.SessionFactory>` `getObjectType()` Return the type of object that this FactoryBean creates, or `null` if not known in advance.
`protected org.hibernate.SessionFactory` `getSessionFactory()` Return the exposed SessionFactory.
`protected boolean` `isExposeTransactionAwareSessionFactory()` Return whether to expose a transaction-aware proxy for the SessionFactory.
`boolean` `isSingleton()` Is the object managed by this factory a singleton? That is, will `FactoryBean.getObject()` always return the same object (a reference that can be cached)?
`protected boolean` `isUseTransactionAwareDataSource()` Return whether to use a transaction-aware DataSource for the SessionFactory.
`void` `setDataSource(DataSource dataSource)` Set the DataSource to be used by the SessionFactory.
`void` `setExposeTransactionAwareSessionFactory(boolean exposeTransactionAwareSessionFactory)` Set whether to expose a transaction-aware current Session from the SessionFactory's `getCurrentSession()` method, returning the Session that's associated with the current Spring-managed transaction, if any.
`void` `setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator)` Set the JDBC exception translator for the SessionFactory, exposed via the PersistenceExceptionTranslator interface.
`void` `setUseTransactionAwareDataSource(boolean useTransactionAwareDataSource)` Set whether to use a transaction-aware DataSource for the SessionFactory, i.e.
`DataAccessException` `translateExceptionIfPossible(RuntimeException ex)` Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.
`protected org.hibernate.SessionFactory` `wrapSessionFactoryIfNecessary(org.hibernate.SessionFactory rawSf)` Wrap the given SessionFactory with a proxy, if demanded.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### logger

    protected final Log logger

  Logger available to subclasses

Constructor Detail

### AbstractSessionFactoryBean

    public AbstractSessionFactoryBean()

Method Detail

### setDataSource

    public void setDataSource(DataSource dataSource)

  Set the DataSource to be used by the SessionFactory. If set, this will override corresponding settings in Hibernate properties.

  If this is set, the Hibernate settings should not define a connection provider to avoid meaningless double configuration.

  If using HibernateTransactionManager as transaction strategy, consider proxying your target DataSource with a LazyConnectionDataSourceProxy. This defers fetching of an actual JDBC Connection until the first JDBC Statement gets executed, even within JDBC transactions (as performed by HibernateTransactionManager). Such lazy fetching is particularly beneficial for read-only operations, in particular if the chances of resolving the result in the second-level cache are high.

  As JTA and transactional JNDI DataSources already provide lazy enlistment of JDBC Connections, LazyConnectionDataSourceProxy does not add value with JTA (i.e. Spring's JtaTransactionManager) as transaction strategy.

  See Also:
    `setUseTransactionAwareDataSource(boolean)`, `HibernateTransactionManager`, `JtaTransactionManager`, `LazyConnectionDataSourceProxy`

### getDataSource

    public DataSource getDataSource()

  Return the DataSource to be used by the SessionFactory.

### setUseTransactionAwareDataSource

    public void setUseTransactionAwareDataSource(boolean useTransactionAwareDataSource)

  Set whether to use a transaction-aware DataSource for the SessionFactory, i.e. whether to automatically wrap the passed-in DataSource with Spring's TransactionAwareDataSourceProxy.

  Default is "false": LocalSessionFactoryBean is usually used with Spring's HibernateTransactionManager or JtaTransactionManager, both of which work nicely on a plain JDBC DataSource. Hibernate Sessions and their JDBC Connections are fully managed by the Hibernate/JTA transaction infrastructure in such a scenario.

  If you switch this flag to "true", Spring's Hibernate access will be able to participate in JDBC-based transactions managed outside of Hibernate (for example, by Spring's DataSourceTransactionManager). This can be convenient if you need a different local transaction strategy for another O/R mapping tool, for example, but still want Hibernate access to join into those transactions.

  A further benefit of this option is that plain Sessions opened directly via the SessionFactory, outside of Spring's Hibernate support, will still participate in active Spring-managed transactions. However, consider using Hibernate's `getCurrentSession()` method instead (see javadoc of "exposeTransactionAwareSessionFactory" property).

  WARNING: When using a transaction-aware JDBC DataSource in combination with OpenSessionInViewFilter/Interceptor, whether participating in JTA or external JDBC-based transactions, it is strongly recommended to set Hibernate's Connection release mode to "after_transaction" or "after_statement", which guarantees proper Connection handling in such a scenario. In contrast to that, HibernateTransactionManager generally requires release mode "on_close".

  Note: If you want to use Hibernate's Connection release mode "after_statement" with a DataSource specified on this LocalSessionFactoryBean (for example, a JTA-aware DataSource fetched from JNDI), switch this setting to "true". Otherwise, the ConnectionProvider used underneath will vote against aggressive release and thus silently switch to release mode "after_transaction".

  See Also:
    `setDataSource(javax.sql.DataSource)`, `setExposeTransactionAwareSessionFactory(boolean)`, `TransactionAwareDataSourceProxy`, `DataSourceTransactionManager`, `OpenSessionInViewFilter`, `OpenSessionInViewInterceptor`, `HibernateTransactionManager`, `JtaTransactionManager`

### isUseTransactionAwareDataSource

    protected boolean isUseTransactionAwareDataSource()

  Return whether to use a transaction-aware DataSource for the SessionFactory.

### setExposeTransactionAwareSessionFactory

    public void setExposeTransactionAwareSessionFactory(boolean exposeTransactionAwareSessionFactory)

  Set whether to expose a transaction-aware current Session from the SessionFactory's `getCurrentSession()` method, returning the Session that's associated with the current Spring-managed transaction, if any.

  Default is "true", letting data access code work with the plain Hibernate SessionFactory and its `getCurrentSession()` method, while still being able to participate in current Spring-managed transactions: with any transaction management strategy, either local or JTA / EJB CMT, and any transaction synchronization mechanism, either Spring or JTA. Furthermore, `getCurrentSession()` will also seamlessly work with a request-scoped Session managed by OpenSessionInViewFilter/Interceptor.

  Turn this flag off to expose the plain Hibernate SessionFactory with Hibernate's default `getCurrentSession()` behavior, supporting plain JTA synchronization only. Alternatively, simply override the corresponding Hibernate property "hibernate.current_session_context_class".

  See Also:
    `SpringSessionContext`, `SessionFactory.getCurrentSession()`, `JtaTransactionManager`, `HibernateTransactionManager`, `OpenSessionInViewFilter`, `OpenSessionInViewInterceptor`

### isExposeTransactionAwareSessionFactory

    protected boolean isExposeTransactionAwareSessionFactory()

  Return whether to expose a transaction-aware proxy for the SessionFactory.

### setJdbcExceptionTranslator

    public void setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator)

  Set the JDBC exception translator for the SessionFactory, exposed via the PersistenceExceptionTranslator interface.

  Applied to any SQLException root cause of a Hibernate JDBCException, overriding Hibernate's default SQLException translation (which is based on Hibernate's Dialect for a specific target database).

  Parameters:
    `jdbcExceptionTranslator` - the exception translator
  See Also:
    `SQLException`, `JDBCException`, `SQLErrorCodeSQLExceptionTranslator`, `SQLStateSQLExceptionTranslator`, `PersistenceExceptionTranslator`

### afterPropertiesSet

    public void afterPropertiesSet()
                            throws Exception

  Build and expose the SessionFactory.

  Specified by:
    `afterPropertiesSet` in interface `InitializingBean`
  Throws:
    `Exception` - in the event of misconfiguration (such as failure to set an essential property) or if initialization fails.
  See Also:
    `buildSessionFactory()`, `wrapSessionFactoryIfNecessary(org.hibernate.SessionFactory)`

### wrapSessionFactoryIfNecessary

    protected org.hibernate.SessionFactory wrapSessionFactoryIfNecessary(org.hibernate.SessionFactory rawSf)

  Wrap the given SessionFactory with a proxy, if demanded.

  The default implementation simply returns the given SessionFactory as-is. Subclasses may override this to implement transaction awareness through a SessionFactory proxy, for example.

  Parameters:
    `rawSf` - the raw SessionFactory as built by `buildSessionFactory()`
  Returns:
    the SessionFactory reference to expose
  See Also:
    `buildSessionFactory()`

### getSessionFactory

    protected final org.hibernate.SessionFactory getSessionFactory()

  Return the exposed SessionFactory. Will throw an exception if not initialized yet.

  Returns:
    the SessionFactory (never `null`)
  Throws:
    `IllegalStateException` - if the SessionFactory has not been initialized yet

### destroy

    public void destroy()
                 throws org.hibernate.HibernateException

  Close the SessionFactory on bean factory shutdown.

  Specified by:
    `destroy` in interface `DisposableBean`
  Throws:
    `org.hibernate.HibernateException`

### getObject

    public org.hibernate.SessionFactory getObject()

  Return the singleton SessionFactory.

  Specified by:
    `getObject` in interface `FactoryBean<org.hibernate.SessionFactory>`
  Returns:
    an instance of the bean (can be `null`)
  See Also:
    `FactoryBeanNotInitializedException`

### getObjectType

    public Class<? extends org.hibernate.SessionFactory> getObjectType()

  Description copied from interface: `FactoryBean`
  Return the type of object that this FactoryBean creates, or `null` if not known in advance.

  This allows one to check for specific types of beans without instantiating objects, for example on autowiring.

  In the case of implementations that are creating a singleton object, this method should try to avoid singleton creation as far as possible; it should rather estimate the type in advance. For prototypes, returning a meaningful type here is advisable too.

  This method can be called before this FactoryBean has been fully initialized. It must not rely on state created during initialization; of course, it can still use such state if available.

  NOTE: Autowiring will simply ignore FactoryBeans that return `null` here. Therefore it is highly recommended to implement this method properly, using the current state of the FactoryBean.

  Specified by:
    `getObjectType` in interface `FactoryBean<org.hibernate.SessionFactory>`
  Returns:
    the type of object that this FactoryBean creates, or `null` if not known at the time of the call
  See Also:
    `ListableBeanFactory.getBeansOfType(java.lang.Class<T>)`

### isSingleton

    public boolean isSingleton()

  Description copied from interface: `FactoryBean`
  Is the object managed by this factory a singleton? That is, will `FactoryBean.getObject()` always return the same object (a reference that can be cached)?

  NOTE: If a FactoryBean indicates to hold a singleton object, the object returned from `getObject()` might get cached by the owning BeanFactory. Hence, do not return `true` unless the FactoryBean always exposes the same reference.

  The singleton status of the FactoryBean itself will generally be provided by the owning BeanFactory; usually, it has to be defined as singleton there.

  NOTE: This method returning `false` does not necessarily indicate that returned objects are independent instances. An implementation of the extended `SmartFactoryBean` interface may explicitly indicate independent instances through its `SmartFactoryBean.isPrototype()` method. Plain `FactoryBean` implementations which do not implement this extended interface are simply assumed to always return independent instances if the `isSingleton()` implementation returns `false`.

  Specified by:
    `isSingleton` in interface `FactoryBean<org.hibernate.SessionFactory>`
  Returns:
    whether the exposed object is a singleton
  See Also:
    `FactoryBean.getObject()`, `SmartFactoryBean.isPrototype()`

### translateExceptionIfPossible

    public DataAccessException translateExceptionIfPossible(RuntimeException ex)

  Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.

  Converts the exception if it is a HibernateException; else returns `null` to indicate an unknown exception.

  Specified by:
    `translateExceptionIfPossible` in interface `PersistenceExceptionTranslator`
  Parameters:
    `ex` - a RuntimeException thrown
  Returns:
    the corresponding DataAccessException (or `null` if the exception could not be translated, as in this case it may result from user code rather than an actual persistence problem)
  See Also:
    `PersistenceExceptionTranslationPostProcessor`, `convertHibernateAccessException(org.hibernate.HibernateException)`

### convertHibernateAccessException

    protected DataAccessException convertHibernateAccessException(org.hibernate.HibernateException ex)

  Convert the given HibernateException to an appropriate exception from the `org.springframework.dao` hierarchy.

  Will automatically apply a specified SQLExceptionTranslator to a Hibernate JDBCException, else rely on Hibernate's default translation.

  Parameters:
    `ex` - HibernateException that occured
  Returns:
    a corresponding DataAccessException
  See Also:
    `SessionFactoryUtils.convertHibernateAccessException(org.hibernate.HibernateException)`, `setJdbcExceptionTranslator(org.springframework.jdbc.support.SQLExceptionTranslator)`

### buildSessionFactory

    protected abstract org.hibernate.SessionFactory buildSessionFactory()
                                                                 throws Exception

  Build the underlying Hibernate SessionFactory.

  Returns:
    the raw SessionFactory (potentially to be wrapped with a transaction-aware proxy before it is exposed to the application)
  Throws:
    `Exception` - in case of initialization failure

### afterSessionFactoryCreation

    protected void afterSessionFactoryCreation()
                                        throws Exception

  Hook that allows post-processing after the SessionFactory has been successfully created. The SessionFactory is already available through `getSessionFactory()` at this point.

  This implementation is empty.

  Throws:
    `Exception` - in case of initialization failure
  See Also:
    `getSessionFactory()`

### beforeSessionFactoryDestruction

    protected void beforeSessionFactoryDestruction()

  Hook that allows shutdown processing before the SessionFactory will be closed. The SessionFactory is still available through `getSessionFactory()` at this point.

  This implementation is empty.

  See Also:
    `getSessionFactory()`