protected  void afterSessionFactoryCreation() throws Exception 
{
		if (this.schemaUpdate) {
			DataSource dataSource = getDataSource();
			if (dataSource != null) {
				// Make given DataSource available for the schema update,
				// which unfortunately reinstantiates a ConnectionProvider.
				configTimeDataSourceHolder.set(dataSource);
			}
			try {
				updateDatabaseSchema();
			}
			finally {
				if (dataSource != null) {
					// Reset DataSource holder.
					configTimeDataSourceHolder.set(null);
				}
			}
		}
}

Executes schema update if requested.

 protected SessionFactory buildSessionFactory() throws Exception 
{
		// Create Configuration instance.
		Configuration config = newConfiguration();
		DataSource dataSource = getDataSource();
		if (dataSource != null) {
			// Make given DataSource available for SessionFactory configuration.
			configTimeDataSourceHolder.set(dataSource);
		}
		if (this.jtaTransactionManager != null) {
			// Make Spring-provided JTA TransactionManager available.
			configTimeTransactionManagerHolder.set(this.jtaTransactionManager);
		}
		if (this.cacheProvider != null) {
			// Make Spring-provided Hibernate CacheProvider available.
			configTimeCacheProviderHolder.set(this.cacheProvider);
		}
		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);
		}
		// Analogous to Hibernate EntityManager's Ejb3Configuration:
		// Hibernate doesn't allow setting the bean ClassLoader explicitly,
		// so we need to expose it as thread context ClassLoader accordingly.
		Thread currentThread = Thread.currentThread();
		ClassLoader threadContextClassLoader = currentThread.getContextClassLoader();
		boolean overrideClassLoader =
				(this.beanClassLoader != null && !this.beanClassLoader.equals(threadContextClassLoader));
		if (overrideClassLoader) {
			currentThread.setContextClassLoader(this.beanClassLoader);
		}
		try {
			if (isExposeTransactionAwareSessionFactory()) {
				// Set Hibernate 3.1 CurrentSessionContext implementation,
				// providing the Spring-managed Session as current Session.
				// Can be overridden by a custom value for the corresponding Hibernate property.
				config.setProperty(
						Environment.CURRENT_SESSION_CONTEXT_CLASS, SpringSessionContext.class.getName());
			}
			if (this.jtaTransactionManager != null) {
				// Set Spring-provided JTA TransactionManager as Hibernate property.
				config.setProperty(
						Environment.TRANSACTION_STRATEGY, JTATransactionFactory.class.getName());
				config.setProperty(
						Environment.TRANSACTION_MANAGER_STRATEGY, LocalTransactionManagerLookup.class.getName());
			}
			else {
				// Makes the Hibernate Session aware of the presence of a Spring-managed transaction.
				// Also sets connection release mode to ON_CLOSE by default.
				config.setProperty(
						Environment.TRANSACTION_STRATEGY, SpringTransactionFactory.class.getName());
			}
			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 (dataSource != null) {
				Class providerClass = LocalDataSourceConnectionProvider.class;
				if (isUseTransactionAwareDataSource() || dataSource instanceof TransactionAwareDataSourceProxy) {
					providerClass = TransactionAwareDataSourceConnectionProvider.class;
				}
				else if (config.getProperty(Environment.TRANSACTION_MANAGER_STRATEGY) != null) {
					providerClass = LocalJtaDataSourceConnectionProvider.class;
				}
				// Set Spring-provided DataSource as Hibernate ConnectionProvider.
				config.setProperty(Environment.CONNECTION_PROVIDER, providerClass.getName());
			}
			if (this.cacheProvider != null) {
				// Expose Spring-provided Hibernate CacheProvider.
				config.setProperty(Environment.CACHE_PROVIDER, LocalCacheProviderProxy.class.getName());
			}
			if (this.mappingResources != null) {
				// Register given Hibernate mapping definitions, contained in resource files.
				for (int i = 0; i <  this.mappingResources.length; i++) {
					Resource resource = new ClassPathResource(this.mappingResources[i].trim(), this.beanClassLoader);
					config.addInputStream(resource.getInputStream());
				}
			}
			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);
				}
			}
			// Tell Hibernate to eagerly compile the mappings that we registered,
			// for availability of the mapping information in further processing.
			postProcessMappings(config);
			config.buildMappings();
			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);
			// Build SessionFactory instance.
			logger.info("Building new Hibernate SessionFactory");
			this.configuration = config;
			return newSessionFactory(config);
		}
		finally {
			if (dataSource != null) {
				// Reset DataSource holder.
				configTimeDataSourceHolder.set(null);
			}
			if (this.jtaTransactionManager != null) {
				// Reset TransactionManager holder.
				configTimeTransactionManagerHolder.set(null);
			}
			if (this.cacheProvider != null) {
				// Reset CacheProvider holder.
				configTimeCacheProviderHolder.set(null);
			}
			if (this.lobHandler != null) {
				// Reset LobHandler holder.
				configTimeLobHandlerHolder.set(null);
			}
			if (overrideClassLoader) {
				// Reset original thread context ClassLoader.
				currentThread.setContextClassLoader(threadContextClassLoader);
			}
		}
}

 public  void createDatabaseSchema() throws DataAccessException 
{
		logger.info("Creating database schema for Hibernate SessionFactory");
		HibernateTemplate hibernateTemplate = new HibernateTemplate(getSessionFactory());
		hibernateTemplate.execute(
			new HibernateCallback() {
				public Object doInHibernate(Session session) throws HibernateException, SQLException {
					Connection con = session.connection();
					Dialect dialect = Dialect.getDialect(getConfiguration().getProperties());
					String[] sql = getConfiguration().generateSchemaCreationScript(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.

 public  void destroy() throws HibernateException 
{
		DataSource dataSource = getDataSource();
		if (dataSource != null) {
			// Make given DataSource available for potential SchemaExport,
			// which unfortunately reinstantiates a ConnectionProvider.
			configTimeDataSourceHolder.set(dataSource);
		}
		try {
			super.destroy();
		}
		finally {
			if (dataSource != null) {
				// Reset DataSource holder.
				configTimeDataSourceHolder.set(null);
			}
		}
}

Allows for schema export on shutdown.

 public  void dropDatabaseSchema() throws DataAccessException 
{
		logger.info("Dropping database schema for Hibernate SessionFactory");
		HibernateTemplate hibernateTemplate = new HibernateTemplate(getSessionFactory());
		hibernateTemplate.execute(
			new HibernateCallback() {
				public Object doInHibernate(Session session) throws HibernateException, SQLException {
					Connection con = session.connection();
					Dialect dialect = Dialect.getDialect(getConfiguration().getProperties());
					String[] sql = getConfiguration().generateDropSchemaScript(dialect);
					executeSchemaScript(con, sql);
					return null;
				}
			}
		);
}

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.

 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 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.

 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);
			}
		}
}

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.

 public static CacheProvider getConfigTimeCacheProvider() 
{
		return (CacheProvider) configTimeCacheProviderHolder.get();
}

Return the CacheProvider for the currently configured Hibernate SessionFactory, to be used by LocalCacheProviderProxy.

This instance will be set before initialization of the corresponding SessionFactory, and reset immediately afterwards. It is thus only available during configuration.

 public static DataSource getConfigTimeDataSource() 
{
	                                        	 
		return (DataSource) configTimeDataSourceHolder.get();
}

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.

 public static LobHandler getConfigTimeLobHandler() 
{
		return (LobHandler) configTimeLobHandlerHolder.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.

 public static TransactionManager getConfigTimeTransactionManager() 
{
		return (TransactionManager) configTimeTransactionManagerHolder.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.

 public final Configuration getConfiguration() 
{
		if (this.configuration == null) {
			throw new IllegalStateException("Configuration not initialized yet");
		}
		return this.configuration;
}

Return the Configuration object used to build the SessionFactory. Allows access to configuration metadata stored there (rarely needed).

 public Properties getHibernateProperties() 
{
		if (this.hibernateProperties == null) {
			this.hibernateProperties = new Properties();
		}
		return this.hibernateProperties;
}

Return the Hibernate properties, if any. Mainly available for configuration through property paths that specify individual keys.

 protected Configuration newConfiguration() throws HibernateException 
{
		return (Configuration) BeanUtils.instantiateClass(this.configurationClass);
}

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.

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

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.

 protected  void postProcessConfiguration(Configuration config) throws HibernateException 
{

}

To be implemented by subclasses that want to to perform custom post-processing of the Configuration object after this FactoryBean performed its default initialization.

Invoked after the Configuration.buildMappings() call, so that it can operate on the completed and fully parsed mapping information.

 protected  void postProcessMappings(Configuration config) throws HibernateException 
{

}

To be implemented by subclasses that want to to register further mappings on the Configuration object after this FactoryBean registered its specified mappings.

Invoked before the Configuration.buildMappings() call, so that it can still extend and modify the mapping information.

 public  void setBeanClassLoader(ClassLoader beanClassLoader) 
{
		this.beanClassLoader = beanClassLoader;
}

 public  void setCacheProvider(CacheProvider cacheProvider) 
{
		this.cacheProvider = cacheProvider;
}

Set the Hibernate CacheProvider to use for the SessionFactory. Allows for using a Spring-managed CacheProvider instance.

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

 public  void setCacheableMappingLocations(Resource[] cacheableMappingLocations) 
{
		this.cacheableMappingLocations = cacheableMappingLocations;
}

Set locations of cacheable Hibernate mapping files, for example as web app resource "/WEB-INF/mapping/example.hbm.xml". Supports any resource location via Spring's resource abstraction, as long as the resource can be resolved in the file system.

Can be used to add to mappings from a Hibernate XML config file, or to specify all mappings locally.

 public  void setCollectionCacheStrategies(Properties collectionCacheStrategies) 
{
		this.collectionCacheStrategies = collectionCacheStrategies;
}

Specify the cache strategies for persistent collections (with specific roles). This configuration setting corresponds to the <collection-cache> entry in the "hibernate.cfg.xml" configuration format.

For example:

<property name="collectionCacheStrategies">
<props>
<prop key="com.mycompany.Order.items">read-write</prop>
<prop key="com.mycompany.Product.categories">read-only,myRegion</prop>
</props>
</property>

Note that appending a cache region name (with a comma separator) is only supported on Hibernate 3.1, where this functionality is publically available.

 public  void setConfigLocation(Resource configLocation) 
{
		this.configLocations = new Resource[] {configLocation};
}

Set the location of a single 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.

 public  void setConfigLocations(Resource[] configLocations) 
{
		this.configLocations = configLocations;
}

Set the locations of multiple Hibernate XML config files, for example as classpath resources "classpath:hibernate.cfg.xml,classpath:extension.cfg.xml".

Note: Can be omitted when all necessary properties and mapping resources are specified locally via this bean.

 public  void setConfigurationClass(Class configurationClass) 
{
	                                                                                   	 
		if (configurationClass == null || !Configuration.class.isAssignableFrom(configurationClass)) {
			throw new IllegalArgumentException(
					"configurationClass must be assignable to [org.hibernate.cfg.Configuration]");
		}
		this.configurationClass = configurationClass;
}

Specify the Hibernate Configuration class to use. Default is "org.hibernate.cfg.Configuration"; any subclass of this default Hibernate Configuration class can be specified.

Can be set to "org.hibernate.cfg.AnnotationConfiguration" for using Hibernate3 annotation support (initially only available as alpha download separate from the main Hibernate3 distribution).

Annotated packages and annotated classes can be specified via the corresponding tags in "hibernate.cfg.xml" then, so this will usually be combined with a "configLocation" property that points at such a standard Hibernate configuration file.

 public  void setEntityCacheStrategies(Properties entityCacheStrategies) 
{
		this.entityCacheStrategies = entityCacheStrategies;
}

Specify the cache strategies for entities (persistent classes or named entities). This configuration setting corresponds to the <class-cache> entry in the "hibernate.cfg.xml" configuration format.

For example:

<property name="entityCacheStrategies">
<props>
<prop key="com.mycompany.Customer">read-write</prop>
<prop key="com.mycompany.Product">read-only,myRegion</prop>
</props>
</property>

Note that appending a cache region name (with a comma separator) is only supported on Hibernate 3.1, where this functionality is publically available.

 public  void setEntityInterceptor(Interceptor entityInterceptor) 
{
		this.entityInterceptor = entityInterceptor;
}

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.

 public  void setEventListeners(Map eventListeners) 
{
		this.eventListeners = eventListeners;
}

Specify the Hibernate event listeners to register, with listener types as keys and listener objects as values.

Instead of a single listener object, you can also pass in a list or set of listeners objects as value. However, this is only supported on Hibernate 3.1.

See the Hibernate documentation for further details on listener types and associated listener interfaces.

 public  void setFilterDefinitions(FilterDefinition[] filterDefinitions) 
{
		this.filterDefinitions = filterDefinitions;
}

Specify the Hibernate FilterDefinitions to register with the SessionFactory. This is an alternative to specifying <<filter-def> elements in Hibernate mapping files.

Typically, the passed-in FilterDefinition objects will have been defined as Spring FilterDefinitionFactoryBeans, probably as inner beans within the LocalSessionFactoryBean definition.

 public  void setHibernateProperties(Properties hibernateProperties) 
{
		this.hibernateProperties = hibernateProperties;
}

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.

 public  void setJtaTransactionManager(TransactionManager jtaTransactionManager) 
{
		this.jtaTransactionManager = jtaTransactionManager;
}

Set the JTA TransactionManager to be used for Hibernate's TransactionManagerLookup. Allows for using 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.

 public  void setLobHandler(LobHandler lobHandler) 
{
		this.lobHandler = lobHandler;
}

Set the LobHandler to be used by the SessionFactory. Will be exposed at config time for UserType implementations.

 public  void setMappingDirectoryLocations(Resource[] mappingDirectoryLocations) 
{
		this.mappingDirectoryLocations = mappingDirectoryLocations;
}

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.

 public  void setMappingJarLocations(Resource[] mappingJarLocations) 
{
		this.mappingJarLocations = mappingJarLocations;
}

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.

 public  void setMappingLocations(Resource[] mappingLocations) 
{
		this.mappingLocations = mappingLocations;
}

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.

 public  void setMappingResources(String[] mappingResources) 
{
		this.mappingResources = mappingResources;
}

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.

 public  void setNamingStrategy(NamingStrategy namingStrategy) 
{
		this.namingStrategy = namingStrategy;
}

Set a Hibernate NamingStrategy for the SessionFactory, determining the physical column and table names given the info in the mapping document.

 public  void setSchemaUpdate(boolean schemaUpdate) 
{
		this.schemaUpdate = schemaUpdate;
}

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 org.hibernate.cfg.Configuration as Hibernate's own SchemaUpdate tool.

 public  void setTypeDefinitions(TypeDefinitionBean[] typeDefinitions) 
{
		this.typeDefinitions = typeDefinitions;
}

Specify the Hibernate type definitions to register with the SessionFactory, as Spring TypeDefinitionBean instances. This is an alternative to specifying <<typedef> elements in Hibernate mapping files.

Unfortunately, Hibernate itself does not define a complete object that represents a type definition, hence the need for Spring's TypeDefinitionBean.

 public  void updateDatabaseSchema() throws DataAccessException 
{
		logger.info("Updating database schema for Hibernate SessionFactory");
		HibernateTemplate hibernateTemplate = new HibernateTemplate(getSessionFactory());
		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(getConfiguration().getProperties());
					DatabaseMetadata metadata = new DatabaseMetadata(con, dialect);
					String[] sql = getConfiguration().generateSchemaUpdateScript(dialect, metadata);
					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.