|
The Spring Framework | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.springframework.orm.jpa.AbstractEntityManagerFactoryBean org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
public class LocalContainerEntityManagerFactoryBean
FactoryBean
that creates a JPA
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 PersistenceUnitInfo
object (with further configuration merged in, such as JDBC DataSources and the
Spring LoadTimeWeaver), to be passed to the chosen JPA
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.
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
,
PersistenceProvider.createContainerEntityManagerFactory(javax.persistence.spi.PersistenceUnitInfo, java.util.Map)
Field Summary |
---|
Fields inherited from class org.springframework.orm.jpa.AbstractEntityManagerFactoryBean |
---|
logger, nativeEntityManagerFactory |
Constructor Summary | |
---|---|
LocalContainerEntityManagerFactoryBean()
|
Method Summary | |
---|---|
protected javax.persistence.EntityManagerFactory |
createNativeEntityManagerFactory()
Subclasses must implement this method to create the EntityManagerFactory that will be returned by the getObject() method |
protected javax.persistence.spi.PersistenceUnitInfo |
determinePersistenceUnitInfo(PersistenceUnitManager persistenceUnitManager)
Determine the PersistenceUnitInfo to use for the EntityManagerFactory created by this bean. |
DataSource |
getDataSource()
Return the JDBC DataSource that this EntityManagerFactory obtains its JDBC Connections from. |
javax.persistence.spi.PersistenceUnitInfo |
getPersistenceUnitInfo()
Return the PersistenceUnitInfo used to create this EntityManagerFactory, if the in-container API was used. |
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(javax.persistence.EntityManagerFactory emf,
javax.persistence.spi.PersistenceUnitInfo pui)
Hook method allowing subclasses to customize the EntityManagerFactory after its creation via the PersistenceProvider. |
void |
setBeanClassLoader(ClassLoader beanClassLoader)
Callback that supplies the bean class loader to
a bean instance. |
void |
setDataSource(DataSource dataSource)
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 |
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 |
setPersistenceUnitPostProcessors(PersistenceUnitPostProcessor[] postProcessors)
Set the PersistenceUnitPostProcessors to be applied to the PersistenceUnitInfo used for creating this EntityManagerFactory. |
void |
setPersistenceXmlLocation(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. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
public LocalContainerEntityManagerFactoryBean()
Method Detail |
---|
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(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 setDataSource(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, overriding
data source configuration in persistence.xml
(if any).
NOTE: Only applied if no external PersistenceUnitManager specified.
PersistenceUnitInfo.getNonJtaDataSource()
,
setPersistenceUnitManager(org.springframework.orm.jpa.persistenceunit.PersistenceUnitManager)
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 (for example, interacting with Spring's TomcatInstrumentableClassLoader).
NOTE: Only applied if no external PersistenceUnitManager specified.
public void setPersistenceUnitPostProcessors(PersistenceUnitPostProcessor[] postProcessors)
Such post-processors can, for example, register further entity
classes and jar files, in addition to the metadata read in from
persistence.xml
.
NOTE: Only applied if no external PersistenceUnitManager specified.
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)
public void setBeanClassLoader(ClassLoader beanClassLoader)
BeanClassLoaderAware
class loader
to
a bean instance.
Invoked after the population of normal bean properties but
before an initialization callback such as
InitializingBean's
InitializingBean.afterPropertiesSet()
method or a custom init-method.
setBeanClassLoader
in interface BeanClassLoaderAware
beanClassLoader
- the owning class loader; may be null
in
which case a default ClassLoader
must be used, for example
the ClassLoader
obtained via
ClassUtils.getDefaultClassLoader()
protected javax.persistence.EntityManagerFactory createNativeEntityManagerFactory() throws javax.persistence.PersistenceException
AbstractEntityManagerFactoryBean
createNativeEntityManagerFactory
in class AbstractEntityManagerFactoryBean
javax.persistence.PersistenceException
- if the EntityManager cannot be createdprotected javax.persistence.spi.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 from
protected void postProcessEntityManagerFactory(javax.persistence.EntityManagerFactory emf, javax.persistence.spi.PersistenceUnitInfo pui)
The default implementation is empty.
emf
- the newly created EntityManagerFactory we are working withpui
- the PersistenceUnitInfo used to configure the EntityManagerFactoryPersistenceProvider.createContainerEntityManagerFactory(javax.persistence.spi.PersistenceUnitInfo, java.util.Map)
public javax.persistence.spi.PersistenceUnitInfo getPersistenceUnitInfo()
EntityManagerFactoryInfo
getPersistenceUnitInfo
in interface EntityManagerFactoryInfo
getPersistenceUnitInfo
in class AbstractEntityManagerFactoryBean
null
if the in-container contract was not used to
configure the EntityManagerFactorypublic String getPersistenceUnitName()
EntityManagerFactoryInfo
null
if
it is an unnamed default. If getPersistenceUnitInfo()
returns non-null, the return type of getPersistenceUnitName()
must be equal to the value returned by
PersistenceUnitInfo.getPersistenceUnitName()
.
getPersistenceUnitName
in interface EntityManagerFactoryInfo
getPersistenceUnitName
in class AbstractEntityManagerFactoryBean
EntityManagerFactoryInfo.getPersistenceUnitInfo()
,
PersistenceUnitInfo.getPersistenceUnitName()
public DataSource getDataSource()
EntityManagerFactoryInfo
getDataSource
in interface EntityManagerFactoryInfo
getDataSource
in class AbstractEntityManagerFactoryBean
null
if not known
|
The Spring Framework | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |