public class LocalContainerEntityManagerFactoryBean extends AbstractEntityManagerFactoryBean implements ResourceLoaderAware, LoadTimeWeaverAware
FactoryBean
that creates a JPA
javax.persistence.EntityManagerFactory
according to JPA's standard
container bootstrap contract. This is the most powerful way to set
up a shared JPA EntityManagerFactory in a Spring application context;
the EntityManagerFactory can then be passed to JPA-based DAOs via
dependency injection. Note that switching to a JNDI lookup or to a
LocalEntityManagerFactoryBean
definition is just a matter of
configuration!
As with LocalEntityManagerFactoryBean
, configuration settings
are usually read in from a META-INF/persistence.xml
config file,
residing in the class path, according to the general JPA configuration contract.
However, this FactoryBean is more flexible in that you can override the location
of the persistence.xml
file, specify the JDBC DataSources to link to,
etc. Furthermore, it allows for pluggable class instrumentation through Spring's
LoadTimeWeaver
abstraction,
instead of being tied to a special VM agent specified on JVM startup.
Internally, this FactoryBean parses the persistence.xml
file
itself and creates a corresponding javax.persistence.spi.PersistenceUnitInfo
object (with further configuration merged in, such as JDBC DataSources and the
Spring LoadTimeWeaver), to be passed to the chosen JPA
javax.persistence.spi.PersistenceProvider
. This corresponds to a
local JPA container with full support for the standard JPA container contract.
The exposed EntityManagerFactory object will implement all the interfaces of
the underlying native EntityManagerFactory returned by the PersistenceProvider,
plus the EntityManagerFactoryInfo
interface which exposes additional
metadata as assembled by this FactoryBean.
NOTE: Spring's JPA support requires JPA 2.1 or higher, as of Spring 5.0. JPA 1.0/2.0 based applications are still supported; however, a JPA 2.1 compliant persistence provider is needed at runtime.
setPersistenceXmlLocation(java.lang.String)
,
AbstractEntityManagerFactoryBean.setJpaProperties(java.util.Properties)
,
AbstractEntityManagerFactoryBean.setJpaVendorAdapter(org.springframework.orm.jpa.JpaVendorAdapter)
,
setLoadTimeWeaver(org.springframework.instrument.classloading.LoadTimeWeaver)
,
setDataSource(javax.sql.DataSource)
,
EntityManagerFactoryInfo
,
LocalEntityManagerFactoryBean
,
SharedEntityManagerBean
,
javax.persistence.spi.PersistenceProvider#createContainerEntityManagerFactory
,
Serialized FormModifier and Type | Field and Description |
---|---|
private DefaultPersistenceUnitManager |
internalPersistenceUnitManager |
private PersistenceUnitInfo |
persistenceUnitInfo |
private PersistenceUnitManager |
persistenceUnitManager |
logger
Constructor and Description |
---|
LocalContainerEntityManagerFactoryBean() |
Modifier and Type | Method and Description |
---|---|
protected EntityManagerFactory |
createNativeEntityManagerFactory()
Subclasses must implement this method to create the EntityManagerFactory
that will be returned by the
getObject() method. |
protected PersistenceUnitInfo |
determinePersistenceUnitInfo(PersistenceUnitManager persistenceUnitManager)
Determine the PersistenceUnitInfo to use for the EntityManagerFactory
created by this bean.
|
javax.sql.DataSource |
getDataSource()
Return the JDBC DataSource that this EntityManagerFactory
obtains its JDBC Connections from.
|
PersistenceUnitInfo |
getPersistenceUnitInfo()
Return the PersistenceUnitInfo used to create this
EntityManagerFactory, if the in-container API was used.
|
java.lang.String |
getPersistenceUnitName()
Return the name of the persistence unit used to create this
EntityManagerFactory, or
null if it is an unnamed default. |
protected void |
postProcessEntityManagerFactory(EntityManagerFactory emf,
PersistenceUnitInfo pui)
Hook method allowing subclasses to customize the EntityManagerFactory
after its creation via the PersistenceProvider.
|
void |
setDataSource(javax.sql.DataSource dataSource)
Specify the JDBC DataSource that the JPA persistence provider is supposed
to use for accessing the database.
|
void |
setJtaDataSource(javax.sql.DataSource jtaDataSource)
Specify the JDBC DataSource that the JPA persistence provider is supposed
to use for accessing the database.
|
void |
setLoadTimeWeaver(LoadTimeWeaver loadTimeWeaver)
Specify the Spring LoadTimeWeaver to use for class instrumentation according
to the JPA class transformer contract.
|
void |
setMappingResources(java.lang.String... mappingResources)
Specify one or more mapping resources (equivalent to
<mapping-file>
entries in persistence.xml ) for the default persistence unit. |
void |
setPackagesToScan(java.lang.String... packagesToScan)
Set whether to use Spring-based scanning for entity classes in the classpath
instead of using JPA's standard scanning of jar files with
persistence.xml
markers in them. |
void |
setPersistenceUnitManager(PersistenceUnitManager persistenceUnitManager)
Set the PersistenceUnitManager to use for obtaining the JPA persistence unit
that this FactoryBean is supposed to build an EntityManagerFactory for.
|
void |
setPersistenceUnitName(java.lang.String persistenceUnitName)
Uses the specified persistence unit name as the name of the default
persistence unit, if applicable.
|
void |
setPersistenceUnitPostProcessors(PersistenceUnitPostProcessor... postProcessors)
Set the PersistenceUnitPostProcessors to be applied to the
PersistenceUnitInfo used for creating this EntityManagerFactory.
|
void |
setPersistenceUnitRootLocation(java.lang.String defaultPersistenceUnitRootLocation)
Set a persistence unit root location for the default persistence unit.
|
void |
setPersistenceXmlLocation(java.lang.String persistenceXmlLocation)
Set the location of the
persistence.xml file
we want to use. |
void |
setResourceLoader(ResourceLoader resourceLoader)
Set the ResourceLoader that this object runs in.
|
void |
setSharedCacheMode(SharedCacheMode sharedCacheMode)
Specify the JPA 2.0 shared cache mode for this persistence unit,
overriding a value in
persistence.xml if set. |
void |
setValidationMode(ValidationMode validationMode)
Specify the JPA 2.0 validation mode for this persistence unit,
overriding a value in
persistence.xml if set. |
afterPropertiesSet, createEntityManagerFactoryProxy, destroy, getBeanClassLoader, getBootstrapExecutor, getEntityManagerInterface, getJpaDialect, getJpaPropertyMap, getJpaVendorAdapter, getNativeEntityManagerFactory, getObject, getObjectType, getPersistenceProvider, invokeProxyMethod, isSingleton, setBeanClassLoader, setBeanFactory, setBeanName, setBootstrapExecutor, setEntityManagerFactoryInterface, setEntityManagerInterface, setJpaDialect, setJpaProperties, setJpaPropertyMap, setJpaVendorAdapter, setPersistenceProvider, setPersistenceProviderClass, translateExceptionIfPossible, writeReplace
@Nullable private PersistenceUnitManager persistenceUnitManager
private final DefaultPersistenceUnitManager internalPersistenceUnitManager
@Nullable private PersistenceUnitInfo persistenceUnitInfo
public LocalContainerEntityManagerFactoryBean()
public void setPersistenceUnitManager(PersistenceUnitManager persistenceUnitManager)
The default is to rely on the local settings specified on this FactoryBean, such as "persistenceXmlLocation", "dataSource" and "loadTimeWeaver".
For reuse of existing persistence unit configuration or more advanced forms
of custom persistence unit handling, consider defining a separate
PersistenceUnitManager bean (typically a DefaultPersistenceUnitManager instance)
and linking it in here. persistence.xml
location, DataSource
configuration and LoadTimeWeaver will be defined on that separate
DefaultPersistenceUnitManager bean in such a scenario.
public void setPersistenceXmlLocation(java.lang.String persistenceXmlLocation)
persistence.xml
file
we want to use. This is a Spring resource location.
Default is "classpath:META-INF/persistence.xml".
NOTE: Only applied if no external PersistenceUnitManager specified.
persistenceXmlLocation
- a Spring resource String
identifying the location of the persistence.xml
file
that this LocalContainerEntityManagerFactoryBean should parsesetPersistenceUnitManager(org.springframework.orm.jpa.persistenceunit.PersistenceUnitManager)
public void setPersistenceUnitName(@Nullable java.lang.String persistenceUnitName)
NOTE: Only applied if no external PersistenceUnitManager specified.
public void setPersistenceUnitRootLocation(java.lang.String defaultPersistenceUnitRootLocation)
Default is "classpath:", that is, the root of the current classpath (nearest root directory). To be overridden if unit-specific resolution does not work and the classpath root is not appropriate either.
NOTE: Only applied if no external PersistenceUnitManager specified.
DefaultPersistenceUnitManager.setDefaultPersistenceUnitRootLocation(java.lang.String)
public void setPackagesToScan(java.lang.String... packagesToScan)
persistence.xml
markers in them. In case of Spring-based scanning, no persistence.xml
is necessary; all you need to do is to specify base packages to search here.
Default is none. Specify packages to search for autodetection of your entity
classes in the classpath. This is analogous to Spring's component-scan feature
(ClassPathBeanDefinitionScanner
).
Note: There may be limitations in comparison to regular JPA scanning.
In particular, JPA providers may pick up annotated packages for provider-specific
annotations only when driven by persistence.xml
. As of 4.1, Spring's
scan can detect annotated packages as well if supported by the given
JpaVendorAdapter
(e.g. for Hibernate).
If no explicit mapping resources
have been
specified in addition to these packages, Spring's setup looks for a default
META-INF/orm.xml
file in the classpath, registering it as a mapping
resource for the default unit if the mapping file is not co-located with a
persistence.xml
file (in which case we assume it is only meant to be
used with the persistence units defined there, like in standard JPA).
NOTE: Only applied if no external PersistenceUnitManager specified.
packagesToScan
- one or more base packages to search, analogous to
Spring's component-scan configuration for regular Spring componentssetPersistenceUnitManager(org.springframework.orm.jpa.persistenceunit.PersistenceUnitManager)
,
DefaultPersistenceUnitManager.setPackagesToScan(java.lang.String...)
public void setMappingResources(java.lang.String... mappingResources)
<mapping-file>
entries in persistence.xml
) for the default persistence unit.
Can be used on its own or in combination with entity scanning in the classpath,
in both cases avoiding persistence.xml
.
Note that mapping resources must be relative to the classpath root,
e.g. "META-INF/mappings.xml" or "com/mycompany/repository/mappings.xml",
so that they can be loaded through ClassLoader.getResource
.
If no explicit mapping resources have been specified next to
packages to scan
, Spring's setup looks for a default
META-INF/orm.xml
file in the classpath, registering it as a mapping
resource for the default unit if the mapping file is not co-located with a
persistence.xml
file (in which case we assume it is only meant to be
used with the persistence units defined there, like in standard JPA).
Note that specifying an empty array/list here suppresses the default
META-INF/orm.xml
check. On the other hand, explicitly specifying
META-INF/orm.xml
here will register that file even if it happens
to be co-located with a persistence.xml
file.
NOTE: Only applied if no external PersistenceUnitManager specified.
public void setSharedCacheMode(SharedCacheMode sharedCacheMode)
persistence.xml
if set.
NOTE: Only applied if no external PersistenceUnitManager specified.
javax.persistence.spi.PersistenceUnitInfo#getSharedCacheMode()
,
setPersistenceUnitManager(org.springframework.orm.jpa.persistenceunit.PersistenceUnitManager)
public void setValidationMode(ValidationMode validationMode)
persistence.xml
if set.
NOTE: Only applied if no external PersistenceUnitManager specified.
javax.persistence.spi.PersistenceUnitInfo#getValidationMode()
,
setPersistenceUnitManager(org.springframework.orm.jpa.persistenceunit.PersistenceUnitManager)
public void setDataSource(javax.sql.DataSource dataSource)
persistence.xml
, passing in a Spring-managed
DataSource instead.
In JPA speak, a DataSource passed in here will be used as "nonJtaDataSource"
on the PersistenceUnitInfo passed to the PersistenceProvider, as well as
overriding data source configuration in persistence.xml
(if any).
Note that this variant typically works for JTA transaction management as well;
if it does not, consider using the explicit setJtaDataSource(javax.sql.DataSource)
instead.
NOTE: Only applied if no external PersistenceUnitManager specified.
javax.persistence.spi.PersistenceUnitInfo#getNonJtaDataSource()
,
setPersistenceUnitManager(org.springframework.orm.jpa.persistenceunit.PersistenceUnitManager)
public void setJtaDataSource(javax.sql.DataSource jtaDataSource)
persistence.xml
, passing in a Spring-managed
DataSource instead.
In JPA speak, a DataSource passed in here will be used as "jtaDataSource"
on the PersistenceUnitInfo passed to the PersistenceProvider, as well as
overriding data source configuration in persistence.xml
(if any).
NOTE: Only applied if no external PersistenceUnitManager specified.
javax.persistence.spi.PersistenceUnitInfo#getJtaDataSource()
,
setPersistenceUnitManager(org.springframework.orm.jpa.persistenceunit.PersistenceUnitManager)
public void setPersistenceUnitPostProcessors(PersistenceUnitPostProcessor... postProcessors)
Such post-processors can, for example, register further entity
classes and jar files, in addition to the metadata read from
persistence.xml
.
NOTE: Only applied if no external PersistenceUnitManager specified.
public void setLoadTimeWeaver(LoadTimeWeaver loadTimeWeaver)
It is a not required to specify a LoadTimeWeaver: Most providers will be able to provide a subset of their functionality without class instrumentation as well, or operate with their VM agent specified on JVM startup.
In terms of Spring-provided weaving options, the most important ones are InstrumentationLoadTimeWeaver, which requires a Spring-specific (but very general) VM agent specified on JVM startup, and ReflectiveLoadTimeWeaver, which interacts with an underlying ClassLoader based on specific extended methods being available on it.
NOTE: As of Spring 2.5, the context's default LoadTimeWeaver (defined
as bean with name "loadTimeWeaver") will be picked up automatically, if available,
removing the need for LoadTimeWeaver configuration on each affected target bean.
Consider using the context:load-time-weaver
XML tag for creating
such a shared LoadTimeWeaver (autodetecting the environment by default).
NOTE: Only applied if no external PersistenceUnitManager specified.
Otherwise, the external PersistenceUnitManager
is responsible for the weaving configuration.
setLoadTimeWeaver
in interface LoadTimeWeaverAware
loadTimeWeaver
- the LoadTimeWeaver
instance (never null
)InstrumentationLoadTimeWeaver
,
ReflectiveLoadTimeWeaver
public void setResourceLoader(ResourceLoader resourceLoader)
ResourceLoaderAware
This might be a ResourcePatternResolver, which can be checked
through instanceof ResourcePatternResolver
. See also the
ResourcePatternUtils.getResourcePatternResolver
method.
Invoked after population of normal bean properties but before an init callback
like InitializingBean's afterPropertiesSet
or a custom init-method.
Invoked before ApplicationContextAware's setApplicationContext
.
setResourceLoader
in interface ResourceLoaderAware
resourceLoader
- ResourceLoader object to be used by this objectResourcePatternResolver
,
ResourcePatternUtils.getResourcePatternResolver(org.springframework.core.io.ResourceLoader)
protected EntityManagerFactory createNativeEntityManagerFactory() throws PersistenceException
AbstractEntityManagerFactoryBean
getObject()
method.createNativeEntityManagerFactory
in class AbstractEntityManagerFactoryBean
PersistenceException
- if the EntityManager cannot be createdprotected PersistenceUnitInfo determinePersistenceUnitInfo(PersistenceUnitManager persistenceUnitManager)
The default implementation reads in all persistence unit infos from
persistence.xml
, as defined in the JPA specification.
If no entity manager name was specified, it takes the first info in the
array as returned by the reader. Otherwise, it checks for a matching name.
persistenceUnitManager
- the PersistenceUnitManager to obtain fromprotected void postProcessEntityManagerFactory(EntityManagerFactory emf, PersistenceUnitInfo pui)
The default implementation is empty.
emf
- the newly created EntityManagerFactory we are working withpui
- the PersistenceUnitInfo used to configure the EntityManagerFactoryjavax.persistence.spi.PersistenceProvider#createContainerEntityManagerFactory
@Nullable public PersistenceUnitInfo getPersistenceUnitInfo()
EntityManagerFactoryInfo
getPersistenceUnitInfo
in interface EntityManagerFactoryInfo
getPersistenceUnitInfo
in class AbstractEntityManagerFactoryBean
null
if the in-container contract was not used to
configure the EntityManagerFactory@Nullable public java.lang.String getPersistenceUnitName()
EntityManagerFactoryInfo
null
if it is an unnamed default.
If getPersistenceUnitInfo()
returns non-null, the result of
getPersistenceUnitName()
must be equal to the value returned by
PersistenceUnitInfo.getPersistenceUnitName()
.
getPersistenceUnitName
in interface EntityManagerFactoryInfo
getPersistenceUnitName
in class AbstractEntityManagerFactoryBean
EntityManagerFactoryInfo.getPersistenceUnitInfo()
,
javax.persistence.spi.PersistenceUnitInfo#getPersistenceUnitName()
public javax.sql.DataSource getDataSource()
EntityManagerFactoryInfo
getDataSource
in interface EntityManagerFactoryInfo
getDataSource
in class AbstractEntityManagerFactoryBean
null
if not known