Modifier and Type	Class and Description
private static class	ExtendedEntityManagerCreator.ExtendedEntityManagerInvocationHandler InvocationHandler for extended EntityManagers as defined in the JPA spec.
private static class	ExtendedEntityManagerCreator.ExtendedEntityManagerSynchronization TransactionSynchronization enlisting an extended EntityManager with a current Spring transaction.

Modifier and Type	Field and Description
private static final Map<Class<?>, Class<?>[]>	cachedEntityManagerInterfaces

Access	Constructor and Description
public	ExtendedEntityManagerCreator()

Method Summary

Modifier and Type	Method and Description
public static EntityManager	Returns: an application-managed EntityManager that can join transactions but does not participate in them automatically createApplicationManagedEntityManager(EntityManager the raw EntityManager to decorate rawEntityManager, EntityManagerFactoryInfo the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from emfInfo) Create an application-managed extended EntityManager proxy.
public static EntityManager	Returns: an application-managed EntityManager that can join transactions but does not participate in them automatically createApplicationManagedEntityManager(EntityManager the raw EntityManager to decorate rawEntityManager, EntityManagerFactoryInfo the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from emfInfo, boolean whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules) synchronizedWithTransaction) Create an application-managed extended EntityManager proxy.
public static EntityManager	Returns: a container-managed EntityManager that will automatically participate in any managed transaction createContainerManagedEntityManager(EntityManager the raw EntityManager to decorate rawEntityManager, EntityManagerFactoryInfo the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from emfInfo) Create a container-managed extended EntityManager proxy.
public static EntityManager	Returns: a container-managed EntityManager that will automatically participate in any managed transaction createContainerManagedEntityManager(EntityManagerFactory the EntityManagerFactory to create the EntityManager with. If this implements the EntityManagerFactoryInfo interface, the corresponding JpaDialect and PersistenceUnitInfo will be detected accordingly. emf) Create a container-managed extended EntityManager proxy.
public static EntityManager	Returns: a container-managed EntityManager that will automatically participate in any managed transaction createContainerManagedEntityManager(EntityManagerFactory the EntityManagerFactory to create the EntityManager with. If this implements the EntityManagerFactoryInfo interface, the corresponding JpaDialect and PersistenceUnitInfo will be detected accordingly. emf, Map<?, ?> the properties to be passed into the `createEntityManager` call (may be `null`) properties) Create a container-managed extended EntityManager proxy.
public static EntityManager	Returns: a container-managed EntityManager that expects container-driven lifecycle management but may opt out of automatic transaction synchronization createContainerManagedEntityManager(EntityManagerFactory the EntityManagerFactory to create the EntityManager with. If this implements the EntityManagerFactoryInfo interface, the corresponding JpaDialect and PersistenceUnitInfo will be detected accordingly. emf, Map<?, ?> the properties to be passed into the `createEntityManager` call (may be `null`) properties, boolean whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules) synchronizedWithTransaction) Create a container-managed extended EntityManager proxy.
private static EntityManager	Returns: the EntityManager proxy createProxy(EntityManager raw EntityManager rawEntityManager, EntityManagerFactoryInfo the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from emfInfo, boolean whether to follow container-managed EntityManager or application-managed EntityManager semantics containerManaged, boolean whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules) synchronizedWithTransaction) Actually create the EntityManager proxy.
private static EntityManager	Returns: the EntityManager proxy createProxy(EntityManager raw EntityManager rawEm, Class<? extends EntityManager> the (potentially vendor-specific) EntityManager interface to proxy, or `null` for default detection of all interfaces emIfc, ClassLoader the ClassLoader to use for proxy creation (maybe `null`) cl, PersistenceExceptionTranslator the PersistenceException translator to use exceptionTranslator, Boolean whether to create a JTA-aware EntityManager (or `null` if not known in advance) jta, boolean whether to follow container-managed EntityManager or application-managed EntityManager semantics containerManaged, boolean whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules) synchronizedWithTransaction) Actually create the EntityManager proxy.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

