Configuration (Hibernate Core Aggregator 3.6.10.Final API)

java.lang.Object
- org.hibernate.cfg.Configuration

All Implemented Interfaces:

Serializable

Direct Known Subclasses:

AnnotationConfiguration
```
public class Configuration
extends Object
implements Serializable
```
An instance of Configuration allows the application to specify properties and mapping documents to be used when creating a SessionFactory. Usually an application will create a single Configuration, build a single instance of SessionFactory and then instantiate Sessions in threads servicing client requests. The Configuration is meant only as an initialization-time object. SessionFactorys are immutable and do not retain any association back to the Configuration.

A new Configuration will use the properties specified in hibernate.properties by default.

Author:

Gavin King

See Also:
SessionFactory, Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`Configuration.MappingsImpl` Internal implementation of the Mappings interface giving access to the Configuration's internal `metadata repository` state (`classes`, `tables`, etc).
`protected class`	`Configuration.MetadataSourceQueue`

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`ARTEFACT_PROCESSING_ORDER`
`protected List<AuxiliaryDatabaseObject>`	`auxiliaryDatabaseObjects`
`protected Map<String,PersistentClass>`	`classes`
`protected Map<String,Collection>`	`collections`
`protected Map`	`columnNameBindingPerTable`
`static MetadataSourceType[]`	`DEFAULT_ARTEFACT_PROCESSING_ORDER`
`static String`	`DEFAULT_CACHE_CONCURRENCY_STRATEGY` Setting used to give the name of the default `CacheConcurrencyStrategy` to use when either `@Cacheable` or `@Cache` is used.
`protected Map<ExtendsQueueEntry,?>`	`extendsQueue`
`protected Map<String,FetchProfile>`	`fetchProfiles`
`protected Map<String,FilterDefinition>`	`filterDefinitions`
`protected Map<String,String>`	`imports`
`protected Configuration.MetadataSourceQueue`	`metadataSourceQueue`
`protected Map<String,NamedQueryDefinition>`	`namedQueries`
`protected Map<String,NamedSQLQueryDefinition>`	`namedSqlQueries`
`protected NamingStrategy`	`namingStrategy`
`protected List<Mappings.PropertyReference>`	`propertyReferences`
`protected List<SecondPass>`	`secondPasses`
`protected SettingsFactory`	`settingsFactory`
`protected Map<String,SQLFunction>`	`sqlFunctions`
`protected Map<String,ResultSetMappingDefinition>`	`sqlResultSetMappings`
`protected Map`	`tableNameBinding`
`protected Map<String,Table>`	`tables`
`protected Map<String,TypeDef>`	`typeDefs`
`static String`	`USE_NEW_ID_GENERATOR_MAPPINGS` Setting which indicates whether or not the new `IdentifierGenerator` are used for AUTO, TABLE and SEQUENCE.
`protected XMLHelper`	`xmlHelper`

Constructor Summary

Constructors
Modifier Constructor and Description

Configuration()

protected Configuration(SettingsFactory settingsFactory)

Constructors
Modifier	Constructor and Description
	`Configuration()`
`protected`	`Configuration(SettingsFactory settingsFactory)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`add(XmlDocument metadataXml)`
`Configuration`	`addAnnotatedClass(Class annotatedClass)` Read metadata from the annotations associated with this class.
`void`	`addAuxiliaryDatabaseObject(AuxiliaryDatabaseObject object)`
`Configuration`	`addCacheableFile(File xmlFile)` Add a cached mapping file.
`Configuration`	`addCacheableFile(String xmlFile)` Add a cacheable mapping file.
`Configuration`	`addCacheableFileStrictly(File xmlFile)` INTENDED FOR TESTSUITE USE ONLY! Much like `addCacheableFile(File)` except that here we will fail immediately if the cache version cannot be found or used for whatever reason
`Configuration`	`addClass(Class persistentClass)` Read a mapping as an application resource using the convention that a class named `foo.bar.Foo` is mapped by a file `foo/bar/Foo.hbm.xml` which can be resolved as a classpath resource.
`Configuration`	`addDirectory(File dir)` Read all mapping documents from a directory tree.
`Configuration`	`addDocument(Document doc)` Read mappings from a DOM `Document`
`void`	`addFetchProfile(FetchProfile fetchProfile)`
`Configuration`	`addFile(File xmlFile)` Read mappings from a particular XML file
`Configuration`	`addFile(String xmlFile)` Read mappings from a particular XML file
`void`	`addFilterDefinition(FilterDefinition definition)`
`Configuration`	`addInputStream(InputStream xmlInputStream)` Read mappings from an `InputStream`.
`Configuration`	`addJar(File jar)` Read all mappings from a jar file Assumes that any file named `*.hbm.xml` is a mapping document.
`Configuration`	`addPackage(String packageName)` Read package-level metadata.
`Configuration`	`addProperties(Properties extraProperties)` Add the given properties to ours.
`Configuration`	`addResource(String resourceName)` Read mappings as a application resourceName (i.e.
`Configuration`	`addResource(String resourceName, ClassLoader classLoader)` Read mappings as a application resource (i.e.
`void`	`addSqlFunction(String functionName, SQLFunction function)`
`Configuration`	`addURL(URL url)` Read mappings from a `URL`
`Configuration`	`addXML(String xml)` Read mappings from a `String`
`Mapping`	`buildMapping()`
`void`	`buildMappings()` Call this to ensure the mappings are fully compiled/built.
`SessionFactory`	`buildSessionFactory()` Create a `SessionFactory` using the properties and mappings in this configuration.
`Settings`	`buildSettings()` Create an object-oriented view of the configuration properties
`Settings`	`buildSettings(Properties props)`
`Configuration`	`configure()` Use the mappings and properties specified in an application resource named `hibernate.cfg.xml`.
`Configuration`	`configure(Document document)` Use the mappings and properties specified in the given XML document.
`Configuration`	`configure(File configFile)` Use the mappings and properties specified in the given application file.
`Configuration`	`configure(String resource)` Use the mappings and properties specified in the given application resource.
`Configuration`	`configure(URL url)` Use the mappings and properties specified in the given document.
`Mappings`	`createMappings()` Create a new `Mappings` to add class and collection mappings to.
`protected Configuration`	`doConfigure(org.dom4j.Document doc)` Parse a dom4j document conforming to the Hibernate Configuration DTD (`hibernate-configuration-3.0.dtd`) and use its information to configure this `Configuration`'s state
`protected Configuration`	`doConfigure(InputStream stream, String resourceName)` Configure this configuration's state from the contents of the given input stream.
`protected ExtendsQueueEntry`	`findPossibleExtends()`
`String[]`	`generateDropSchemaScript(Dialect dialect)` Generate DDL for dropping tables
`String[]`	`generateSchemaCreationScript(Dialect dialect)`
`String[]`	`generateSchemaUpdateScript(Dialect dialect, DatabaseMetadata databaseMetadata)`
`PersistentClass`	`getClassMapping(String entityName)` Get the mapping for a particular entity
`Iterator<PersistentClass>`	`getClassMappings()` Iterate the entity mappings
`Collection`	`getCollectionMapping(String role)` Get the mapping for a particular collection role
`Iterator`	`getCollectionMappings()` Iterate the collection mappings
`protected InputStream`	`getConfigurationInputStream(String resource)` Get the configuration file as an `InputStream`.
`EntityNotFoundDelegate`	`getEntityNotFoundDelegate()` Retrieve the user-supplied delegate to handle non-existent entity scenarios.
`EntityResolver`	`getEntityResolver()`
`EntityTuplizerFactory`	`getEntityTuplizerFactory()`
`EventListeners`	`getEventListeners()`
`Map`	`getFilterDefinitions()`
`DefaultIdentifierGeneratorFactory`	`getIdentifierGeneratorFactory()` Retrieve the IdentifierGeneratorFactory in effect for this configuration.
`Map<String,String>`	`getImports()` Get the query language imports
`Interceptor`	`getInterceptor()` Rterieve the configured `Interceptor`.
`Iterator<MappedSuperclass>`	`getMappedSuperclassMappings()` Iterate the mapped super class mappings EXPERIMENTAL Consider this API as PRIVATE
`Map<String,NamedQueryDefinition>`	`getNamedQueries()`
`Map`	`getNamedSQLQueries()`
`NamingStrategy`	`getNamingStrategy()`
`PersisterClassProvider`	`getPersisterClassProvider()`
`Properties`	`getProperties()` Get all properties
`String`	`getProperty(String propertyName)` Get a property value by name
`org.hibernate.annotations.common.reflection.ReflectionManager`	`getReflectionManager()`
`SessionFactoryObserver`	`getSessionFactoryObserver()`
`Map`	`getSqlFunctions()`
`Map`	`getSqlResultSetMappings()`
`Iterator<Table>`	`getTableMappings()` Iterate the table mappings
`TypeResolver`	`getTypeResolver()`
`Iterator`	`iterateFetchProfiles()`
`Configuration`	`mergeProperties(Properties properties)` Adds the incoming properties to the internal properties structure, as long as the internal structure does not already contain an entry for the given key.
`void`	`registerTypeOverride(BasicType type)` Allows registration of a type into the type registry.
`void`	`registerTypeOverride(CompositeUserType type, String[] keys)`
`void`	`registerTypeOverride(UserType type, String[] keys)`
`protected void`	`reset()`
`protected void`	`secondPassCompile()`
`protected void`	`secondPassCompileForeignKeys(Table table, Set done)`
`Configuration`	`setCacheConcurrencyStrategy(String entityName, String concurrencyStrategy)` Set up a cache for an entity class
`Configuration`	`setCacheConcurrencyStrategy(String entityName, String concurrencyStrategy, String region)` Set up a cache for an entity class, giving an explicit region name
`void`	`setCacheConcurrencyStrategy(String entityName, String concurrencyStrategy, String region, boolean cacheLazyProperty)`
`Configuration`	`setCollectionCacheConcurrencyStrategy(String collectionRole, String concurrencyStrategy)` Set up a cache for a collection role
`void`	`setCollectionCacheConcurrencyStrategy(String collectionRole, String concurrencyStrategy, String region)` Set up a cache for a collection role, giving an explicit region name
`void`	`setEntityNotFoundDelegate(EntityNotFoundDelegate entityNotFoundDelegate)` Specify a user-supplied delegate to be used to handle scenarios where an entity could not be located by specified id.
`void`	`setEntityResolver(EntityResolver entityResolver)` Set a custom entity resolver.
`Configuration`	`setInterceptor(Interceptor interceptor)` Set the current `Interceptor`
`void`	`setListener(String type, Object listener)`
`void`	`setListener(String type, String listener)`
`void`	`setListeners(String type, Object[] listeners)`
`void`	`setListeners(String type, String[] listenerClasses)`
`Configuration`	`setNamingStrategy(NamingStrategy namingStrategy)` Set a custom naming strategy
`Configuration`	`setPersisterClassProvider(PersisterClassProvider persisterClassProvider)` Defines a custom persister class provider.
`void`	`setPrecedence(String precedence)`
`Configuration`	`setProperties(Properties properties)` Specify a completely new set of properties
`Configuration`	`setProperty(String propertyName, String value)` Set a property value by name
`void`	`setSessionFactoryObserver(SessionFactoryObserver sessionFactoryObserver)`
`void`	`validateSchema(Dialect dialect, DatabaseMetadata databaseMetadata)`

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

- Field Detail
  - DEFAULT_CACHE_CONCURRENCY_STRATEGY
```
public static final String DEFAULT_CACHE_CONCURRENCY_STRATEGY
```
    Setting used to give the name of the default CacheConcurrencyStrategy to use when either @Cacheable or @Cache is used. @Cache(strategy="..") is used to override.
    
    See Also:
    Constant Field Values
  - USE_NEW_ID_GENERATOR_MAPPINGS
```
public static final String USE_NEW_ID_GENERATOR_MAPPINGS
```
    Setting which indicates whether or not the new IdentifierGenerator are used for AUTO, TABLE and SEQUENCE. Default to false to keep backward compatibility.
    
    See Also:
    Constant Field Values
  - ARTEFACT_PROCESSING_ORDER
```
public static final String ARTEFACT_PROCESSING_ORDER
```
    See Also:
    Constant Field Values
  - metadataSourceQueue
```
protected Configuration.MetadataSourceQueue metadataSourceQueue
```
  - classes
```
protected Map<String,PersistentClass> classes
```
  - imports
```
protected Map<String,String> imports
```
  - collections
```
protected Map<String,Collection> collections
```
  - tables
```
protected Map<String,Table> tables
```
  - auxiliaryDatabaseObjects
```
protected List<AuxiliaryDatabaseObject> auxiliaryDatabaseObjects
```
  - namedQueries
```
protected Map<String,NamedQueryDefinition> namedQueries
```
  - namedSqlQueries
```
protected Map<String,NamedSQLQueryDefinition> namedSqlQueries
```
  - sqlResultSetMappings
```
protected Map<String,ResultSetMappingDefinition> sqlResultSetMappings
```
  - typeDefs
```
protected Map<String,TypeDef> typeDefs
```
  - filterDefinitions
```
protected Map<String,FilterDefinition> filterDefinitions
```
  - fetchProfiles
```
protected Map<String,FetchProfile> fetchProfiles
```
  - tableNameBinding
```
protected Map tableNameBinding
```
  - columnNameBindingPerTable
```
protected Map columnNameBindingPerTable
```
  - secondPasses
```
protected List<SecondPass> secondPasses
```
  - propertyReferences
```
protected List<Mappings.PropertyReference> propertyReferences
```
  - extendsQueue
```
protected Map<ExtendsQueueEntry,?> extendsQueue
```
  - sqlFunctions
```
protected Map<String,SQLFunction> sqlFunctions
```
  - xmlHelper
```
protected transient XMLHelper xmlHelper
```
  - namingStrategy
```
protected NamingStrategy namingStrategy
```
  - settingsFactory
```
protected final SettingsFactory settingsFactory
```
  - DEFAULT_ARTEFACT_PROCESSING_ORDER
```
public static final MetadataSourceType[] DEFAULT_ARTEFACT_PROCESSING_ORDER
```
- Constructor Detail
  - Configuration
```
protected Configuration(SettingsFactory settingsFactory)
```
  - Configuration
```
public Configuration()
```
- Method Detail
  - reset
```
protected void reset()
```
  - getEntityTuplizerFactory
```
public EntityTuplizerFactory getEntityTuplizerFactory()
```
  - getReflectionManager
```
public org.hibernate.annotations.common.reflection.ReflectionManager getReflectionManager()
```
  - getClassMappings
```
public Iterator<PersistentClass> getClassMappings()
```
    Iterate the entity mappings
    
    Returns:
    Iterator of the entity mappings currently contained in the configuration.
  - getCollectionMappings
```
public Iterator getCollectionMappings()
```
    Iterate the collection mappings
    
    Returns:
    Iterator of the collection mappings currently contained in the configuration.
  - getTableMappings
```
public Iterator<Table> getTableMappings()
```
    Iterate the table mappings
    
    Returns:
    Iterator of the table mappings currently contained in the configuration.
  - getMappedSuperclassMappings
```
public Iterator<MappedSuperclass> getMappedSuperclassMappings()
```
    Iterate the mapped super class mappings EXPERIMENTAL Consider this API as PRIVATE
    
    Returns:
    iterator over the MappedSuperclass mapping currently contained in the configuration.
  - getClassMapping
```
public PersistentClass getClassMapping(String entityName)
```
    Get the mapping for a particular entity
    
    Parameters:
    entityName - An entity name.
    
    Returns:
    the entity mapping information
  - getCollectionMapping
```
public Collection getCollectionMapping(String role)
```
    Get the mapping for a particular collection role
    
    Parameters:
    role - a collection role
    
    Returns:
    The collection mapping information
  - setEntityResolver
```
public void setEntityResolver(EntityResolver entityResolver)
```
    Set a custom entity resolver. This entity resolver must be set before addXXX(misc) call. Default value is DTDEntityResolver
    
    Parameters:
    entityResolver - entity resolver to use
  - getEntityResolver
```
public EntityResolver getEntityResolver()
```
  - getEntityNotFoundDelegate
```
public EntityNotFoundDelegate getEntityNotFoundDelegate()
```
    Retrieve the user-supplied delegate to handle non-existent entity scenarios. May be null.
    
    Returns:
    The user-supplied delegate
  - setEntityNotFoundDelegate
```
public void setEntityNotFoundDelegate(EntityNotFoundDelegate entityNotFoundDelegate)
```
    Specify a user-supplied delegate to be used to handle scenarios where an entity could not be located by specified id. This is mainly intended for EJB3 implementations to be able to control how proxy initialization errors should be handled...
    
    Parameters:
    entityNotFoundDelegate - The delegate to use
  - addFile
```
public Configuration addFile(String xmlFile)
                      throws MappingException
