## org.hibernate.cfg
Class Configuration

    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 `Session`s in threads servicing client requests. The `Configuration` is meant only as an initialization-time object. `SessionFactory`s 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
`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
`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
`` `Configuration()`
`protected` `Configuration(SettingsFactory settingsFactory)`

Method Summary
`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)

Copyright © 2001-2010 Red Hat, Inc. All Rights Reserved.