cachedEntityManagerInterfaces	back to summary
private static final Map<Class<?>, Class<?>[]> cachedEntityManagerInterfaces

ExtendedEntityManagerCreator	back to summary
public ExtendedEntityManagerCreator()

Method Detail

createApplicationManagedEntityManager	back to summary
public static EntityManager createApplicationManagedEntityManager(EntityManager rawEntityManager, EntityManagerFactoryInfo emfInfo) Create an application-managed extended EntityManager proxy. Parameters rawEntityManager:EntityManager the raw EntityManager to decorate emfInfo:EntityManagerFactoryInfo the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from Returns:EntityManager an application-managed EntityManager that can join transactions but does not participate in them automatically

createApplicationManagedEntityManager

back to summary

public static EntityManager createApplicationManagedEntityManager(EntityManager rawEntityManager, EntityManagerFactoryInfo emfInfo)

Create an application-managed extended EntityManager proxy.

Parameters

rawEntityManager:EntityManager: the raw EntityManager to decorate
emfInfo:EntityManagerFactoryInfo: the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from

Returns:EntityManager

an application-managed EntityManager that can join transactions but does not participate in them automatically

createApplicationManagedEntityManager	back to summary
public static EntityManager createApplicationManagedEntityManager(EntityManager rawEntityManager, EntityManagerFactoryInfo emfInfo, boolean synchronizedWithTransaction) Create an application-managed extended EntityManager proxy. Parameters rawEntityManager:EntityManager the raw EntityManager to decorate emfInfo:EntityManagerFactoryInfo the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from synchronizedWithTransaction:boolean whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules) Returns:EntityManager an application-managed EntityManager that can join transactions but does not participate in them automatically Since 4.0

createApplicationManagedEntityManager

back to summary

public static EntityManager createApplicationManagedEntityManager(EntityManager rawEntityManager, EntityManagerFactoryInfo emfInfo, boolean synchronizedWithTransaction)

Create an application-managed extended EntityManager proxy.

Parameters

rawEntityManager:EntityManager: the raw EntityManager to decorate
emfInfo:EntityManagerFactoryInfo: the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from
synchronizedWithTransaction:boolean: whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules)

Returns:EntityManager

an application-managed EntityManager that can join transactions but does not participate in them automatically

Since

4.0

createContainerManagedEntityManager	back to summary
public static EntityManager createContainerManagedEntityManager(EntityManager rawEntityManager, EntityManagerFactoryInfo emfInfo) Create a container-managed extended EntityManager proxy. Parameters rawEntityManager:EntityManager the raw EntityManager to decorate emfInfo:EntityManagerFactoryInfo the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from Returns:EntityManager a container-managed EntityManager that will automatically participate in any managed transaction

createContainerManagedEntityManager

back to summary

public static EntityManager createContainerManagedEntityManager(EntityManager rawEntityManager, EntityManagerFactoryInfo emfInfo)

Create a container-managed extended EntityManager proxy.

Parameters

rawEntityManager:EntityManager: the raw EntityManager to decorate
emfInfo:EntityManagerFactoryInfo: the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from

Returns:EntityManager

a container-managed EntityManager that will automatically participate in any managed transaction

createContainerManagedEntityManager back to summary

createContainerManagedEntityManager	back to summary
public static EntityManager createContainerManagedEntityManager(EntityManagerFactory emf) Create a container-managed extended EntityManager proxy. Parameters emf:EntityManagerFactory the EntityManagerFactory to create the EntityManager with. If this implements the EntityManagerFactoryInfo interface, the corresponding JpaDialect and PersistenceUnitInfo will be detected accordingly. Returns:EntityManager a container-managed EntityManager that will automatically participate in any managed transaction See Also `jakarta.persistence.EntityManagerFactory#createEntityManager()`