```
    Read mappings from a particular XML file
    
    Parameters:
    xmlFile - a path to a file
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates inability to locate or parse the specified mapping file.
    See Also:
    addFile(java.io.File)
  - addFile
```
public Configuration addFile(File xmlFile)
                      throws MappingException
```
    Read mappings from a particular XML file
    
    Parameters:
    xmlFile - a path to a file
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates inability to locate the specified mapping file. Historically this could have indicated a problem parsing the XML document, but that is now delayed until after buildMappings()
  - add
```
public void add(XmlDocument metadataXml)
```
  - addCacheableFile
```
public Configuration addCacheableFile(File xmlFile)
                               throws MappingException
```
    Add a cached mapping file. A cached file is a serialized representation of the DOM structure of a particular mapping. It is saved from a previous call as a file with the name xmlFile + ".bin" where xmlFile is the name of the original mapping file.
    If a cached xmlFile + ".bin" exists and is newer than xmlFile the ".bin" file will be read directly. Otherwise xmlFile is read and then serialized to xmlFile + ".bin" for use the next time.
    
    Parameters:
    xmlFile - The cacheable mapping file to be added.
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems reading the cached file or processing the non-cached file.
  - addCacheableFileStrictly
```
public Configuration addCacheableFileStrictly(File xmlFile)
                                       throws SerializationException,
                                              FileNotFoundException
