Package org.springframework.orm.jpa

# Class AbstractEntityManagerFactoryBean

java.lang.Object
org.springframework.orm.jpa.AbstractEntityManagerFactoryBean

All Implemented Interfaces:
  `Serializable`, `org.springframework.beans.factory.Aware`, `org.springframework.beans.factory.BeanClassLoaderAware`, `org.springframework.beans.factory.BeanFactoryAware`, `org.springframework.beans.factory.BeanNameAware`, `org.springframework.beans.factory.DisposableBean`, `org.springframework.beans.factory.FactoryBean<EntityManagerFactory>`, `org.springframework.beans.factory.InitializingBean`, `org.springframework.beans.factory.SmartInitializingSingleton`, `org.springframework.dao.support.PersistenceExceptionTranslator`, `EntityManagerFactoryInfo`

Direct Known Subclasses:
  `LocalContainerEntityManagerFactoryBean`, `LocalEntityManagerFactoryBean`

public abstract class AbstractEntityManagerFactoryBean extends Object implements org.springframework.beans.factory.FactoryBean<EntityManagerFactory>, org.springframework.beans.factory.BeanClassLoaderAware, org.springframework.beans.factory.BeanFactoryAware, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.InitializingBean, org.springframework.beans.factory.SmartInitializingSingleton, org.springframework.beans.factory.DisposableBean, EntityManagerFactoryInfo, org.springframework.dao.support.PersistenceExceptionTranslator, Serializable
Abstract `FactoryBean` that creates a local JPA `EntityManagerFactory` instance within a Spring application context.

Encapsulates the common functionality between the different JPA bootstrap contracts: standalone as well as container.

Implements support for standard JPA configuration conventions as well as Spring's customizable `JpaVendorAdapter` mechanism, and controls the EntityManagerFactory's lifecycle.

This class also implements the `PersistenceExceptionTranslator` interface, as autodetected by Spring's `PersistenceExceptionTranslationPostProcessor`, for AOP-based translation of native exceptions to Spring DataAccessExceptions. Hence, the presence of, for example, LocalEntityManagerFactoryBean automatically enables a PersistenceExceptionTranslationPostProcessor to translate JPA exceptions.

Since:
  2.0
Author:
  Juergen Hoeller, Rod Johnson
See Also:
  - `LocalEntityManagerFactoryBean`
  - `LocalContainerEntityManagerFactoryBean`
  - Serialized Form

## Field Summary

Fields
Modifier and Type
Field
Description
`protected final org.apache.commons.logging.Log`
`logger`
Logger available to subclasses.

### Fields inherited from interface org.springframework.beans.factory.FactoryBean

`OBJECT_TYPE_ATTRIBUTE`

## Constructor Summary

Constructors
Constructor
Description
`AbstractEntityManagerFactoryBean()`

## Method Summary