public static EntityManager createContainerManagedEntityManager(EntityManagerFactory emf)

Create a container-managed extended EntityManager proxy.

Parameters

emf:EntityManagerFactory: the EntityManagerFactory to create the EntityManager with. If this implements the EntityManagerFactoryInfo interface, the corresponding JpaDialect and PersistenceUnitInfo will be detected accordingly.

Returns:EntityManager

a container-managed EntityManager that will automatically participate in any managed transaction

createContainerManagedEntityManager back to summary

createContainerManagedEntityManager	back to summary
public static EntityManager createContainerManagedEntityManager(EntityManagerFactory emf, Map<?, ?> properties) Create a container-managed extended EntityManager proxy. Parameters emf:EntityManagerFactory the EntityManagerFactory to create the EntityManager with. If this implements the EntityManagerFactoryInfo interface, the corresponding JpaDialect and PersistenceUnitInfo will be detected accordingly. properties:Map<?, ?> the properties to be passed into the `createEntityManager` call (may be `null`) Returns:EntityManager a container-managed EntityManager that will automatically participate in any managed transaction See Also `jakarta.persistence.EntityManagerFactory#createEntityManager(java.util.Map)`

public static EntityManager createContainerManagedEntityManager(EntityManagerFactory emf, Map<?, ?> properties)

Create a container-managed extended EntityManager proxy.

Parameters

emf:EntityManagerFactory: the EntityManagerFactory to create the EntityManager with. If this implements the EntityManagerFactoryInfo interface, the corresponding JpaDialect and PersistenceUnitInfo will be detected accordingly.
properties:Map<?, ?>: the properties to be passed into the createEntityManager call (may be null)

Returns:EntityManager

a container-managed EntityManager that will automatically participate in any managed transaction

createContainerManagedEntityManager back to summary

createContainerManagedEntityManager	back to summary
public static EntityManager createContainerManagedEntityManager(EntityManagerFactory emf, Map<?, ?> properties, boolean synchronizedWithTransaction) Create a container-managed extended EntityManager proxy. Parameters emf:EntityManagerFactory the EntityManagerFactory to create the EntityManager with. If this implements the EntityManagerFactoryInfo interface, the corresponding JpaDialect and PersistenceUnitInfo will be detected accordingly. properties:Map<?, ?> the properties to be passed into the `createEntityManager` call (may be `null`) synchronizedWithTransaction:boolean whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules) Returns:EntityManager a container-managed EntityManager that expects container-driven lifecycle management but may opt out of automatic transaction synchronization Since 4.0 See Also `jakarta.persistence.EntityManagerFactory#createEntityManager(java.util.Map)`

public static EntityManager createContainerManagedEntityManager(EntityManagerFactory emf, Map<?, ?> properties, boolean synchronizedWithTransaction)

Create a container-managed extended EntityManager proxy.

Parameters

emf:EntityManagerFactory: the EntityManagerFactory to create the EntityManager with. If this implements the EntityManagerFactoryInfo interface, the corresponding JpaDialect and PersistenceUnitInfo will be detected accordingly.
properties:Map<?, ?>: the properties to be passed into the createEntityManager call (may be null)
synchronizedWithTransaction:boolean: whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules)

Returns:EntityManager

a container-managed EntityManager that expects container-driven lifecycle management but may opt out of automatic transaction synchronization

Since

4.0

createProxy	back to summary
private static EntityManager createProxy(EntityManager rawEntityManager, EntityManagerFactoryInfo emfInfo, boolean containerManaged, boolean synchronizedWithTransaction) Actually create the EntityManager proxy. Parameters rawEntityManager:EntityManager raw EntityManager emfInfo:EntityManagerFactoryInfo the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from containerManaged:boolean whether to follow container-managed EntityManager or application-managed EntityManager semantics synchronizedWithTransaction:boolean whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules) Returns:EntityManager the EntityManager proxy

createProxy

back to summary

private static EntityManager createProxy(EntityManager rawEntityManager, EntityManagerFactoryInfo emfInfo, boolean containerManaged, boolean synchronizedWithTransaction)

Actually create the EntityManager proxy.

Parameters

rawEntityManager:EntityManager: raw EntityManager
emfInfo:EntityManagerFactoryInfo: the EntityManagerFactoryInfo to obtain the JpaDialect and PersistenceUnitInfo from
containerManaged:boolean: whether to follow container-managed EntityManager or application-managed EntityManager semantics
synchronizedWithTransaction:boolean: whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules)

Returns:EntityManager

the EntityManager proxy

createProxy back to summary

createProxy	back to summary
private static EntityManager createProxy(EntityManager rawEm, Class<? extends EntityManager> emIfc, ClassLoader cl, PersistenceExceptionTranslator exceptionTranslator, Boolean jta, boolean containerManaged, boolean synchronizedWithTransaction) Actually create the EntityManager proxy. Parameters rawEm:EntityManager raw EntityManager emIfc:Class<? extends EntityManager> the (potentially vendor-specific) EntityManager interface to proxy, or `null` for default detection of all interfaces cl:ClassLoader the ClassLoader to use for proxy creation (maybe `null`) exceptionTranslator:PersistenceExceptionTranslator the PersistenceException translator to use jta:Boolean whether to create a JTA-aware EntityManager (or `null` if not known in advance) containerManaged:boolean whether to follow container-managed EntityManager or application-managed EntityManager semantics synchronizedWithTransaction:boolean whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules) Returns:EntityManager the EntityManager proxy

private static EntityManager createProxy(EntityManager rawEm, Class<? extends EntityManager> emIfc, ClassLoader cl, PersistenceExceptionTranslator exceptionTranslator, Boolean jta, boolean containerManaged, boolean synchronizedWithTransaction)

Actually create the EntityManager proxy.

Parameters

rawEm:EntityManager: raw EntityManager
emIfc:Class<? extends EntityManager>: the (potentially vendor-specific) EntityManager interface to proxy, or null for default detection of all interfaces
cl:ClassLoader: the ClassLoader to use for proxy creation (maybe null)
exceptionTranslator:PersistenceExceptionTranslator: the PersistenceException translator to use
jta:Boolean: whether to create a JTA-aware EntityManager (or null if not known in advance)
containerManaged:boolean: whether to follow container-managed EntityManager or application-managed EntityManager semantics
synchronizedWithTransaction:boolean: whether to automatically join ongoing transactions (according to the JPA 2.1 SynchronizationType rules)

Returns:EntityManager

the EntityManager proxy

org.springframework.orm.jpa back to summary

private final Class ExtendedEntityManagerCreator.ExtendedEntityManagerInvocationHandler

Class Inheritance

extends Object
implements InvocationHandler, Serializable

java.lang.Object
org.springframework.orm.jpa.ExtendedEntityManagerCreator.ExtendedEntityManagerInvocationHandler

All Implemented Interfaces

java.io.Serializable, java.lang.reflect.InvocationHandler

Annotations

@SuppressWarnings:serial

InvocationHandler for extended EntityManagers as defined in the JPA spec.

Field Summary

Modifier and Type	Field and Description
private final boolean	containerManaged
private final PersistenceExceptionTranslator	exceptionTranslator
private final boolean	jta
private static final Log	logger
private final boolean	synchronizedWithTransaction
private final EntityManager	target

Constructor Summary

Access	Constructor and Description
private	ExtendedEntityManagerInvocationHandler(EntityManager target, PersistenceExceptionTranslator exceptionTranslator, Boolean jta, boolean containerManaged, boolean synchronizedWithTransaction)

Method Summary

Modifier and Type	Method and Description
private void	doJoinTransaction(boolean whether to enforce the transaction (i.e. whether failure to join is considered fatal) enforce) Join an existing transaction, if not already joined.
private void	enlistInCurrentTransaction() Enlist this application-managed EntityManager in the current transaction.
public Object	invoke(Object the proxy instance that the method was invoked on proxy, Method the `Method` instance corresponding to the interface method invoked on the proxy instance. The declaring class of the `Method` object will be the interface that the method was declared in, which may be a superinterface of the proxy interface that the proxy class inherits the method through. method, Object[] an array of objects containing the values of the arguments passed in the method invocation on the proxy instance, or `null` if interface method takes no arguments. Arguments of primitive types are wrapped in instances of the appropriate primitive wrapper class, such as `java.lang.Integer` or `java.lang.Boolean`. args) Implements java.lang.reflect.InvocationHandler.invoke. Processes a method invocation on a proxy instance and returns the result.
private boolean	isJtaEntityManager()

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

containerManaged	back to summary
private final boolean containerManaged

exceptionTranslator	back to summary
private final PersistenceExceptionTranslator exceptionTranslator Annotations @Nullable

jta	back to summary
private final boolean jta

logger	back to summary
private static final Log logger

synchronizedWithTransaction	back to summary
private final boolean synchronizedWithTransaction

target	back to summary
private final EntityManager target

Constructor Detail

ExtendedEntityManagerInvocationHandler	back to summary
private ExtendedEntityManagerInvocationHandler(EntityManager target, PersistenceExceptionTranslator exceptionTranslator, Boolean jta, boolean containerManaged, boolean synchronizedWithTransaction)

Method Detail

doJoinTransaction	back to summary
private void doJoinTransaction(boolean enforce) Join an existing transaction, if not already joined. Parameters enforce:boolean whether to enforce the transaction (i.e. whether failure to join is considered fatal)

doJoinTransaction

back to summary

private void doJoinTransaction(boolean enforce)

Join an existing transaction, if not already joined.

Parameters

enforce:boolean: whether to enforce the transaction (i.e. whether failure to join is considered fatal)

enlistInCurrentTransaction	back to summary
private void enlistInCurrentTransaction() Enlist this application-managed EntityManager in the current transaction.

invoke back to summary

invoke	back to summary
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable Implements java.lang.reflect.InvocationHandler.invoke. Doc from java.lang.reflect.InvocationHandler.invoke. Processes a method invocation on a proxy instance and returns the result. This method will be invoked on an invocation handler when a method is invoked on a proxy instance that it is associated with. Parameters proxy:Object the proxy instance that the method was invoked on method:Method the `Method` instance corresponding to the interface method invoked on the proxy instance. The declaring class of the `Method` object will be the interface that the method was declared in, which may be a superinterface of the proxy interface that the proxy class inherits the method through. args:Object[] an array of objects containing the values of the arguments passed in the method invocation on the proxy instance, or `null` if interface method takes no arguments. Arguments of primitive types are wrapped in instances of the appropriate primitive wrapper class, such as `java.lang.Integer` or `java.lang.Boolean`. Returns:Object the value to return from the method invocation on the proxy instance. If the declared return type of the interface method is a primitive type, then the value returned by this method must be an instance of the corresponding primitive wrapper class; otherwise, it must be a type assignable to the declared return type. If the value returned by this method is `null` and the interface method's return type is primitive, then a `NullPointerException` will be thrown by the method invocation on the proxy instance. If the value returned by this method is otherwise not compatible with the interface method's declared return type as described above, a `ClassCastException` will be thrown by the method invocation on the proxy instance. Annotations @Override @Nullable Exceptions Throwable: the exception to throw from the method invocation on the proxy instance. The exception's type must be assignable either to any of the exception types declared in the `throws` clause of the interface method or to the unchecked exception types `java.lang.RuntimeException` or `java.lang.Error`. If a checked exception is thrown by this method that is not assignable to any of the exception types declared in the `throws` clause of the interface method, then an `UndeclaredThrowableException` containing the exception that was thrown by this method will be thrown by the method invocation on the proxy instance.

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

Implements java.lang.reflect.InvocationHandler.invoke.

Doc from java.lang.reflect.InvocationHandler.invoke.

Processes a method invocation on a proxy instance and returns the result. This method will be invoked on an invocation handler when a method is invoked on a proxy instance that it is associated with.

Parameters

proxy:Object: the proxy instance that the method was invoked on
method:Method: the Method instance corresponding to the interface method invoked on the proxy instance. The declaring class of the Method object will be the interface that the method was declared in, which may be a superinterface of the proxy interface that the proxy class inherits the method through.
args:Object[]: an array of objects containing the values of the arguments passed in the method invocation on the proxy instance, or null if interface method takes no arguments. Arguments of primitive types are wrapped in instances of the appropriate primitive wrapper class, such as java.lang.Integer or java.lang.Boolean.

Returns:Object

the value to return from the method invocation on the proxy instance. If the declared return type of the interface method is a primitive type, then the value returned by this method must be an instance of the corresponding primitive wrapper class; otherwise, it must be a type assignable to the declared return type. If the value returned by this method is null and the interface method's return type is primitive, then a NullPointerException will be thrown by the method invocation on the proxy instance. If the value returned by this method is otherwise not compatible with the interface method's declared return type as described above, a ClassCastException will be thrown by the method invocation on the proxy instance.

Annotations

@Override
@Nullable

Exceptions

Throwable:: the exception to throw from the method invocation on the proxy instance. The exception's type must be assignable either to any of the exception types declared in the throws clause of the interface method or to the unchecked exception types java.lang.RuntimeException or java.lang.Error. If a checked exception is thrown by this method that is not assignable to any of the exception types declared in the throws clause of the interface method, then an UndeclaredThrowableException containing the exception that was thrown by this method will be thrown by the method invocation on the proxy instance.

isJtaEntityManager	back to summary
private boolean isJtaEntityManager()

org.springframework.orm.jpa back to summary

private Class ExtendedEntityManagerCreator.ExtendedEntityManagerSynchronization

Class Inheritance

extends ResourceHolderSynchronization<EntityManagerHolder, EntityManager>
implements Ordered

java.lang.Object
org.springframework.transaction.support.ResourceHolderSynchronization
org.springframework.orm.jpa.ExtendedEntityManagerCreator.ExtendedEntityManagerSynchronization

All Implemented Interfaces

org.springframework.core.Ordered

TransactionSynchronization enlisting an extended EntityManager with a current Spring transaction.

Field Summary

Modifier and Type	Field and Description
public volatile boolean	closeOnCompletion
private final EntityManager	entityManager
private final PersistenceExceptionTranslator	exceptionTranslator

Constructor Summary

Access	Constructor and Description
public	ExtendedEntityManagerSynchronization(EntityManager em, PersistenceExceptionTranslator exceptionTranslator)

Method Summary

Modifier and Type	Method and Description
public void	afterCommit() Overrides org.springframework.transaction.support.ResourceHolderSynchronization.afterCommit. Overrides default org.springframework.transaction.support.TransactionSynchronization.afterCommit. Invoked after transaction commit.
public void	afterCompletion(int completion status according to the `STATUS_*` constants status) Overrides org.springframework.transaction.support.ResourceHolderSynchronization.afterCompletion. Overrides default org.springframework.transaction.support.TransactionSynchronization.afterCompletion. Invoked after transaction commit/rollback.
private RuntimeException	convertException(RuntimeException ex)
protected void	flushResource(EntityManagerHolder the resource holder to flush resourceHolder) Overrides org.springframework.transaction.support.ResourceHolderSynchronization.flushResource. Flush callback for the given resource holder.
public int	getOrder() Overrides default org.springframework.transaction.support.TransactionSynchronization.getOrder. Implements org.springframework.core.Ordered.getOrder. Get the order value of this object.
protected boolean	shouldReleaseBeforeCompletion() Overrides org.springframework.transaction.support.ResourceHolderSynchronization.shouldReleaseBeforeCompletion. Return whether this holder's resource should be released before transaction completion (`true`) or rather after transaction completion (`false`).

Inherited from org.springframework.transaction.support.ResourceHolderSynchronization:: beforeCommit beforeCompletion cleanupResource flush processResourceAfterCommit releaseResource resume shouldReleaseAfterCompletion shouldUnbindAtCompletion suspend

Field Detail

closeOnCompletion	back to summary
public volatile boolean closeOnCompletion

entityManager	back to summary
private final EntityManager entityManager

exceptionTranslator	back to summary
private final PersistenceExceptionTranslator exceptionTranslator Annotations @Nullable

Constructor Detail

ExtendedEntityManagerSynchronization	back to summary
public ExtendedEntityManagerSynchronization(EntityManager em, PersistenceExceptionTranslator exceptionTranslator)

Method Detail

afterCommit back to summary

afterCommit	back to summary
public void afterCommit() Overrides org.springframework.transaction.support.ResourceHolderSynchronization.afterCommit. Overrides default org.springframework.transaction.support.TransactionSynchronization.afterCommit. Doc from org.springframework.transaction.support.TransactionSynchronization.afterCommit. Invoked after transaction commit. Can perform further operations right after the main transaction has successfully committed. Can e.g. commit further operations that are supposed to follow on a successful commit of the main transaction, like confirmation messages or emails. Note The transaction will have been committed already, but the transactional resources might still be active and accessible. As a consequence, any data access code triggered at this point will still "participate" in the original transaction, allowing to perform some cleanup (with no commit following anymore!), unless it explicitly declares that it needs to run in a separate transaction. Hence: Use `PROPAGATION_REQUIRES_NEW` for any transactional operation that is called from here. Annotations @Override

public void afterCommit()

Overrides org.springframework.transaction.support.ResourceHolderSynchronization.afterCommit.

Overrides default org.springframework.transaction.support.TransactionSynchronization.afterCommit.

Doc from org.springframework.transaction.support.TransactionSynchronization.afterCommit.

Invoked after transaction commit. Can perform further operations right after the main transaction has successfully committed.

Can e.g. commit further operations that are supposed to follow on a successful commit of the main transaction, like confirmation messages or emails.

Note

The transaction will have been committed already, but the transactional resources might still be active and accessible. As a consequence, any data access code triggered at this point will still "participate" in the original transaction, allowing to perform some cleanup (with no commit following anymore!), unless it explicitly declares that it needs to run in a separate transaction. Hence: Use PROPAGATION_REQUIRES_NEW for any transactional operation that is called from here.

Annotations

@Override

afterCompletion back to summary

afterCompletion	back to summary
public void afterCompletion(int status) Overrides org.springframework.transaction.support.ResourceHolderSynchronization.afterCompletion. Overrides default org.springframework.transaction.support.TransactionSynchronization.afterCompletion. Doc from org.springframework.transaction.support.TransactionSynchronization.afterCompletion. Invoked after transaction commit/rollback. Can perform resource cleanup after transaction completion. Note The transaction will have been committed or rolled back already, but the transactional resources might still be active and accessible. As a consequence, any data access code triggered at this point will still "participate" in the original transaction, allowing to perform some cleanup (with no commit following anymore!), unless it explicitly declares that it needs to run in a separate transaction. Hence: Use `PROPAGATION_REQUIRES_NEW` for any transactional operation that is called from here. Parameters status:int completion status according to the `STATUS_*` constants Annotations @Override

public void afterCompletion(int status)

Overrides org.springframework.transaction.support.ResourceHolderSynchronization.afterCompletion.

Overrides default org.springframework.transaction.support.TransactionSynchronization.afterCompletion.