```
    INTENDED FOR TESTSUITE USE ONLY!
    Much like addCacheableFile(File) except that here we will fail immediately if the cache version cannot be found or used for whatever reason
    
    Parameters:
    xmlFile - The xml file, not the bin!
    
    Returns:
    The dom "deserialized" from the cached file.
    
    Throws:
    
    SerializationException - Indicates a problem deserializing the cached dom tree
    
    FileNotFoundException - Indicates that the cached file was not found or was not usable.
  - addCacheableFile
```
public Configuration addCacheableFile(String xmlFile)
                               throws MappingException
```
    Add a cacheable mapping file.
    
    Parameters:
    xmlFile - The name of the file to be added. This must be in a form useable to simply construct a File instance.
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems reading the cached file or processing the non-cached file.
    See Also:
    addCacheableFile(java.io.File)
  - addXML
```
public Configuration addXML(String xml)
                     throws MappingException
```
    Read mappings from a String
    
    Parameters:
    xml - an XML string
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems parsing the given XML string
  - addURL
```
public Configuration addURL(URL url)
                     throws MappingException
```
    Read mappings from a URL
    
    Parameters:
    url - The url for the mapping document to be read.
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems reading the URL or processing the mapping document.
  - addDocument
```
public Configuration addDocument(Document doc)
                          throws MappingException
```
    Read mappings from a DOM Document
    
    Parameters:
    doc - The DOM document
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems reading the DOM or processing the mapping document.
  - addInputStream
```
public Configuration addInputStream(InputStream xmlInputStream)
                             throws MappingException
```
    Read mappings from an InputStream.
    
    Parameters:
    xmlInputStream - The input stream containing a DOM.
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems reading the stream, or processing the contained mapping document.
  - addResource
```
public Configuration addResource(String resourceName,
                        ClassLoader classLoader)
                          throws MappingException
```
    Read mappings as a application resource (i.e. classpath lookup).
    
    Parameters:
    resourceName - The resource name
    classLoader - The class loader to use.
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems locating the resource or processing the contained mapping document.
  - addResource
```
public Configuration addResource(String resourceName)
                          throws MappingException
```
    Read mappings as a application resourceName (i.e. classpath lookup) trying different class loaders.
    
    Parameters:
    resourceName - The resource name
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems locating the resource or processing the contained mapping document.
  - addClass
```
public Configuration addClass(Class persistentClass)
                       throws MappingException
```
    Read a mapping as an application resource using the convention that a class named foo.bar.Foo is mapped by a file foo/bar/Foo.hbm.xml which can be resolved as a classpath resource.
    
    Parameters:
    persistentClass - The mapped class
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems locating the resource or processing the contained mapping document.
  - addAnnotatedClass
```
public Configuration addAnnotatedClass(Class annotatedClass)
```
    Read metadata from the annotations associated with this class.
    
    Parameters:
    annotatedClass - The class containing annotations
    
    Returns:
    this (for method chaining)
  - addPackage
```
public Configuration addPackage(String packageName)
                         throws MappingException
```
    Read package-level metadata.
    
    Parameters:
    packageName - java package name
    
    Returns:
    this (for method chaining)
    
    Throws:
    
    MappingException - in case there is an error in the mapping data
  - addJar
```
public Configuration addJar(File jar)
                     throws MappingException
```
    Read all mappings from a jar file
    Assumes that any file named *.hbm.xml is a mapping document.
    
    Parameters:
    jar - a jar file
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems reading the jar file or processing the contained mapping documents.
  - addDirectory
```
public Configuration addDirectory(File dir)
                           throws MappingException
```
    Read all mapping documents from a directory tree.
    Assumes that any file named *.hbm.xml is a mapping document.
    
    Parameters:
    dir - The directory
    
    Returns:
    this (for method chaining purposes)
    
    Throws:
    
    MappingException - Indicates problems reading the jar file or processing the contained mapping documents.
  - createMappings
```
public Mappings createMappings()
```
    Create a new Mappings to add class and collection mappings to.
    
    Returns:
    The created mappings
  - generateDropSchemaScript
```
public String[] generateDropSchemaScript(Dialect dialect)
                                  throws HibernateException
```
    Generate DDL for dropping tables
    
    Parameters:
    dialect - The dialect for which to generate the drop script
    
    Returns:
    The sequence of DDL commands to drop the schema objects
    
    Throws:
    
    HibernateException - Generally indicates a problem calling buildMappings()
    See Also:
    SchemaExport
  - generateSchemaCreationScript
```
public String[] generateSchemaCreationScript(Dialect dialect)
                                      throws HibernateException
```
    Parameters:
    dialect - The dialect for which to generate the creation script
    
    Returns:
    The sequence of DDL commands to create the schema objects
    
    Throws:
    
    HibernateException - Generally indicates a problem calling buildMappings()
    See Also:
    SchemaExport
  - generateSchemaUpdateScript
```
public String[] generateSchemaUpdateScript(Dialect dialect,
                                  DatabaseMetadata databaseMetadata)
                                    throws HibernateException
```
    Parameters:
    dialect - The dialect for which to generate the creation script
    databaseMetadata - The database catalog information for the database to be updated; needed to work out what should be created/altered
    
    Returns:
    The sequence of DDL commands to apply the schema objects
    
    Throws:
    
    HibernateException - Generally indicates a problem calling buildMappings()
    See Also:
    SchemaExport
  - validateSchema
```
public void validateSchema(Dialect dialect,
                  DatabaseMetadata databaseMetadata)
                    throws HibernateException
```
    Throws:
    
    HibernateException
  - buildMappings
```
public void buildMappings()
```
    Call this to ensure the mappings are fully compiled/built. Usefull to ensure getting access to all information in the metamodel when calling e.g. getClassMappings().
  - secondPassCompile
```
protected void secondPassCompile()
                          throws MappingException
```
    Throws:
    
    MappingException
  - findPossibleExtends
```
protected ExtendsQueueEntry findPossibleExtends()
```
  - secondPassCompileForeignKeys
```
protected void secondPassCompileForeignKeys(Table table,
                                Set done)
                                     throws MappingException
```
    Throws:
    
    MappingException
  - getNamedQueries
```
public Map<String,NamedQueryDefinition> getNamedQueries()
```
  - buildSessionFactory
```
public SessionFactory buildSessionFactory()
                                   throws HibernateException
```
    Create a SessionFactory using the properties and mappings in this configuration. The SessionFactory will be immutable, so changes made to this Configuration after building the SessionFactory will not affect it.
    
    Returns:
    The build SessionFactory
    
    Throws:
    
    HibernateException - usually indicates an invalid configuration or invalid mapping information
  - getInterceptor
```
public Interceptor getInterceptor()
```
    Rterieve the configured Interceptor.
    
    Returns:
    The current Interceptor
  - setInterceptor
```
public Configuration setInterceptor(Interceptor interceptor)
```
    Set the current Interceptor
    
    Parameters:
    interceptor - The Interceptor to use for the built SessionFactory.
    
    Returns:
    this for method chaining
  - getProperties
```
public Properties getProperties()
```
    Get all properties
    
    Returns:
    all properties
  - getProperty
```
public String getProperty(String propertyName)
```
    Get a property value by name
    
    Parameters:
    propertyName - The name of the property
    
    Returns:
    The value curently associated with that property name; may be null.
  - setProperties
```
public Configuration setProperties(Properties properties)
```
    Specify a completely new set of properties
    
    Parameters:
    properties - The new set of properties
    
    Returns:
    this for method chaining
  - addProperties
```
public Configuration addProperties(Properties extraProperties)
```
    Add the given properties to ours.
    
    Parameters:
    extraProperties - The properties to add.
    
    Returns:
    this for method chaining
  - mergeProperties
```
public Configuration mergeProperties(Properties properties)
```
    Adds the incoming properties to the internal properties structure, as long as the internal structure does not already contain an entry for the given key.
    
    Parameters:
    properties - The properties to merge
    
    Returns:
    this for ethod chaining
  - setProperty
```
public Configuration setProperty(String propertyName,
                        String value)
```
    Set a property value by name
    
    Parameters:
    propertyName - The name of the property to set
    value - The new property value
    
    Returns:
    this for method chaining
  - configure
```
public Configuration configure()
                        throws HibernateException
```
    Use the mappings and properties specified in an application resource named hibernate.cfg.xml.
    
    Returns:
    this for method chaining
    
    Throws:
    
    HibernateException - Generally indicates we cannot find hibernate.cfg.xml
    See Also:
    configure(String)
  - configure
```
public Configuration configure(String resource)
                        throws HibernateException
```
    Use the mappings and properties specified in the given application resource. The format of the resource is defined in hibernate-configuration-3.0.dtd.
    The resource is found via getConfigurationInputStream(java.lang.String)
    
    Parameters:
    resource - The resource to use
    
    Returns:
    this for method chaining
    
    Throws:
    
    HibernateException - Generally indicates we cannot find the named resource
    See Also:
    doConfigure(java.io.InputStream, String)
  - getConfigurationInputStream
```
protected InputStream getConfigurationInputStream(String resource)
                                           throws HibernateException
```
    Get the configuration file as an InputStream. Might be overridden by subclasses to allow the configuration to be located by some arbitrary mechanism.
    By default here we use classpath resource resolution
    
    Parameters:
    resource - The resource to locate
    
    Returns:
    The stream
    
    Throws:
    
    HibernateException - Generally indicates we cannot find the named resource
  - configure
```
public Configuration configure(URL url)
                        throws HibernateException
```
    Use the mappings and properties specified in the given document. The format of the document is defined in hibernate-configuration-3.0.dtd.
    
    Parameters:
    url - URL from which you wish to load the configuration
    
    Returns:
    this for method chaining
    
    Throws:
    
    HibernateException - Generally indicates a problem access the url
    See Also:
    doConfigure(java.io.InputStream, String)
  - configure
```
public Configuration configure(File configFile)
                        throws HibernateException
```
    Use the mappings and properties specified in the given application file. The format of the file is defined in hibernate-configuration-3.0.dtd.
    
    Parameters:
    configFile - File from which you wish to load the configuration
    
    Returns:
    this for method chaining
    
    Throws:
    
    HibernateException - Generally indicates a problem access the file
    See Also:
    doConfigure(java.io.InputStream, String)
  - doConfigure
```
protected Configuration doConfigure(InputStream stream,
                        String resourceName)
                             throws HibernateException
```
    Configure this configuration's state from the contents of the given input stream. The expectation is that the stream contents represent an XML document conforming to the Hibernate Configuration DTD. See doConfigure(Document) for further details.
    
    Parameters:
    stream - The input stream from which to read
    resourceName - The name to use in warning/error messages
    
    Returns:
    this for method chaining
    
    Throws:
    
    HibernateException - Indicates a problem reading the stream contents.
  - configure
```
public Configuration configure(Document document)
                        throws HibernateException
```
    Use the mappings and properties specified in the given XML document. The format of the file is defined in hibernate-configuration-3.0.dtd.
    
    Parameters:
    document - an XML document from which you wish to load the configuration
    
    Returns:
    A configuration configured via the Document
    
    Throws:
    
    HibernateException - if there is problem in accessing the file.
  - doConfigure
```
protected Configuration doConfigure(org.dom4j.Document doc)
                             throws HibernateException
```
    Parse a dom4j document conforming to the Hibernate Configuration DTD (hibernate-configuration-3.0.dtd) and use its information to configure this Configuration's state
    
    Parameters:
    doc - The dom4j document
    
    Returns:
    this for method chaining
    
    Throws:
    
    HibernateException - Indicates a problem performing the configuration task
  - setListener
```
public void setListener(String type,
               String listener)
```
  - setListeners
```
public void setListeners(String type,
                String[] listenerClasses)
```
  - setListener
```
public void setListener(String type,
               Object listener)
```
  - setListeners
```
public void setListeners(String type,
                Object[] listeners)
```
  - getEventListeners
```
public EventListeners getEventListeners()
```
  - setCacheConcurrencyStrategy
```
public Configuration setCacheConcurrencyStrategy(String entityName,
                                        String concurrencyStrategy)
```
    Set up a cache for an entity class
    
    Parameters:
    entityName - The name of the entity to which we shoudl associate these cache settings
    concurrencyStrategy - The cache strategy to use
    
    Returns:
    this for method chaining
  - setCacheConcurrencyStrategy
```
public Configuration setCacheConcurrencyStrategy(String entityName,
                                        String concurrencyStrategy,
                                        String region)
```
    Set up a cache for an entity class, giving an explicit region name
    
    Parameters:
    entityName - The name of the entity to which we should associate these cache settings
    concurrencyStrategy - The cache strategy to use
    region - The name of the cache region to use
    
    Returns:
    this for method chaining
  - setCacheConcurrencyStrategy
```
public void setCacheConcurrencyStrategy(String entityName,
                               String concurrencyStrategy,
                               String region,
                               boolean cacheLazyProperty)
                                 throws MappingException
```
    Throws:
    
    MappingException
  - setCollectionCacheConcurrencyStrategy
```
public Configuration setCollectionCacheConcurrencyStrategy(String collectionRole,
                                                  String concurrencyStrategy)
```
    Set up a cache for a collection role
    
    Parameters:
    collectionRole - The name of the collection to which we should associate these cache settings
    concurrencyStrategy - The cache strategy to use
    
    Returns:
    this for method chaining
  - setCollectionCacheConcurrencyStrategy
```
public void setCollectionCacheConcurrencyStrategy(String collectionRole,
                                         String concurrencyStrategy,
                                         String region)
```
    Set up a cache for a collection role, giving an explicit region name
    
    Parameters:
    collectionRole - The name of the collection to which we should associate these cache settings
    concurrencyStrategy - The cache strategy to use
    region - The name of the cache region to use
  - getImports
```
public Map<String,String> getImports()
```
    Get the query language imports
    
    Returns:
    a mapping from "import" names to fully qualified class names
  - buildSettings
```
public Settings buildSettings()
```
    Create an object-oriented view of the configuration properties
    
    Returns:
    The build settings
  - buildSettings
```
public Settings buildSettings(Properties props)
                       throws HibernateException
```
    Throws:
    
    HibernateException
  - getNamedSQLQueries
```
public Map getNamedSQLQueries()
```
  - getSqlResultSetMappings
```
public Map getSqlResultSetMappings()
```
  - getNamingStrategy
```
public NamingStrategy getNamingStrategy()
```
  - setNamingStrategy
```
public Configuration setNamingStrategy(NamingStrategy namingStrategy)
```
    Set a custom naming strategy
    
    Parameters:
    namingStrategy - the NamingStrategy to set
    
    Returns:
    this for method chaining
  - getPersisterClassProvider
```
public PersisterClassProvider getPersisterClassProvider()
```
  - setPersisterClassProvider
```
public Configuration setPersisterClassProvider(PersisterClassProvider persisterClassProvider)
```
    Defines a custom persister class provider. The persister class is chosen according to the following rules in decreasing priority: - the persister class defined explicitly via annotation or XML - the persister class returned by the PersisterClassProvider implementation (if not null) - the default provider as chosen by Hibernate Core (best choice most of the time)
    
    Parameters:
    persisterClassProvider - implementation
  - getIdentifierGeneratorFactory
```
public DefaultIdentifierGeneratorFactory getIdentifierGeneratorFactory()
```
    Retrieve the IdentifierGeneratorFactory in effect for this configuration.
    
    Returns:
    This configuration's IdentifierGeneratorFactory.
  - buildMapping
```
public Mapping buildMapping()
```
  - getFilterDefinitions
```
public Map getFilterDefinitions()
```
  - addFilterDefinition
```
public void addFilterDefinition(FilterDefinition definition)
```
  - iterateFetchProfiles
```
public Iterator iterateFetchProfiles()
```
  - addFetchProfile
```
public void addFetchProfile(FetchProfile fetchProfile)
```
  - addAuxiliaryDatabaseObject
```
public void addAuxiliaryDatabaseObject(AuxiliaryDatabaseObject object)
```
  - getSqlFunctions
```
public Map getSqlFunctions()
```
  - addSqlFunction
```
public void addSqlFunction(String functionName,
                  SQLFunction function)
```
  - getTypeResolver
```
public TypeResolver getTypeResolver()
```
  - registerTypeOverride
```
public void registerTypeOverride(BasicType type)
```
    Allows registration of a type into the type registry. The phrase 'override' in the method name simply reminds that registration *potentially* replaces a previously registered type .
    
    Parameters:
    type - The type to register.
  - registerTypeOverride
```
public void registerTypeOverride(UserType type,
                        String[] keys)
```
  - registerTypeOverride
```
public void registerTypeOverride(CompositeUserType type,
                        String[] keys)
```
  - getSessionFactoryObserver
```
public SessionFactoryObserver getSessionFactoryObserver()
```
  - setSessionFactoryObserver
```
public void setSessionFactoryObserver(SessionFactoryObserver sessionFactoryObserver)
```
  - setPrecedence
```
public void setPrecedence(String precedence)
```

Class Configuration

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_CACHE_CONCURRENCY_STRATEGY

USE_NEW_ID_GENERATOR_MAPPINGS

ARTEFACT_PROCESSING_ORDER

metadataSourceQueue

classes

imports

collections

tables

auxiliaryDatabaseObjects

namedQueries

namedSqlQueries

sqlResultSetMappings

typeDefs

filterDefinitions

fetchProfiles

tableNameBinding

columnNameBindingPerTable

secondPasses

propertyReferences

extendsQueue

sqlFunctions

xmlHelper

namingStrategy

settingsFactory

DEFAULT_ARTEFACT_PROCESSING_ORDER

Constructor Detail

Configuration

Configuration

Method Detail

reset

getEntityTuplizerFactory

getReflectionManager

getClassMappings

getCollectionMappings

getTableMappings

getMappedSuperclassMappings

getClassMapping

getCollectionMapping

setEntityResolver

getEntityResolver

getEntityNotFoundDelegate

setEntityNotFoundDelegate

addFile

addFile

add

addCacheableFile

addCacheableFileStrictly

addCacheableFile

addXML

addURL

addDocument

addInputStream

addResource

addResource

addClass

addAnnotatedClass

addPackage

addJar

addDirectory

createMappings

generateDropSchemaScript

generateSchemaCreationScript

generateSchemaUpdateScript

validateSchema

buildMappings

secondPassCompile

findPossibleExtends

secondPassCompileForeignKeys

getNamedQueries

buildSessionFactory

getInterceptor

setInterceptor

getProperties