Modifier and Type
Method
Description
`void`
`afterPropertiesSet()`
`void`
`afterSingletonsInstantiated()`
`protected EntityManagerFactory`
`createEntityManagerFactoryProxy(EntityManagerFactory emf)`
Create a proxy for the given `EntityManagerFactory`.
`EntityManager`
`createNativeEntityManager(Map<?,?> properties)`
Create a native JPA EntityManager to be used as the framework-managed resource behind an application-level EntityManager handle.
`protected abstract EntityManagerFactory`
`createNativeEntityManagerFactory()`
Subclasses must implement this method to create the EntityManagerFactory that will be returned by the `getObject()` method.
`void`
`destroy()`
Close the EntityManagerFactory on bean factory shutdown.
`ClassLoader`
`getBeanClassLoader()`
Return the ClassLoader that the application's beans are loaded with.
`org.springframework.core.task.AsyncTaskExecutor`
`getBootstrapExecutor()`
Return the asynchronous executor for background bootstrapping, if any.
`DataSource`
`getDataSource()`
Return the JDBC DataSource that this EntityManagerFactory obtains its JDBC Connections from.
`Class<? extends EntityManager>`
`getEntityManagerInterface()`
Return the (potentially vendor-specific) EntityManager interface that this factory's EntityManagers will implement.
`JpaDialect`
`getJpaDialect()`
Return the vendor-specific JpaDialect implementation for this EntityManagerFactory, or `null` if not known.
`Map<String,Object>`
`getJpaPropertyMap()`
Allow `Map` access to the JPA properties to be passed to the persistence provider, with the option to add or override specific entries.
`JpaVendorAdapter`
`getJpaVendorAdapter()`
Return the JpaVendorAdapter implementation for this EntityManagerFactory, or `null` if not known.
`EntityManagerFactory`
`getNativeEntityManagerFactory()`
Return the raw underlying EntityManagerFactory.
`EntityManagerFactory`
`getObject()`
Return the singleton EntityManagerFactory.
`Class<? extends EntityManagerFactory>`
`getObjectType()`
`PersistenceProvider`
`getPersistenceProvider()`
Return the underlying PersistenceProvider that the underlying EntityManagerFactory was created with.
`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.
`boolean`
`isSingleton()`
`protected void`
`postProcessEntityManager(EntityManager rawEntityManager)`
Optional callback for post-processing the native EntityManager before active use.
`void`
`setBeanClassLoader(ClassLoader classLoader)`
`void`
`setBeanFactory(org.springframework.beans.factory.BeanFactory beanFactory)`
`void`
`setBeanName(String name)`
`void`
`setBootstrapExecutor(org.springframework.core.task.AsyncTaskExecutor bootstrapExecutor)`
Specify an asynchronous executor for background bootstrapping, for example, a `SimpleAsyncTaskExecutor`.
`void`
`setEntityManagerFactoryInterface(Class<? extends EntityManagerFactory> emfInterface)`
Specify the (potentially vendor-specific) EntityManagerFactory interface that this EntityManagerFactory proxy is supposed to implement.
`void`
`setEntityManagerInitializer(Consumer<EntityManager> entityManagerInitializer)`
Specify a callback for customizing every `EntityManager` created by the exposed `EntityManagerFactory`.
`void`
`setEntityManagerInterface(Class<? extends EntityManager> emInterface)`
Specify the (potentially vendor-specific) EntityManager interface that this factory's EntityManagers are supposed to implement.
`void`
`setJpaDialect(JpaDialect jpaDialect)`
Specify the vendor-specific JpaDialect implementation to associate with this EntityManagerFactory.
`void`
`setJpaProperties(Properties jpaProperties)`
Specify JPA properties, to be passed into `Persistence.createEntityManagerFactory` (if any).
`void`
`setJpaPropertyMap(Map<String,?> jpaProperties)`
Specify JPA properties as a Map, to be passed into `Persistence.createEntityManagerFactory` (if any).
`void`
`setJpaVendorAdapter(JpaVendorAdapter jpaVendorAdapter)`
Specify the JpaVendorAdapter implementation for the desired JPA provider, if any.
`void`
`setPersistenceProvider(PersistenceProvider persistenceProvider)`
Set the PersistenceProvider instance to use for creating the EntityManagerFactory.
`void`
`setPersistenceProviderClass(Class<? extends PersistenceProvider> persistenceProviderClass)`
Set the PersistenceProvider implementation class to use for creating the EntityManagerFactory.
`void`
`setPersistenceUnitName(String persistenceUnitName)`
Specify the name of the persistence unit configuration to use.
`org.springframework.dao.DataAccessException`
`translateExceptionIfPossible(RuntimeException ex)`
Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.
`protected Object`
`writeReplace()`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Field Details

### logger

protected final org.apache.commons.logging.Log logger
Logger available to subclasses.

## Constructor Details

### AbstractEntityManagerFactoryBean

public AbstractEntityManagerFactoryBean()

## Method Details

### setPersistenceProviderClass

public void setPersistenceProviderClass(Class<? extends PersistenceProvider> persistenceProviderClass)
Set the PersistenceProvider implementation class to use for creating the EntityManagerFactory. If not specified, the persistence provider will be taken from the JpaVendorAdapter (if any) or retrieved through scanning (as far as possible).

See Also:
  - `JpaVendorAdapter.getPersistenceProvider()`
  - `PersistenceProvider`
  - `Persistence`

### setPersistenceProvider

public void setPersistenceProvider(@Nullable PersistenceProvider persistenceProvider)
Set the PersistenceProvider instance to use for creating the EntityManagerFactory. If not specified, the persistence provider will be taken from the JpaVendorAdapter (if any) or determined by the persistence unit deployment descriptor (as far as possible).

See Also:
  - `JpaVendorAdapter.getPersistenceProvider()`
  - `PersistenceProvider`
  - `Persistence`

### getPersistenceProvider

@Nullable public PersistenceProvider getPersistenceProvider()
Description copied from interface: `EntityManagerFactoryInfo`
Return the underlying PersistenceProvider that the underlying EntityManagerFactory was created with.

Specified by:
  `getPersistenceProvider` in interface `EntityManagerFactoryInfo`
Returns:
  the PersistenceProvider used to create this EntityManagerFactory, or `null` if the standard JPA provider autodetection process was used to configure the EntityManagerFactory

### setPersistenceUnitName

public void setPersistenceUnitName(@Nullable String persistenceUnitName)
Specify the name of the persistence unit configuration to use.

Default is none, indicating the default persistence unit configuration. The persistence provider will throw an exception if ambiguous persistence unit configurations are found.

See Also:
  - `Persistence.createEntityManagerFactory(String)`

### getPersistenceUnitName

@Nullable public String getPersistenceUnitName()
Description copied from interface: `EntityManagerFactoryInfo`
Return the name of the persistence unit used to create this EntityManagerFactory, or `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()`.

Specified by:
  `getPersistenceUnitName` in interface `EntityManagerFactoryInfo`
See Also:
  - `EntityManagerFactoryInfo.getPersistenceUnitInfo()`
  - `PersistenceUnitInfo.getPersistenceUnitName()`

### setJpaProperties

public void setJpaProperties(Properties jpaProperties)
Specify JPA properties, to be passed into `Persistence.createEntityManagerFactory` (if any).

Can be populated with a String "value" (parsed via PropertiesEditor) or a "props" element in XML bean definitions.

See Also:
  - `Persistence.createEntityManagerFactory(String, Map)`
  - `PersistenceProvider.createContainerEntityManagerFactory(PersistenceUnitInfo, Map)`

### setJpaPropertyMap

public void setJpaPropertyMap(@Nullable Map<String,?> jpaProperties)
Specify JPA properties as a Map, to be passed into `Persistence.createEntityManagerFactory` (if any).

Can be populated with a "map" or "props" element in XML bean definitions.

See Also:
  - `Persistence.createEntityManagerFactory(String, Map)`
  - `PersistenceProvider.createContainerEntityManagerFactory(PersistenceUnitInfo, Map)`

### getJpaPropertyMap

public Map<String,Object> getJpaPropertyMap()
Allow `Map` access to the JPA properties to be passed to the persistence provider, with the option to add or override specific entries.

Useful for specifying entries directly, for example via `jpaPropertyMap[myKey]`.

### setEntityManagerFactoryInterface

public void setEntityManagerFactoryInterface(Class<? extends EntityManagerFactory> emfInterface)
Specify the (potentially vendor-specific) EntityManagerFactory interface that this EntityManagerFactory proxy is supposed to implement.

The default will be taken from the specific JpaVendorAdapter, if any, or set to the standard `jakarta.persistence.EntityManagerFactory` interface else.

See Also:
  - `JpaVendorAdapter.getEntityManagerFactoryInterface()`

### setEntityManagerInterface

public void setEntityManagerInterface(@Nullable Class<? extends EntityManager> emInterface)
Specify the (potentially vendor-specific) EntityManager interface that this factory's EntityManagers are supposed to implement.

The default will be taken from the specific JpaVendorAdapter, if any, or set to the standard `jakarta.persistence.EntityManager` interface else.

See Also:
  - `JpaVendorAdapter.getEntityManagerInterface()`
  - `EntityManagerFactoryInfo.getEntityManagerInterface()`

### getEntityManagerInterface

@Nullable public Class<? extends EntityManager> getEntityManagerInterface()
Description copied from interface: `EntityManagerFactoryInfo`
Return the (potentially vendor-specific) EntityManager interface that this factory's EntityManagers will implement.

A `null` return value suggests that autodetection is supposed to happen: either based on a target `EntityManager` instance or simply defaulting to `jakarta.persistence.EntityManager`.

Specified by:
  `getEntityManagerInterface` in interface `EntityManagerFactoryInfo`

### setJpaDialect

public void setJpaDialect(@Nullable JpaDialect jpaDialect)
Specify the vendor-specific JpaDialect implementation to associate with this EntityManagerFactory. This will be exposed through the EntityManagerFactoryInfo interface, to be picked up as default dialect by accessors that intend to use JpaDialect functionality.

See Also:
  - `EntityManagerFactoryInfo.getJpaDialect()`

### getJpaDialect

@Nullable public JpaDialect getJpaDialect()
Description copied from interface: `EntityManagerFactoryInfo`
Return the vendor-specific JpaDialect implementation for this EntityManagerFactory, or `null` if not known.

Specified by:
  `getJpaDialect` in interface `EntityManagerFactoryInfo`

### setJpaVendorAdapter

public void setJpaVendorAdapter(@Nullable JpaVendorAdapter jpaVendorAdapter)
Specify the JpaVendorAdapter implementation for the desired JPA provider, if any. This will initialize appropriate defaults for the given provider, such as persistence provider class and JpaDialect, unless locally overridden in this FactoryBean.

### getJpaVendorAdapter

@Nullable public JpaVendorAdapter getJpaVendorAdapter()
Return the JpaVendorAdapter implementation for this EntityManagerFactory, or `null` if not known.

### setEntityManagerInitializer

public void setEntityManagerInitializer(Consumer<EntityManager> entityManagerInitializer)
Specify a callback for customizing every `EntityManager` created by the exposed `EntityManagerFactory`.

This is an alternative to a `JpaVendorAdapter`-level `postProcessEntityManager` implementation, enabling convenient customizations for application purposes, for example, setting Hibernate filters.

Since:
  5.3
See Also:
  - `JpaVendorAdapter.postProcessEntityManager(jakarta.persistence.EntityManager)`
  - `JpaTransactionManager.setEntityManagerInitializer(java.util.function.Consumer<jakarta.persistence.EntityManager>)`

### setBootstrapExecutor

public void setBootstrapExecutor(@Nullable org.springframework.core.task.AsyncTaskExecutor bootstrapExecutor)
Specify an asynchronous executor for background bootstrapping, for example, a `SimpleAsyncTaskExecutor`.

`EntityManagerFactory` initialization will then switch into background bootstrap mode, with a `EntityManagerFactory` proxy immediately returned for injection purposes instead of waiting for the JPA provider's bootstrapping to complete. However, note that the first actual call to a `EntityManagerFactory` method will then block until the JPA provider's bootstrapping completed, if not ready by then. For maximum benefit, make sure to avoid early `EntityManagerFactory` calls in init methods of related beans, even for metadata introspection purposes.

As of 6.2, JPA initialization is enforced before context refresh completion, waiting for asynchronous bootstrapping to complete by then.

Since:
  4.3

### getBootstrapExecutor

@Nullable public org.springframework.core.task.AsyncTaskExecutor getBootstrapExecutor()
Return the asynchronous executor for background bootstrapping, if any.

Since:
  4.3

### setBeanClassLoader

public void setBeanClassLoader(ClassLoader classLoader)

Specified by:
  `setBeanClassLoader` in interface `org.springframework.beans.factory.BeanClassLoaderAware`

### getBeanClassLoader

public ClassLoader getBeanClassLoader()
Description copied from interface: `EntityManagerFactoryInfo`
Return the ClassLoader that the application's beans are loaded with.

Proxies will be generated in this ClassLoader.

Specified by:
  `getBeanClassLoader` in interface `EntityManagerFactoryInfo`

### setBeanFactory

public void setBeanFactory(org.springframework.beans.factory.BeanFactory beanFactory)

Specified by:
  `setBeanFactory` in interface `org.springframework.beans.factory.BeanFactoryAware`

### setBeanName

public void setBeanName(String name)

Specified by:
  `setBeanName` in interface `org.springframework.beans.factory.BeanNameAware`

### afterPropertiesSet

public void afterPropertiesSet() throws PersistenceException

Specified by:
  `afterPropertiesSet` in interface `org.springframework.beans.factory.InitializingBean`
Throws:
  `PersistenceException`

### afterSingletonsInstantiated

public void afterSingletonsInstantiated()

Specified by:
  `afterSingletonsInstantiated` in interface `org.springframework.beans.factory.SmartInitializingSingleton`

### createEntityManagerFactoryProxy

protected EntityManagerFactory createEntityManagerFactoryProxy(@Nullable EntityManagerFactory emf)
Create a proxy for the given `EntityManagerFactory`. We do this to be able to return a transaction-aware proxy for an application-managed `EntityManager`.

Parameters:
  `emf` - the EntityManagerFactory as returned by the persistence provider, if initialized already
Returns:
  the EntityManagerFactory proxy

### createNativeEntityManagerFactory

protected abstract EntityManagerFactory createNativeEntityManagerFactory() throws PersistenceException
Subclasses must implement this method to create the EntityManagerFactory that will be returned by the `getObject()` method.

Returns:
  the EntityManagerFactory instance returned by this FactoryBean
Throws:
  `PersistenceException` - if the EntityManager cannot be created

### translateExceptionIfPossible

@Nullable public org.springframework.dao.DataAccessException translateExceptionIfPossible(RuntimeException ex)
Implementation of the PersistenceExceptionTranslator interface, as autodetected by Spring's PersistenceExceptionTranslationPostProcessor.

Uses the dialect's conversion if possible; otherwise falls back to standard JPA exception conversion.

Specified by:
  `translateExceptionIfPossible` in interface `org.springframework.dao.support.PersistenceExceptionTranslator`
See Also:
  - `PersistenceExceptionTranslationPostProcessor`
  - `PersistenceExceptionTranslator.translateExceptionIfPossible(java.lang.RuntimeException)`
  - `EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(java.lang.RuntimeException)`

### getNativeEntityManagerFactory

public EntityManagerFactory getNativeEntityManagerFactory()
Description copied from interface: `EntityManagerFactoryInfo`
Return the raw underlying EntityManagerFactory.

Specified by:
  `getNativeEntityManagerFactory` in interface `EntityManagerFactoryInfo`
Returns:
  the unadorned EntityManagerFactory (never `null`)

### createNativeEntityManager

public EntityManager createNativeEntityManager(@Nullable Map<?,?> properties)
Description copied from interface: `EntityManagerFactoryInfo`
Create a native JPA EntityManager to be used as the framework-managed resource behind an application-level EntityManager handle.

This exposes a native `EntityManager` from the underlying `native EntityManagerFactory`, taking `JpaVendorAdapter.postProcessEntityManager(EntityManager)` into account.

Specified by:
  `createNativeEntityManager` in interface `EntityManagerFactoryInfo`
See Also:
  - `EntityManagerFactoryInfo.getNativeEntityManagerFactory()`
  - `EntityManagerFactory.createEntityManager()`

### postProcessEntityManager

protected void postProcessEntityManager(EntityManager rawEntityManager)
Optional callback for post-processing the native EntityManager before active use.

The default implementation delegates to `JpaVendorAdapter.postProcessEntityManager(jakarta.persistence.EntityManager)`, if available.

Parameters:
  `rawEntityManager` - the EntityManager to post-process
Since:
  5.3
See Also:
  - `createNativeEntityManager(java.util.Map<?, ?>)`
  - `JpaVendorAdapter.postProcessEntityManager(jakarta.persistence.EntityManager)`

### getPersistenceUnitInfo

@Nullable public PersistenceUnitInfo getPersistenceUnitInfo()
Description copied from interface: `EntityManagerFactoryInfo`
Return the PersistenceUnitInfo used to create this EntityManagerFactory, if the in-container API was used.

Specified by:
  `getPersistenceUnitInfo` in interface `EntityManagerFactoryInfo`
Returns:
  the PersistenceUnitInfo used to create this EntityManagerFactory, or `null` if the in-container contract was not used to configure the EntityManagerFactory

### getDataSource

@Nullable public DataSource getDataSource()
Description copied from interface: `EntityManagerFactoryInfo`
Return the JDBC DataSource that this EntityManagerFactory obtains its JDBC Connections from.

Specified by:
  `getDataSource` in interface `EntityManagerFactoryInfo`
Returns:
  the JDBC DataSource, or `null` if not known

### getObject

@Nullable public EntityManagerFactory getObject()
Return the singleton EntityManagerFactory.

Specified by:
  `getObject` in interface `org.springframework.beans.factory.FactoryBean<EntityManagerFactory>`

### getObjectType

public Class<? extends EntityManagerFactory> getObjectType()

Specified by:
  `getObjectType` in interface `org.springframework.beans.factory.FactoryBean<EntityManagerFactory>`

### isSingleton

public boolean isSingleton()

Specified by:
  `isSingleton` in interface `org.springframework.beans.factory.FactoryBean<EntityManagerFactory>`

### destroy

public void destroy()
Close the EntityManagerFactory on bean factory shutdown.

Specified by:
  `destroy` in interface `org.springframework.beans.factory.DisposableBean`

### writeReplace

protected Object writeReplace() throws ObjectStreamException

Throws:
  `ObjectStreamException`