Doc from org.springframework.transaction.support.TransactionSynchronization.afterCompletion.

Invoked after transaction commit/rollback. Can perform resource cleanup after transaction completion.

Note

The transaction will have been committed or rolled back already, but the transactional resources might still be active and accessible. As a consequence, any data access code triggered at this point will still "participate" in the original transaction, allowing to perform some cleanup (with no commit following anymore!), unless it explicitly declares that it needs to run in a separate transaction. Hence: Use PROPAGATION_REQUIRES_NEW for any transactional operation that is called from here.

Parameters

status:int: completion status according to the STATUS_* constants

Annotations

@Override

convertException	back to summary
private RuntimeException convertException(RuntimeException ex)

flushResource	back to summary
protected void flushResource(EntityManagerHolder resourceHolder) Overrides org.springframework.transaction.support.ResourceHolderSynchronization.flushResource. Doc from org.springframework.transaction.support.ResourceHolderSynchronization.flushResource. Flush callback for the given resource holder. Parameters resourceHolder:EntityManagerHolder the resource holder to flush Annotations @Override

flushResource

back to summary

protected void flushResource(EntityManagerHolder resourceHolder)

Overrides org.springframework.transaction.support.ResourceHolderSynchronization.flushResource.

Doc from org.springframework.transaction.support.ResourceHolderSynchronization.flushResource.

Flush callback for the given resource holder.

Parameters

resourceHolder:EntityManagerHolder: the resource holder to flush

Annotations

@Override

getOrder back to summary

getOrder	back to summary
public int getOrder() Overrides default org.springframework.transaction.support.TransactionSynchronization.getOrder. Implements org.springframework.core.Ordered.getOrder. Doc from org.springframework.core.Ordered.getOrder. Get the order value of this object. Higher values are interpreted as lower priority. As a consequence, the object with the lowest value has the highest priority (somewhat analogous to Servlet `load-on-startup` values). Same order values will result in arbitrary sort positions for the affected objects. Returns:int the order value Annotations @Override

public int getOrder()

Overrides default org.springframework.transaction.support.TransactionSynchronization.getOrder.

Implements org.springframework.core.Ordered.getOrder.

Doc from org.springframework.core.Ordered.getOrder.

Get the order value of this object.

Higher values are interpreted as lower priority. As a consequence, the object with the lowest value has the highest priority (somewhat analogous to Servlet load-on-startup values).

Same order values will result in arbitrary sort positions for the affected objects.

Returns:int

the order value

Annotations

@Override

shouldReleaseBeforeCompletion back to summary

shouldReleaseBeforeCompletion	back to summary
protected boolean shouldReleaseBeforeCompletion() Overrides org.springframework.transaction.support.ResourceHolderSynchronization.shouldReleaseBeforeCompletion. Doc from org.springframework.transaction.support.ResourceHolderSynchronization.shouldReleaseBeforeCompletion. Return whether this holder's resource should be released before transaction completion (`true`) or rather after transaction completion (`false`). Note that resources will only be released when they are unbound from the thread (`shouldUnbindAtCompletion()`). The default implementation returns `true`. Annotations @Override

protected boolean shouldReleaseBeforeCompletion()

Overrides org.springframework.transaction.support.ResourceHolderSynchronization.shouldReleaseBeforeCompletion.

Doc from org.springframework.transaction.support.ResourceHolderSynchronization.shouldReleaseBeforeCompletion.

Return whether this holder's resource should be released before transaction completion (true) or rather after transaction completion (false).

Note that resources will only be released when they are unbound from the thread (shouldUnbindAtCompletion()).

The default implementation returns true.

Annotations

@Override

public abstract Class ExtendedEntityManagerCreator

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private final Class ExtendedEntityManagerCreator.ExtendedEntityManagerInvocationHandler

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private Class ExtendedEntityManagerCreator.ExtendedEntityManagerSynchronization

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail