org.springframework.orm.hibernate.LocalSessionFactoryBean Maven / Gradle / Ivy
/*
* Copyright 2002-2007 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.orm.hibernate;
import java.io.File;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import javax.sql.DataSource;
import javax.transaction.TransactionManager;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Interceptor;
import net.sf.hibernate.Session;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.cfg.Configuration;
import net.sf.hibernate.cfg.Environment;
import net.sf.hibernate.cfg.NamingStrategy;
import net.sf.hibernate.dialect.Dialect;
import net.sf.hibernate.tool.hbm2ddl.DatabaseMetadata;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.support.JdbcUtils;
import org.springframework.jdbc.support.lob.LobHandler;
/**
* {@link org.springframework.beans.factory.FactoryBean} that creates a
* Hibernate {@link net.sf.hibernate.SessionFactory}. This is the usual way to
* set up a shared Hibernate SessionFactory in a Spring application context;
* the SessionFactory can then be passed to Hibernate-based DAOs via
* dependency injection.
*
* Configuration settings can either be read from a Hibernate XML file,
* specified as "configLocation", or completely via this class. A typical
* local configuration consists of one or more "mappingResources", various
* "hibernateProperties" (not strictly necessary), and a "dataSource" that the
* SessionFactory should use. The latter can also be specified via Hibernate
* properties, but "dataSource" supports any Spring-configured DataSource,
* instead of relying on Hibernate's own connection providers.
*
*
This SessionFactory handling strategy is appropriate for most types of
* applications, from Hibernate-only single database apps to ones that need
* distributed transactions. Either {@link HibernateTransactionManager} or
* {@link org.springframework.transaction.jta.JtaTransactionManager} can be
* used for transaction demarcation, with the latter only necessary for
* transactions which span multiple databases.
*
*
Note: Spring's Hibernate support in this package requires Hibernate 2.1.
* Dedicated Hibernate3 support can be found in a separate package:
* org.springframework.orm.hibernate3.
*
* @author Juergen Hoeller
* @since 05.05.2003
* @see HibernateTemplate#setSessionFactory
* @see HibernateTransactionManager#setSessionFactory
*/
public class LocalSessionFactoryBean implements FactoryBean, InitializingBean, DisposableBean {
private static final ThreadLocal configTimeDataSourceHolder = new ThreadLocal();
private static final ThreadLocal configTimeTransactionManagerHolder = new ThreadLocal();
private static final ThreadLocal configTimeLobHandlerHolder = new ThreadLocal();
/**
* Return the DataSource for the currently configured Hibernate SessionFactory,
* to be used by LocalDataSourceConnectionProvoder.
*
This instance will be set before initialization of the corresponding
* SessionFactory, and reset immediately afterwards. It is thus only available
* during configuration.
* @see #setDataSource
* @see LocalDataSourceConnectionProvider
*/
public static DataSource getConfigTimeDataSource() {
return (DataSource) configTimeDataSourceHolder.get();
}
/**
* Return the JTA TransactionManager for the currently configured Hibernate
* SessionFactory, to be used by LocalTransactionManagerLookup.
*
This instance will be set before initialization of the corresponding
* SessionFactory, and reset immediately afterwards. It is thus only available
* during configuration.
* @see #setJtaTransactionManager
* @see LocalTransactionManagerLookup
*/
public static TransactionManager getConfigTimeTransactionManager() {
return (TransactionManager) configTimeTransactionManagerHolder.get();
}
/**
* Return the LobHandler for the currently configured Hibernate SessionFactory,
* to be used by UserType implementations like ClobStringType.
*
This instance will be set before initialization of the corresponding
* SessionFactory, and reset immediately afterwards. It is thus only available
* during configuration.
* @see #setLobHandler
* @see org.springframework.orm.hibernate.support.ClobStringType
* @see org.springframework.orm.hibernate.support.BlobByteArrayType
* @see org.springframework.orm.hibernate.support.BlobSerializableType
*/
public static LobHandler getConfigTimeLobHandler() {
return (LobHandler) configTimeLobHandlerHolder.get();
}
protected final Log logger = LogFactory.getLog(getClass());
private Resource configLocation;
private Resource[] mappingLocations;
private Resource[] mappingJarLocations;
private Resource[] mappingDirectoryLocations;
private Properties hibernateProperties;
private DataSource dataSource;
private boolean useTransactionAwareDataSource = false;
private TransactionManager jtaTransactionManager;
private LobHandler lobHandler;
private Interceptor entityInterceptor;
private NamingStrategy namingStrategy;
private boolean schemaUpdate = false;
private Configuration configuration;
private SessionFactory sessionFactory;
/**
* Set the location of the Hibernate XML config file, for example as
* classpath resource "classpath:hibernate.cfg.xml".
*
Note: Can be omitted when all necessary properties and mapping
* resources are specified locally via this bean.
* @see net.sf.hibernate.cfg.Configuration#configure(java.net.URL)
*/
public void setConfigLocation(Resource configLocation) {
this.configLocation = configLocation;
}
/**
* Set Hibernate mapping resources to be found in the class path,
* like "example.hbm.xml" or "mypackage/example.hbm.xml".
* Analogous to mapping entries in a Hibernate XML config file.
* Alternative to the more generic setMappingLocations method.
*
Can be used to add to mappings from a Hibernate XML config file,
* or to specify all mappings locally.
* @see #setMappingLocations
* @see net.sf.hibernate.cfg.Configuration#addResource
*/
public void setMappingResources(String[] mappingResources) {
this.mappingLocations = new Resource[mappingResources.length];
for (int i = 0; i < mappingResources.length; i++) {
this.mappingLocations[i] = new ClassPathResource(mappingResources[i].trim());
}
}
/**
* Set locations of Hibernate mapping files, for example as classpath
* resource "classpath:example.hbm.xml". Supports any resource location
* via Spring's resource abstraction, for example relative paths like
* "WEB-INF/mappings/example.hbm.xml" when running in an application context.
*
Can be used to add to mappings from a Hibernate XML config file,
* or to specify all mappings locally.
* @see net.sf.hibernate.cfg.Configuration#addInputStream
*/
public void setMappingLocations(Resource[] mappingLocations) {
this.mappingLocations = mappingLocations;
}
/**
* Set locations of jar files that contain Hibernate mapping resources,
* like "WEB-INF/lib/example.hbm.jar".
*
Can be used to add to mappings from a Hibernate XML config file,
* or to specify all mappings locally.
* @see net.sf.hibernate.cfg.Configuration#addJar(java.io.File)
*/
public void setMappingJarLocations(Resource[] mappingJarLocations) {
this.mappingJarLocations = mappingJarLocations;
}
/**
* Set locations of directories that contain Hibernate mapping resources,
* like "WEB-INF/mappings".
*
Can be used to add to mappings from a Hibernate XML config file,
* or to specify all mappings locally.
* @see net.sf.hibernate.cfg.Configuration#addDirectory(java.io.File)
*/
public void setMappingDirectoryLocations(Resource[] mappingDirectoryLocations) {
this.mappingDirectoryLocations = mappingDirectoryLocations;
}
/**
* Set Hibernate properties, such as "hibernate.dialect".
*
Can be used to override values in a Hibernate XML config file,
* or to specify all necessary properties locally.
*
Note: Do not specify a transaction provider here when using
* Spring-driven transactions. It is also advisable to omit connection
* provider settings and use a Spring-set DataSource instead.
* @see #setDataSource
*/
public void setHibernateProperties(Properties hibernateProperties) {
this.hibernateProperties = hibernateProperties;
}
/**
* Return the Hibernate properties, if any. Mainly available for
* configuration through property paths that specify individual keys.
*/
public Properties getHibernateProperties() {
if (this.hibernateProperties == null) {
this.hibernateProperties = new Properties();
}
return this.hibernateProperties;
}
/**
* Set the DataSource to be used by the SessionFactory.
* If set, this will override corresponding settings in Hibernate properties.
*
Note: 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 #setUseTransactionAwareDataSource
* @see LocalDataSourceConnectionProvider
* @see HibernateTransactionManager
* @see org.springframework.transaction.jta.JtaTransactionManager
* @see org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy
*/
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
/**
* 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.
*
As a further effect, using a transaction-aware DataSource will apply
* remaining transaction timeouts to all created JDBC Statements. This means
* that all operations performed by the SessionFactory will automatically
* participate in Spring-managed transaction timeouts, not just queries.
* This adds value even for HibernateTransactionManager.
*
WARNING: Be aware of side effects when using a transaction-aware
* DataSource in combination with OpenSessionInViewFilter/Interceptor.
* This combination is only properly supported with HibernateTransactionManager
* transactions. PROPAGATION_SUPPORTS with HibernateTransactionManager and
* JtaTransactionManager in general are only supported on Hibernate3, which
* introduces (optional) aggressive release of Connections.
* @see #setDataSource
* @see org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy
* @see org.springframework.jdbc.datasource.DataSourceTransactionManager
* @see org.springframework.orm.hibernate.support.OpenSessionInViewFilter
* @see org.springframework.orm.hibernate.support.OpenSessionInViewInterceptor
* @see HibernateTransactionManager
* @see org.springframework.transaction.jta.JtaTransactionManager
* @see org.springframework.orm.hibernate3.LocalSessionFactoryBean#setUseTransactionAwareDataSource
*/
public void setUseTransactionAwareDataSource(boolean useTransactionAwareDataSource) {
this.useTransactionAwareDataSource = useTransactionAwareDataSource;
}
/**
* Set the JTA TransactionManager to be used for Hibernate's
* TransactionManagerLookup. If set, this will override corresponding
* settings in Hibernate properties. Allows to use a Spring-managed
* JTA TransactionManager for Hibernate's cache synchronization.
*
Note: If this is set, the Hibernate settings should not define a
* transaction manager lookup to avoid meaningless double configuration.
* @see LocalTransactionManagerLookup
*/
public void setJtaTransactionManager(TransactionManager jtaTransactionManager) {
this.jtaTransactionManager = jtaTransactionManager;
}
/**
* Set the LobHandler to be used by the SessionFactory.
* Will be exposed at config time for UserType implementations.
* @see #getConfigTimeLobHandler
* @see net.sf.hibernate.UserType
* @see org.springframework.orm.hibernate.support.ClobStringType
* @see org.springframework.orm.hibernate.support.BlobByteArrayType
* @see org.springframework.orm.hibernate.support.BlobSerializableType
*/
public void setLobHandler(LobHandler lobHandler) {
this.lobHandler = lobHandler;
}
/**
* Set a Hibernate entity interceptor that allows to inspect and change
* property values before writing to and reading from the database.
* Will get applied to any new Session created by this factory.
*
Such an interceptor can either be set at the SessionFactory level, i.e. on
* LocalSessionFactoryBean, or at the Session level, i.e. on HibernateTemplate,
* HibernateInterceptor, and HibernateTransactionManager. It's preferable to set
* it on LocalSessionFactoryBean or HibernateTransactionManager to avoid repeated
* configuration and guarantee consistent behavior in transactions.
* @see HibernateTemplate#setEntityInterceptor
* @see HibernateInterceptor#setEntityInterceptor
* @see HibernateTransactionManager#setEntityInterceptor
* @see net.sf.hibernate.cfg.Configuration#setInterceptor
*/
public void setEntityInterceptor(Interceptor entityInterceptor) {
this.entityInterceptor = entityInterceptor;
}
/**
* Set a Hibernate NamingStrategy for the SessionFactory, determining the
* physical column and table names given the info in the mapping document.
* @see net.sf.hibernate.cfg.Configuration#setNamingStrategy
*/
public void setNamingStrategy(NamingStrategy namingStrategy) {
this.namingStrategy = namingStrategy;
}
/**
* Set whether to execute a schema update after SessionFactory initialization.
*
For details on how to make schema update scripts work, see the Hibernate
* documentation, as this class leverages the same schema update script support
* in net.sf.hibernate.cfg.Configuration as Hibernate's own SchemaUpdate tool.
* @see net.sf.hibernate.cfg.Configuration#generateSchemaUpdateScript
* @see net.sf.hibernate.tool.hbm2ddl.SchemaUpdate
*/
public void setSchemaUpdate(boolean schemaUpdate) {
this.schemaUpdate = schemaUpdate;
}
/**
* Initialize the SessionFactory for the given or the default location.
* @throws IllegalArgumentException in case of illegal property values
* @throws HibernateException in case of Hibernate initialization errors
*/
public void afterPropertiesSet() throws IllegalArgumentException, HibernateException, IOException {
// Create Configuration instance.
Configuration config = newConfiguration();
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);
}
try {
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.configLocation != null) {
// Load Hibernate configuration from given location.
config.configure(this.configLocation.getURL());
}
if (this.hibernateProperties != null) {
// Add given Hibernate properties to Configuration.
config.addProperties(this.hibernateProperties);
}
if (this.dataSource != null) {
// Set Spring-provided DataSource as Hibernate property.
config.setProperty(Environment.CONNECTION_PROVIDER,
this.useTransactionAwareDataSource ?
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.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);
}
}
// Perform custom post-processing in subclasses.
postProcessConfiguration(config);
// Build SessionFactory instance.
logger.info("Building new Hibernate SessionFactory");
this.configuration = config;
this.sessionFactory = 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();
}
}
/**
* Subclasses can override this method to perform custom initialization
* of the Configuration instance used for SessionFactory creation.
* The properties of this LocalSessionFactoryBean will be applied to
* the Configuration object that gets returned here.
*
The default implementation creates a new Configuration instance.
* A custom implementation could prepare the instance in a specific way,
* or use a custom Configuration subclass.
* @return the Configuration instance
* @throws HibernateException in case of Hibernate initialization errors
* @see net.sf.hibernate.cfg.Configuration#Configuration()
*/
protected Configuration newConfiguration() throws HibernateException {
return new Configuration();
}
/**
* To be implemented by subclasses that want to to perform custom
* post-processing of the Configuration object after this FactoryBean
* performed its default initialization.
* @param config the current Configuration object
* @throws HibernateException in case of Hibernate initialization errors
*/
protected void postProcessConfiguration(Configuration config) throws HibernateException {
}
/**
* Subclasses can override this method to perform custom initialization
* of the SessionFactory instance, creating it via the given Configuration
* object that got prepared by this LocalSessionFactoryBean.
*
The default implementation invokes Configuration's buildSessionFactory.
* A custom implementation could prepare the instance in a specific way,
* or use a custom SessionFactoryImpl subclass.
* @param config Configuration prepared by this LocalSessionFactoryBean
* @return the SessionFactory instance
* @throws HibernateException in case of Hibernate initialization errors
* @see net.sf.hibernate.cfg.Configuration#buildSessionFactory
*/
protected SessionFactory newSessionFactory(Configuration config) throws HibernateException {
return config.buildSessionFactory();
}
/**
* Execute schema drop script, determined by the Configuration object
* used for creating the SessionFactory. A replacement for Hibernate's
* SchemaExport class, to be invoked on application setup.
*
Fetch the LocalSessionFactoryBean itself rather than the exposed
* SessionFactory to be able to invoke this method, e.g. via
* LocalSessionFactoryBean lsfb = (LocalSessionFactoryBean) ctx.getBean("&mySessionFactory");.
*
Uses the SessionFactory that this bean generates for accessing a JDBC
* connection to perform the script.
* @throws DataAccessException in case of script execution errors
* @see net.sf.hibernate.cfg.Configuration#generateDropSchemaScript
* @see net.sf.hibernate.tool.hbm2ddl.SchemaExport#drop
*/
public void dropDatabaseSchema() throws DataAccessException {
logger.info("Dropping database schema for Hibernate SessionFactory");
HibernateTemplate hibernateTemplate = new HibernateTemplate(this.sessionFactory);
hibernateTemplate.execute(
new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Connection con = session.connection();
Dialect dialect = Dialect.getDialect(configuration.getProperties());
String[] sql = configuration.generateDropSchemaScript(dialect);
executeSchemaScript(con, sql);
return null;
}
}
);
}
/**
* Execute schema creation script, determined by the Configuration object
* used for creating the SessionFactory. A replacement for Hibernate's
* SchemaExport class, to be invoked on application setup.
*
Fetch the LocalSessionFactoryBean itself rather than the exposed
* SessionFactory to be able to invoke this method, e.g. via
* LocalSessionFactoryBean lsfb = (LocalSessionFactoryBean) ctx.getBean("&mySessionFactory");.
*
Uses the SessionFactory that this bean generates for accessing a JDBC
* connection to perform the script.
* @throws DataAccessException in case of script execution errors
* @see net.sf.hibernate.cfg.Configuration#generateSchemaCreationScript
* @see net.sf.hibernate.tool.hbm2ddl.SchemaExport#create
*/
public void createDatabaseSchema() throws DataAccessException {
logger.info("Creating database schema for Hibernate SessionFactory");
HibernateTemplate hibernateTemplate = new HibernateTemplate(this.sessionFactory);
hibernateTemplate.execute(
new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Connection con = session.connection();
Dialect dialect = Dialect.getDialect(configuration.getProperties());
String[] sql = configuration.generateSchemaCreationScript(dialect);
executeSchemaScript(con, sql);
return null;
}
}
);
}
/**
* Execute schema update script, determined by the Configuration object
* used for creating the SessionFactory. A replacement for Hibernate's
* SchemaUpdate class, for automatically executing schema update scripts
* on application startup. Can also be invoked manually.
*
Fetch the LocalSessionFactoryBean itself rather than the exposed
* SessionFactory to be able to invoke this method, e.g. via
* LocalSessionFactoryBean lsfb = (LocalSessionFactoryBean) ctx.getBean("&mySessionFactory");.
*
Uses the SessionFactory that this bean generates for accessing a JDBC
* connection to perform the script.
* @throws DataAccessException in case of script execution errors
* @see #setSchemaUpdate
* @see net.sf.hibernate.cfg.Configuration#generateSchemaUpdateScript
* @see net.sf.hibernate.tool.hbm2ddl.SchemaUpdate
*/
public void updateDatabaseSchema() throws DataAccessException {
logger.info("Updating database schema for Hibernate SessionFactory");
HibernateTemplate hibernateTemplate = new HibernateTemplate(this.sessionFactory);
hibernateTemplate.setFlushMode(HibernateTemplate.FLUSH_NEVER);
hibernateTemplate.execute(
new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Connection con = session.connection();
Dialect dialect = Dialect.getDialect(configuration.getProperties());
DatabaseMetadata metadata = new DatabaseMetadata(con, dialect);
String[] sql = configuration.generateSchemaUpdateScript(dialect, metadata);
executeSchemaScript(con, sql);
return null;
}
}
);
}
/**
* Execute the given schema script on the given JDBC Connection.
*
Note that the default implementation will log unsuccessful statements
* and continue to execute. Override the executeSchemaStatement
* method to treat failures differently.
* @param con the JDBC Connection to execute the script on
* @param sql the SQL statements to execute
* @throws SQLException if thrown by JDBC methods
* @see #executeSchemaStatement
*/
protected void executeSchemaScript(Connection con, String[] sql) throws SQLException {
if (sql != null && sql.length > 0) {
boolean oldAutoCommit = con.getAutoCommit();
if (!oldAutoCommit) {
con.setAutoCommit(true);
}
try {
Statement stmt = con.createStatement();
try {
for (int i = 0; i < sql.length; i++) {
executeSchemaStatement(stmt, sql[i]);
}
}
finally {
JdbcUtils.closeStatement(stmt);
}
}
finally {
if (!oldAutoCommit) {
con.setAutoCommit(false);
}
}
}
}
/**
* Execute the given schema SQL on the given JDBC Statement.
*
Note that the default implementation will log unsuccessful statements
* and continue to execute. Override this method to treat failures differently.
* @param stmt the JDBC Statement to execute the SQL on
* @param sql the SQL statement to execute
* @throws SQLException if thrown by JDBC methods (and considered fatal)
*/
protected void executeSchemaStatement(Statement stmt, String sql) throws SQLException {
if (logger.isDebugEnabled()) {
logger.debug("Executing schema statement: " + sql);
}
try {
stmt.executeUpdate(sql);
}
catch (SQLException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Unsuccessful schema statement: " + sql, ex);
}
}
}
/**
* Return the Configuration object used to build the SessionFactory.
* Allows access to configuration metadata stored there (rarely needed).
*/
public Configuration getConfiguration() {
return configuration;
}
/**
* Return the singleton SessionFactory.
*/
public Object getObject() {
return this.sessionFactory;
}
public Class getObjectType() {
return (this.sessionFactory != null) ? this.sessionFactory.getClass() : SessionFactory.class;
}
public boolean isSingleton() {
return true;
}
/**
* Close the SessionFactory on bean factory shutdown.
*/
public void destroy() throws HibernateException {
logger.info("Closing Hibernate SessionFactory");
if (this.dataSource != null) {
// Make given DataSource available for potential SchemaExport,
// which unfortunately reinstantiates a ConnectionProvider.
configTimeDataSourceHolder.set(this.dataSource);
}
try {
this.sessionFactory.close();
}
finally {
if (this.dataSource != null) {
// Reset DataSource holder.
configTimeDataSourceHolder.set(null);
}
}
}
}