[JBoss JIRA] (WFLY-11233) allow EntityManager caching in the JPA container
by Scott Marlow (Jira)
[ https://issues.jboss.org/browse/WFLY-11233?page=com.atlassian.jira.plugin... ]
Scott Marlow updated WFLY-11233:
--------------------------------
Description:
It could be interesting to see if caching EntityManager instances (per EntityManagerFactory) could improve performance for applications, that could benefit from that.
The JPA 2.2 specification mentions the below, pay particular attention to the text "whether entity manager instances are sometimes reused" in section 7.8.2, also look at mention of [88]:
{quote}
7.8 Requirements on the Container
7.8.1 Application-managed Persistence Contexts
When application-managed persistence contexts are used, the container must instantiate the entity manager factory and expose it to the application via JNDI. The container might use internal APIs to create the entity manager factory, or it might use the PersistenceProvider.createContainerEntityManagerFactory method. However, the container is required to support third-party persistence providers, and in this case the container must use the PersistenceProvider.createContainerEntityManagerFactory method to create the entity manager factory and the EntityManagerFactory.close method to destroy the entity manager factory prior to shutdown (if it has not been previously closed by the application).
7.8.2 Container Managed Persistence Contexts
The container is responsible for managing the lifecycle of container-managed persistence contexts, for injecting EntityManager references into web components and session bean and message-driven bean components, and for making EntityManager references available to direct lookups in JNDI. When operating with a third-party persistence provider, the container uses the contracts defined in section 7.9 to create and destroy container-managed persistence contexts. It is undefined whether a new entity manager instance is created for every persistence context, or whether entity manager instances are sometimes reused. Exactly how the container maintains the association between persistence context and JTA transaction is not defined. If a persistence context is already associated with a JTA transaction, the container uses that persistence context for subsequent invocations within the scope of that transaction, according to the semantics for persistence context propagation defined in section 7.6.4.
7.9 Runtime Contracts between the Container and Persistence Provider
This section describes contracts between the container and the persistence provider for the pluggability of third-party persistence providers. Containers are required to support these pluggability contracts. [87]
7.9.1 Container Responsibilities
For the management of a transaction-scoped persistence context, if there is no EntityManager already associated with the JTA transaction:
* The container creates a new entity manager by calling EntityManagerFactory.createEntityManager when the first invocation of an entity manager with PersistenceContextType.TRANSACTION occurs within the scope of a business method executing in the JTA transaction.
* After the JTA transaction has completed (either by transaction commit or rollback), the container closes the entity manager by calling EntityManager.close. [88] Note that the JTA transaction may rollback in a background thread (e.g., as a result of transaction timeout), in which case the container should arrange for the entity manager to be closed but the EntityManager.close method should not be concurrently invoked while the application is in an EntityManager invocation.
The container must throw the TransactionRequiredException if a transaction-scoped persistence context is used and the EntityManager persist, remove, merge, or refresh method is invoked when no transaction is active.
For stateful session beans with extended persistence contexts:
* The container creates an entity manager by calling EntityManagerFactory.createEntityManager when a stateful session bean is created that declares a dependency on an entity manager with PersistenceContextType.EXTENDED. (See section 7.6.3).
* The container closes the entity manager by calling EntityManager.close after the stateful session bean and all other stateful session beans that have inherited the same persistence context as the entity manager have been removed.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses container managed transaction demarcation, and the entity manager is not already associated with the current JTA transaction, the container associates the entity manager with the current JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction. If there is a different persistence context already associated with the JTA transaction, the container throws the EJBException.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses bean managed transaction demarcation and a UserTransaction is begun within the method, the container associates the persistence context with the JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction.
The container must throw the IllegalStateException if the application calls EntityManager.close on a container-managed entity manager.
[87] It is not required that these contracts be used when a third-party persistence provider is not used: the container might use these same APIs or its might use its own internal APIs.
[88] The container may choose to pool EntityManagers: it instead of creating and closing in each case, it may acquire one from its pool and call clear() on it.
{quote}
One challenge with introducing an entity manager (per EntityManagerFactory) cache, is knowing when to close EntityManagers after certain errors have occurred on the EntityManager:
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], we can try to retrieve an entity manager from the cache (cache reference can be passed into the TransactionScopedEntityManager proxy constructor), if cache is empty, then create a new entity manager to return.
* In https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav..., if caching is enabled, we should call EntityManager.clear(), instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any further exception thrown by the call to em.close().
* If an entity manager is in a bad state, we shouldn't place it back in the cache. This may really be the same as the previous bullet but I wanted to mention it as a separate bullet, since we may need to add more error checking for the persistence throwing exceptions in [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...] or/and other places.
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], if caching is enabled, we should call EntityManager.clear() instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any any further exception thrown by the call to em.close().
* Lastly, we should update [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], to deal with releasing the entity manager cache before calling entityManagerFactory.close(). Since, [https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManagerFacto...] says that the entity managers will be closed automatically, we probably can just clear the cache of EntityManagers, instead of actually calling EntityManager.close() on each one in the cache.
* Also ensure that SynchronizationType is respected, so we don't mix SynchronizationType.UNSYNCHRONIZED + SynchronizationType.SYNCHRONIZED types. Perhaps we need a cache slot for each SynchronizationType.
EntityManager cache settings can be:
* No cache (default)
* ThreadLocal cache (only cached at the application thread level)
* Per EntityManagerFactory cache (cache is shared between multiple threads, so make it thread safe), this would need to be proven to be leak free (especially with CDI beans). Cache size would be configurable.
If EM leaks are a problem in the above, an alternative might be to only cache within JTA transactions, since we would then have control of the closing of the EntityManager.
was:
It could be interesting to see if caching EntityManager instances (per EntityManagerFactory) could improve performance for applications, that could benefit from that.
The JPA 2.2 specification mentions the below, pay particular attention to the text "whether entity manager instances are sometimes reused" in section 7.8.2, also look at mention of [88]:
{quote}
7.8 Requirements on the Container
7.8.1 Application-managed Persistence Contexts
When application-managed persistence contexts are used, the container must instantiate the entity manager factory and expose it to the application via JNDI. The container might use internal APIs to create the entity manager factory, or it might use the PersistenceProvider.createContainerEntityManagerFactory method. However, the container is required to support third-party persistence providers, and in this case the container must use the PersistenceProvider.createContainerEntityManagerFactory method to create the entity manager factory and the EntityManagerFactory.close method to destroy the entity manager factory prior to shutdown (if it has not been previously closed by the application).
7.8.2 Container Managed Persistence Contexts
The container is responsible for managing the lifecycle of container-managed persistence contexts, for injecting EntityManager references into web components and session bean and message-driven bean components, and for making EntityManager references available to direct lookups in JNDI. When operating with a third-party persistence provider, the container uses the contracts defined in section 7.9 to create and destroy container-managed persistence contexts. It is undefined whether a new entity manager instance is created for every persistence context, or whether entity manager instances are sometimes reused. Exactly how the container maintains the association between persistence context and JTA transaction is not defined. If a persistence context is already associated with a JTA transaction, the container uses that persistence context for subsequent invocations within the scope of that transaction, according to the semantics for persistence context propagation defined in section 7.6.4.
7.9 Runtime Contracts between the Container and Persistence Provider
This section describes contracts between the container and the persistence provider for the pluggability of third-party persistence providers. Containers are required to support these pluggability contracts. [87]
7.9.1 Container Responsibilities
For the management of a transaction-scoped persistence context, if there is no EntityManager already associated with the JTA transaction:
* The container creates a new entity manager by calling EntityManagerFactory.createEntityManager when the first invocation of an entity manager with PersistenceContextType.TRANSACTION occurs within the scope of a business method executing in the JTA transaction.
* After the JTA transaction has completed (either by transaction commit or rollback), the container closes the entity manager by calling EntityManager.close. [88] Note that the JTA transaction may rollback in a background thread (e.g., as a result of transaction timeout), in which case the container should arrange for the entity manager to be closed but the EntityManager.close method should not be concurrently invoked while the application is in an EntityManager invocation.
The container must throw the TransactionRequiredException if a transaction-scoped persistence context is used and the EntityManager persist, remove, merge, or refresh method is invoked when no transaction is active.
For stateful session beans with extended persistence contexts:
* The container creates an entity manager by calling EntityManagerFactory.createEntityManager when a stateful session bean is created that declares a dependency on an entity manager with PersistenceContextType.EXTENDED. (See section 7.6.3).
* The container closes the entity manager by calling EntityManager.close after the stateful session bean and all other stateful session beans that have inherited the same persistence context as the entity manager have been removed.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses container managed transaction demarcation, and the entity manager is not already associated with the current JTA transaction, the container associates the entity manager with the current JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction. If there is a different persistence context already associated with the JTA transaction, the container throws the EJBException.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses bean managed transaction demarcation and a UserTransaction is begun within the method, the container associates the persistence context with the JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction.
The container must throw the IllegalStateException if the application calls EntityManager.close on a container-managed entity manager.
[87] It is not required that these contracts be used when a third-party persistence provider is not used: the container might use these same APIs or its might use its own internal APIs.
[88] The container may choose to pool EntityManagers: it instead of creating and closing in each case, it may acquire one from its pool and call clear() on it.
{quote}
One challenge with introducing an entity manager (per EntityManagerFactory) cache, is knowing when to close EntityManagers after certain errors have occurred on the EntityManager:
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], we can try to retrieve an entity manager from the cache (cache reference can be passed into the TransactionScopedEntityManager proxy constructor), if cache is empty, then create a new entity manager to return.
* In https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav..., if caching is enabled, we should call EntityManager.clear(), instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any further exception thrown by the call to em.close().
* If an entity manager is in a bad state, we shouldn't place it back in the cache. This may really be the same as the previous bullet but I wanted to mention it as a separate bullet, since we may need to add more error checking for the persistence throwing exceptions in [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...] or/and other places.
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], if caching is enabled, we should call EntityManager.clear() instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any any further exception thrown by the call to em.close().
* Lastly, we should update [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], to deal with releasing the entity manager cache before calling entityManagerFactory.close(). Since, [https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManagerFacto...] says that the entity managers will be closed automatically, we probably can just clear the cache of EntityManagers, instead of actually calling EntityManager.close() on each one in the cache.
* Also ensure that SynchronizationType is respected, so we don't mix SynchronizationType.UNSYNCHRONIZED + SynchronizationType.SYNCHRONIZED types. Perhaps we need a cache slot for each SynchronizationType.
EntityManager cache settings can be:
* No cache (default)
* ThreadLocal cache (only cached at the application thread level)
* Per EntityManagerFactory cache (cache is shared between multiple threads, so make it thread safe), this would need to be proven to be leak free (especially with CDI beans). Cache size would be configurable.
> allow EntityManager caching in the JPA container
> ------------------------------------------------
>
> Key: WFLY-11233
> URL: https://issues.jboss.org/browse/WFLY-11233
> Project: WildFly
> Issue Type: Enhancement
> Components: JPA / Hibernate
> Reporter: Scott Marlow
> Assignee: Scott Marlow
> Priority: Major
>
> It could be interesting to see if caching EntityManager instances (per EntityManagerFactory) could improve performance for applications, that could benefit from that.
> The JPA 2.2 specification mentions the below, pay particular attention to the text "whether entity manager instances are sometimes reused" in section 7.8.2, also look at mention of [88]:
> {quote}
> 7.8 Requirements on the Container
> 7.8.1 Application-managed Persistence Contexts
> When application-managed persistence contexts are used, the container must instantiate the entity manager factory and expose it to the application via JNDI. The container might use internal APIs to create the entity manager factory, or it might use the PersistenceProvider.createContainerEntityManagerFactory method. However, the container is required to support third-party persistence providers, and in this case the container must use the PersistenceProvider.createContainerEntityManagerFactory method to create the entity manager factory and the EntityManagerFactory.close method to destroy the entity manager factory prior to shutdown (if it has not been previously closed by the application).
> 7.8.2 Container Managed Persistence Contexts
> The container is responsible for managing the lifecycle of container-managed persistence contexts, for injecting EntityManager references into web components and session bean and message-driven bean components, and for making EntityManager references available to direct lookups in JNDI. When operating with a third-party persistence provider, the container uses the contracts defined in section 7.9 to create and destroy container-managed persistence contexts. It is undefined whether a new entity manager instance is created for every persistence context, or whether entity manager instances are sometimes reused. Exactly how the container maintains the association between persistence context and JTA transaction is not defined. If a persistence context is already associated with a JTA transaction, the container uses that persistence context for subsequent invocations within the scope of that transaction, according to the semantics for persistence context propagation defined in section 7.6.4.
> 7.9 Runtime Contracts between the Container and Persistence Provider
> This section describes contracts between the container and the persistence provider for the pluggability of third-party persistence providers. Containers are required to support these pluggability contracts. [87]
> 7.9.1 Container Responsibilities
> For the management of a transaction-scoped persistence context, if there is no EntityManager already associated with the JTA transaction:
> * The container creates a new entity manager by calling EntityManagerFactory.createEntityManager when the first invocation of an entity manager with PersistenceContextType.TRANSACTION occurs within the scope of a business method executing in the JTA transaction.
> * After the JTA transaction has completed (either by transaction commit or rollback), the container closes the entity manager by calling EntityManager.close. [88] Note that the JTA transaction may rollback in a background thread (e.g., as a result of transaction timeout), in which case the container should arrange for the entity manager to be closed but the EntityManager.close method should not be concurrently invoked while the application is in an EntityManager invocation.
> The container must throw the TransactionRequiredException if a transaction-scoped persistence context is used and the EntityManager persist, remove, merge, or refresh method is invoked when no transaction is active.
> For stateful session beans with extended persistence contexts:
> * The container creates an entity manager by calling EntityManagerFactory.createEntityManager when a stateful session bean is created that declares a dependency on an entity manager with PersistenceContextType.EXTENDED. (See section 7.6.3).
> * The container closes the entity manager by calling EntityManager.close after the stateful session bean and all other stateful session beans that have inherited the same persistence context as the entity manager have been removed.
> * When a business method of the stateful session bean is invoked, if the stateful session bean uses container managed transaction demarcation, and the entity manager is not already associated with the current JTA transaction, the container associates the entity manager with the current JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction. If there is a different persistence context already associated with the JTA transaction, the container throws the EJBException.
> * When a business method of the stateful session bean is invoked, if the stateful session bean uses bean managed transaction demarcation and a UserTransaction is begun within the method, the container associates the persistence context with the JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction.
> The container must throw the IllegalStateException if the application calls EntityManager.close on a container-managed entity manager.
> [87] It is not required that these contracts be used when a third-party persistence provider is not used: the container might use these same APIs or its might use its own internal APIs.
> [88] The container may choose to pool EntityManagers: it instead of creating and closing in each case, it may acquire one from its pool and call clear() on it.
> {quote}
> One challenge with introducing an entity manager (per EntityManagerFactory) cache, is knowing when to close EntityManagers after certain errors have occurred on the EntityManager:
> * In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], we can try to retrieve an entity manager from the cache (cache reference can be passed into the TransactionScopedEntityManager proxy constructor), if cache is empty, then create a new entity manager to return.
> * In https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav..., if caching is enabled, we should call EntityManager.clear(), instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any further exception thrown by the call to em.close().
> * If an entity manager is in a bad state, we shouldn't place it back in the cache. This may really be the same as the previous bullet but I wanted to mention it as a separate bullet, since we may need to add more error checking for the persistence throwing exceptions in [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...] or/and other places.
> * In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], if caching is enabled, we should call EntityManager.clear() instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any any further exception thrown by the call to em.close().
> * Lastly, we should update [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], to deal with releasing the entity manager cache before calling entityManagerFactory.close(). Since, [https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManagerFacto...] says that the entity managers will be closed automatically, we probably can just clear the cache of EntityManagers, instead of actually calling EntityManager.close() on each one in the cache.
> * Also ensure that SynchronizationType is respected, so we don't mix SynchronizationType.UNSYNCHRONIZED + SynchronizationType.SYNCHRONIZED types. Perhaps we need a cache slot for each SynchronizationType.
> EntityManager cache settings can be:
> * No cache (default)
> * ThreadLocal cache (only cached at the application thread level)
> * Per EntityManagerFactory cache (cache is shared between multiple threads, so make it thread safe), this would need to be proven to be leak free (especially with CDI beans). Cache size would be configurable.
> If EM leaks are a problem in the above, an alternative might be to only cache within JTA transactions, since we would then have control of the closing of the EntityManager.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 8 months
- 1
- 0
[JBoss JIRA] (WFLY-11233) allow EntityManager caching in the JPA container
by Scott Marlow (Jira)
[ https://issues.jboss.org/browse/WFLY-11233?page=com.atlassian.jira.plugin... ]
Scott Marlow updated WFLY-11233:
--------------------------------
Description:
It could be interesting to see if caching EntityManager instances (per EntityManagerFactory) could improve performance for applications, that could benefit from that.
The JPA 2.2 specification mentions the below, pay particular attention to the text "whether entity manager instances are sometimes reused" in section 7.8.2, also look at mention of [88]:
{quote}
7.8 Requirements on the Container
7.8.1 Application-managed Persistence Contexts
When application-managed persistence contexts are used, the container must instantiate the entity manager factory and expose it to the application via JNDI. The container might use internal APIs to create the entity manager factory, or it might use the PersistenceProvider.createContainerEntityManagerFactory method. However, the container is required to support third-party persistence providers, and in this case the container must use the PersistenceProvider.createContainerEntityManagerFactory method to create the entity manager factory and the EntityManagerFactory.close method to destroy the entity manager factory prior to shutdown (if it has not been previously closed by the application).
7.8.2 Container Managed Persistence Contexts
The container is responsible for managing the lifecycle of container-managed persistence contexts, for injecting EntityManager references into web components and session bean and message-driven bean components, and for making EntityManager references available to direct lookups in JNDI. When operating with a third-party persistence provider, the container uses the contracts defined in section 7.9 to create and destroy container-managed persistence contexts. It is undefined whether a new entity manager instance is created for every persistence context, or whether entity manager instances are sometimes reused. Exactly how the container maintains the association between persistence context and JTA transaction is not defined. If a persistence context is already associated with a JTA transaction, the container uses that persistence context for subsequent invocations within the scope of that transaction, according to the semantics for persistence context propagation defined in section 7.6.4.
7.9 Runtime Contracts between the Container and Persistence Provider
This section describes contracts between the container and the persistence provider for the pluggability of third-party persistence providers. Containers are required to support these pluggability contracts. [87]
7.9.1 Container Responsibilities
For the management of a transaction-scoped persistence context, if there is no EntityManager already associated with the JTA transaction:
* The container creates a new entity manager by calling EntityManagerFactory.createEntityManager when the first invocation of an entity manager with PersistenceContextType.TRANSACTION occurs within the scope of a business method executing in the JTA transaction.
* After the JTA transaction has completed (either by transaction commit or rollback), the container closes the entity manager by calling EntityManager.close. [88] Note that the JTA transaction may rollback in a background thread (e.g., as a result of transaction timeout), in which case the container should arrange for the entity manager to be closed but the EntityManager.close method should not be concurrently invoked while the application is in an EntityManager invocation.
The container must throw the TransactionRequiredException if a transaction-scoped persistence context is used and the EntityManager persist, remove, merge, or refresh method is invoked when no transaction is active.
For stateful session beans with extended persistence contexts:
* The container creates an entity manager by calling EntityManagerFactory.createEntityManager when a stateful session bean is created that declares a dependency on an entity manager with PersistenceContextType.EXTENDED. (See section 7.6.3).
* The container closes the entity manager by calling EntityManager.close after the stateful session bean and all other stateful session beans that have inherited the same persistence context as the entity manager have been removed.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses container managed transaction demarcation, and the entity manager is not already associated with the current JTA transaction, the container associates the entity manager with the current JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction. If there is a different persistence context already associated with the JTA transaction, the container throws the EJBException.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses bean managed transaction demarcation and a UserTransaction is begun within the method, the container associates the persistence context with the JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction.
The container must throw the IllegalStateException if the application calls EntityManager.close on a container-managed entity manager.
[87] It is not required that these contracts be used when a third-party persistence provider is not used: the container might use these same APIs or its might use its own internal APIs.
[88] The container may choose to pool EntityManagers: it instead of creating and closing in each case, it may acquire one from its pool and call clear() on it.
{quote}
One challenge with introducing an entity manager (per EntityManagerFactory) cache, is knowing when to close EntityManagers after certain errors have occurred on the EntityManager:
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], we can try to retrieve an entity manager from the cache (cache reference can be passed into the TransactionScopedEntityManager proxy constructor), if cache is empty, then create a new entity manager to return.
* In https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav..., if caching is enabled, we should call EntityManager.clear(), instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any further exception thrown by the call to em.close().
* If an entity manager is in a bad state, we shouldn't place it back in the cache. This may really be the same as the previous bullet but I wanted to mention it as a separate bullet, since we may need to add more error checking for the persistence throwing exceptions in [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...] or/and other places.
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], if caching is enabled, we should call EntityManager.clear() instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any any further exception thrown by the call to em.close().
* Lastly, we should update [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], to deal with releasing the entity manager cache before calling entityManagerFactory.close(). Since, [https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManagerFacto...] says that the entity managers will be closed automatically, we probably can just clear the cache of EntityManagers, instead of actually calling EntityManager.close() on each one in the cache.
* Also ensure that SynchronizationType is respected, so we don't mix SynchronizationType.UNSYNCHRONIZED + SynchronizationType.SYNCHRONIZED types. Perhaps we need a cache slot for each SynchronizationType.
Also, the reference to the cache of EntityManagers, will be invoked by multiple (concurrent) threads and such, the cache storage should be written to be thread safe.
EntityManager cache settings can be:
* No cache (default)
* ThreadLocal cache (only cached at the application thread level)
* Per EntityManagerFactory cache (cache is shared between multiple threads), this would need to be proven to be leak free (especially with CDI beans). Cache size would be configurable.
was:
It could be interesting to see if caching EntityManager instances (per EntityManagerFactory) could improve performance for applications, that could benefit from that.
The JPA 2.2 specification mentions the below, pay particular attention to the text "whether entity manager instances are sometimes reused" in section 7.8.2, also look at mention of [88]:
{quote}
7.8 Requirements on the Container
7.8.1 Application-managed Persistence Contexts
When application-managed persistence contexts are used, the container must instantiate the entity manager factory and expose it to the application via JNDI. The container might use internal APIs to create the entity manager factory, or it might use the PersistenceProvider.createContainerEntityManagerFactory method. However, the container is required to support third-party persistence providers, and in this case the container must use the PersistenceProvider.createContainerEntityManagerFactory method to create the entity manager factory and the EntityManagerFactory.close method to destroy the entity manager factory prior to shutdown (if it has not been previously closed by the application).
7.8.2 Container Managed Persistence Contexts
The container is responsible for managing the lifecycle of container-managed persistence contexts, for injecting EntityManager references into web components and session bean and message-driven bean components, and for making EntityManager references available to direct lookups in JNDI. When operating with a third-party persistence provider, the container uses the contracts defined in section 7.9 to create and destroy container-managed persistence contexts. It is undefined whether a new entity manager instance is created for every persistence context, or whether entity manager instances are sometimes reused. Exactly how the container maintains the association between persistence context and JTA transaction is not defined. If a persistence context is already associated with a JTA transaction, the container uses that persistence context for subsequent invocations within the scope of that transaction, according to the semantics for persistence context propagation defined in section 7.6.4.
7.9 Runtime Contracts between the Container and Persistence Provider
This section describes contracts between the container and the persistence provider for the pluggability of third-party persistence providers. Containers are required to support these pluggability contracts. [87]
7.9.1 Container Responsibilities
For the management of a transaction-scoped persistence context, if there is no EntityManager already associated with the JTA transaction:
* The container creates a new entity manager by calling EntityManagerFactory.createEntityManager when the first invocation of an entity manager with PersistenceContextType.TRANSACTION occurs within the scope of a business method executing in the JTA transaction.
* After the JTA transaction has completed (either by transaction commit or rollback), the container closes the entity manager by calling EntityManager.close. [88] Note that the JTA transaction may rollback in a background thread (e.g., as a result of transaction timeout), in which case the container should arrange for the entity manager to be closed but the EntityManager.close method should not be concurrently invoked while the application is in an EntityManager invocation.
The container must throw the TransactionRequiredException if a transaction-scoped persistence context is used and the EntityManager persist, remove, merge, or refresh method is invoked when no transaction is active.
For stateful session beans with extended persistence contexts:
* The container creates an entity manager by calling EntityManagerFactory.createEntityManager when a stateful session bean is created that declares a dependency on an entity manager with PersistenceContextType.EXTENDED. (See section 7.6.3).
* The container closes the entity manager by calling EntityManager.close after the stateful session bean and all other stateful session beans that have inherited the same persistence context as the entity manager have been removed.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses container managed transaction demarcation, and the entity manager is not already associated with the current JTA transaction, the container associates the entity manager with the current JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction. If there is a different persistence context already associated with the JTA transaction, the container throws the EJBException.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses bean managed transaction demarcation and a UserTransaction is begun within the method, the container associates the persistence context with the JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction.
The container must throw the IllegalStateException if the application calls EntityManager.close on a container-managed entity manager.
[87] It is not required that these contracts be used when a third-party persistence provider is not used: the container might use these same APIs or its might use its own internal APIs.
[88] The container may choose to pool EntityManagers: it instead of creating and closing in each case, it may acquire one from its pool and call clear() on it.
{quote}
One challenge with introducing an entity manager (per EntityManagerFactory) cache, is knowing when to close EntityManagers after certain errors have occurred on the EntityManager:
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], we can try to retrieve an entity manager from the cache (cache reference can be passed into the TransactionScopedEntityManager proxy constructor), if cache is empty, then create a new entity manager to return.
* In https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav..., if caching is enabled, we should call EntityManager.clear(), instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any further exception thrown by the call to em.close().
* If an entity manager is in a bad state, we shouldn't place it back in the cache. This may really be the same as the previous bullet but I wanted to mention it as a separate bullet, since we may need to add more error checking for the persistence throwing exceptions in [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...] or/and other places.
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], if caching is enabled, we should call EntityManager.clear() instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any any further exception thrown by the call to em.close().
* Lastly, we should update [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], to deal with releasing the entity manager cache before calling entityManagerFactory.close(). Since, [https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManagerFacto...] says that the entity managers will be closed automatically, we probably can just clear the cache of EntityManagers, instead of actually calling EntityManager.close() on each one in the cache.
Also, the reference to the cache of EntityManagers, will be invoked by multiple (concurrent) threads and such, the cache storage should be written to be thread safe.
EntityManager cache settings can be:
* No cache (default)
* ThreadLocal cache (only cached at the application thread level)
* Per EntityManagerFactory cache (cache is shared between multiple threads)
We will also want to specify the EntityManager cache size.
> allow EntityManager caching in the JPA container
> ------------------------------------------------
>
> Key: WFLY-11233
> URL: https://issues.jboss.org/browse/WFLY-11233
> Project: WildFly
> Issue Type: Enhancement
> Components: JPA / Hibernate
> Reporter: Scott Marlow
> Assignee: Scott Marlow
> Priority: Major
>
> It could be interesting to see if caching EntityManager instances (per EntityManagerFactory) could improve performance for applications, that could benefit from that.
> The JPA 2.2 specification mentions the below, pay particular attention to the text "whether entity manager instances are sometimes reused" in section 7.8.2, also look at mention of [88]:
> {quote}
> 7.8 Requirements on the Container
> 7.8.1 Application-managed Persistence Contexts
> When application-managed persistence contexts are used, the container must instantiate the entity manager factory and expose it to the application via JNDI. The container might use internal APIs to create the entity manager factory, or it might use the PersistenceProvider.createContainerEntityManagerFactory method. However, the container is required to support third-party persistence providers, and in this case the container must use the PersistenceProvider.createContainerEntityManagerFactory method to create the entity manager factory and the EntityManagerFactory.close method to destroy the entity manager factory prior to shutdown (if it has not been previously closed by the application).
> 7.8.2 Container Managed Persistence Contexts
> The container is responsible for managing the lifecycle of container-managed persistence contexts, for injecting EntityManager references into web components and session bean and message-driven bean components, and for making EntityManager references available to direct lookups in JNDI. When operating with a third-party persistence provider, the container uses the contracts defined in section 7.9 to create and destroy container-managed persistence contexts. It is undefined whether a new entity manager instance is created for every persistence context, or whether entity manager instances are sometimes reused. Exactly how the container maintains the association between persistence context and JTA transaction is not defined. If a persistence context is already associated with a JTA transaction, the container uses that persistence context for subsequent invocations within the scope of that transaction, according to the semantics for persistence context propagation defined in section 7.6.4.
> 7.9 Runtime Contracts between the Container and Persistence Provider
> This section describes contracts between the container and the persistence provider for the pluggability of third-party persistence providers. Containers are required to support these pluggability contracts. [87]
> 7.9.1 Container Responsibilities
> For the management of a transaction-scoped persistence context, if there is no EntityManager already associated with the JTA transaction:
> * The container creates a new entity manager by calling EntityManagerFactory.createEntityManager when the first invocation of an entity manager with PersistenceContextType.TRANSACTION occurs within the scope of a business method executing in the JTA transaction.
> * After the JTA transaction has completed (either by transaction commit or rollback), the container closes the entity manager by calling EntityManager.close. [88] Note that the JTA transaction may rollback in a background thread (e.g., as a result of transaction timeout), in which case the container should arrange for the entity manager to be closed but the EntityManager.close method should not be concurrently invoked while the application is in an EntityManager invocation.
> The container must throw the TransactionRequiredException if a transaction-scoped persistence context is used and the EntityManager persist, remove, merge, or refresh method is invoked when no transaction is active.
> For stateful session beans with extended persistence contexts:
> * The container creates an entity manager by calling EntityManagerFactory.createEntityManager when a stateful session bean is created that declares a dependency on an entity manager with PersistenceContextType.EXTENDED. (See section 7.6.3).
> * The container closes the entity manager by calling EntityManager.close after the stateful session bean and all other stateful session beans that have inherited the same persistence context as the entity manager have been removed.
> * When a business method of the stateful session bean is invoked, if the stateful session bean uses container managed transaction demarcation, and the entity manager is not already associated with the current JTA transaction, the container associates the entity manager with the current JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction. If there is a different persistence context already associated with the JTA transaction, the container throws the EJBException.
> * When a business method of the stateful session bean is invoked, if the stateful session bean uses bean managed transaction demarcation and a UserTransaction is begun within the method, the container associates the persistence context with the JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction.
> The container must throw the IllegalStateException if the application calls EntityManager.close on a container-managed entity manager.
> [87] It is not required that these contracts be used when a third-party persistence provider is not used: the container might use these same APIs or its might use its own internal APIs.
> [88] The container may choose to pool EntityManagers: it instead of creating and closing in each case, it may acquire one from its pool and call clear() on it.
> {quote}
> One challenge with introducing an entity manager (per EntityManagerFactory) cache, is knowing when to close EntityManagers after certain errors have occurred on the EntityManager:
> * In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], we can try to retrieve an entity manager from the cache (cache reference can be passed into the TransactionScopedEntityManager proxy constructor), if cache is empty, then create a new entity manager to return.
> * In https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav..., if caching is enabled, we should call EntityManager.clear(), instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any further exception thrown by the call to em.close().
> * If an entity manager is in a bad state, we shouldn't place it back in the cache. This may really be the same as the previous bullet but I wanted to mention it as a separate bullet, since we may need to add more error checking for the persistence throwing exceptions in [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...] or/and other places.
> * In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], if caching is enabled, we should call EntityManager.clear() instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any any further exception thrown by the call to em.close().
> * Lastly, we should update [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], to deal with releasing the entity manager cache before calling entityManagerFactory.close(). Since, [https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManagerFacto...] says that the entity managers will be closed automatically, we probably can just clear the cache of EntityManagers, instead of actually calling EntityManager.close() on each one in the cache.
> * Also ensure that SynchronizationType is respected, so we don't mix SynchronizationType.UNSYNCHRONIZED + SynchronizationType.SYNCHRONIZED types. Perhaps we need a cache slot for each SynchronizationType.
> Also, the reference to the cache of EntityManagers, will be invoked by multiple (concurrent) threads and such, the cache storage should be written to be thread safe.
> EntityManager cache settings can be:
> * No cache (default)
> * ThreadLocal cache (only cached at the application thread level)
> * Per EntityManagerFactory cache (cache is shared between multiple threads), this would need to be proven to be leak free (especially with CDI beans). Cache size would be configurable.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 8 months
- 1
- 0
[JBoss JIRA] (WFLY-11233) allow EntityManager caching in the JPA container
by Scott Marlow (Jira)
[ https://issues.jboss.org/browse/WFLY-11233?page=com.atlassian.jira.plugin... ]
Scott Marlow updated WFLY-11233:
--------------------------------
Description:
It could be interesting to see if caching EntityManager instances (per EntityManagerFactory) could improve performance for applications, that could benefit from that.
The JPA 2.2 specification mentions the below, pay particular attention to the text "whether entity manager instances are sometimes reused" in section 7.8.2, also look at mention of [88]:
{quote}
7.8 Requirements on the Container
7.8.1 Application-managed Persistence Contexts
When application-managed persistence contexts are used, the container must instantiate the entity manager factory and expose it to the application via JNDI. The container might use internal APIs to create the entity manager factory, or it might use the PersistenceProvider.createContainerEntityManagerFactory method. However, the container is required to support third-party persistence providers, and in this case the container must use the PersistenceProvider.createContainerEntityManagerFactory method to create the entity manager factory and the EntityManagerFactory.close method to destroy the entity manager factory prior to shutdown (if it has not been previously closed by the application).
7.8.2 Container Managed Persistence Contexts
The container is responsible for managing the lifecycle of container-managed persistence contexts, for injecting EntityManager references into web components and session bean and message-driven bean components, and for making EntityManager references available to direct lookups in JNDI. When operating with a third-party persistence provider, the container uses the contracts defined in section 7.9 to create and destroy container-managed persistence contexts. It is undefined whether a new entity manager instance is created for every persistence context, or whether entity manager instances are sometimes reused. Exactly how the container maintains the association between persistence context and JTA transaction is not defined. If a persistence context is already associated with a JTA transaction, the container uses that persistence context for subsequent invocations within the scope of that transaction, according to the semantics for persistence context propagation defined in section 7.6.4.
7.9 Runtime Contracts between the Container and Persistence Provider
This section describes contracts between the container and the persistence provider for the pluggability of third-party persistence providers. Containers are required to support these pluggability contracts. [87]
7.9.1 Container Responsibilities
For the management of a transaction-scoped persistence context, if there is no EntityManager already associated with the JTA transaction:
* The container creates a new entity manager by calling EntityManagerFactory.createEntityManager when the first invocation of an entity manager with PersistenceContextType.TRANSACTION occurs within the scope of a business method executing in the JTA transaction.
* After the JTA transaction has completed (either by transaction commit or rollback), the container closes the entity manager by calling EntityManager.close. [88] Note that the JTA transaction may rollback in a background thread (e.g., as a result of transaction timeout), in which case the container should arrange for the entity manager to be closed but the EntityManager.close method should not be concurrently invoked while the application is in an EntityManager invocation.
The container must throw the TransactionRequiredException if a transaction-scoped persistence context is used and the EntityManager persist, remove, merge, or refresh method is invoked when no transaction is active.
For stateful session beans with extended persistence contexts:
* The container creates an entity manager by calling EntityManagerFactory.createEntityManager when a stateful session bean is created that declares a dependency on an entity manager with PersistenceContextType.EXTENDED. (See section 7.6.3).
* The container closes the entity manager by calling EntityManager.close after the stateful session bean and all other stateful session beans that have inherited the same persistence context as the entity manager have been removed.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses container managed transaction demarcation, and the entity manager is not already associated with the current JTA transaction, the container associates the entity manager with the current JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction. If there is a different persistence context already associated with the JTA transaction, the container throws the EJBException.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses bean managed transaction demarcation and a UserTransaction is begun within the method, the container associates the persistence context with the JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction.
The container must throw the IllegalStateException if the application calls EntityManager.close on a container-managed entity manager.
[87] It is not required that these contracts be used when a third-party persistence provider is not used: the container might use these same APIs or its might use its own internal APIs.
[88] The container may choose to pool EntityManagers: it instead of creating and closing in each case, it may acquire one from its pool and call clear() on it.
{quote}
One challenge with introducing an entity manager (per EntityManagerFactory) cache, is knowing when to close EntityManagers after certain errors have occurred on the EntityManager:
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], we can try to retrieve an entity manager from the cache (cache reference can be passed into the TransactionScopedEntityManager proxy constructor), if cache is empty, then create a new entity manager to return.
* In https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav..., if caching is enabled, we should call EntityManager.clear(), instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any further exception thrown by the call to em.close().
* If an entity manager is in a bad state, we shouldn't place it back in the cache. This may really be the same as the previous bullet but I wanted to mention it as a separate bullet, since we may need to add more error checking for the persistence throwing exceptions in [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...] or/and other places.
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], if caching is enabled, we should call EntityManager.clear() instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any any further exception thrown by the call to em.close().
* Lastly, we should update [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], to deal with releasing the entity manager cache before calling entityManagerFactory.close(). Since, [https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManagerFacto...] says that the entity managers will be closed automatically, we probably can just clear the cache of EntityManagers, instead of actually calling EntityManager.close() on each one in the cache.
* Also ensure that SynchronizationType is respected, so we don't mix SynchronizationType.UNSYNCHRONIZED + SynchronizationType.SYNCHRONIZED types. Perhaps we need a cache slot for each SynchronizationType.
EntityManager cache settings can be:
* No cache (default)
* ThreadLocal cache (only cached at the application thread level)
* Per EntityManagerFactory cache (cache is shared between multiple threads, so make it thread safe), this would need to be proven to be leak free (especially with CDI beans). Cache size would be configurable.
was:
It could be interesting to see if caching EntityManager instances (per EntityManagerFactory) could improve performance for applications, that could benefit from that.
The JPA 2.2 specification mentions the below, pay particular attention to the text "whether entity manager instances are sometimes reused" in section 7.8.2, also look at mention of [88]:
{quote}
7.8 Requirements on the Container
7.8.1 Application-managed Persistence Contexts
When application-managed persistence contexts are used, the container must instantiate the entity manager factory and expose it to the application via JNDI. The container might use internal APIs to create the entity manager factory, or it might use the PersistenceProvider.createContainerEntityManagerFactory method. However, the container is required to support third-party persistence providers, and in this case the container must use the PersistenceProvider.createContainerEntityManagerFactory method to create the entity manager factory and the EntityManagerFactory.close method to destroy the entity manager factory prior to shutdown (if it has not been previously closed by the application).
7.8.2 Container Managed Persistence Contexts
The container is responsible for managing the lifecycle of container-managed persistence contexts, for injecting EntityManager references into web components and session bean and message-driven bean components, and for making EntityManager references available to direct lookups in JNDI. When operating with a third-party persistence provider, the container uses the contracts defined in section 7.9 to create and destroy container-managed persistence contexts. It is undefined whether a new entity manager instance is created for every persistence context, or whether entity manager instances are sometimes reused. Exactly how the container maintains the association between persistence context and JTA transaction is not defined. If a persistence context is already associated with a JTA transaction, the container uses that persistence context for subsequent invocations within the scope of that transaction, according to the semantics for persistence context propagation defined in section 7.6.4.
7.9 Runtime Contracts between the Container and Persistence Provider
This section describes contracts between the container and the persistence provider for the pluggability of third-party persistence providers. Containers are required to support these pluggability contracts. [87]
7.9.1 Container Responsibilities
For the management of a transaction-scoped persistence context, if there is no EntityManager already associated with the JTA transaction:
* The container creates a new entity manager by calling EntityManagerFactory.createEntityManager when the first invocation of an entity manager with PersistenceContextType.TRANSACTION occurs within the scope of a business method executing in the JTA transaction.
* After the JTA transaction has completed (either by transaction commit or rollback), the container closes the entity manager by calling EntityManager.close. [88] Note that the JTA transaction may rollback in a background thread (e.g., as a result of transaction timeout), in which case the container should arrange for the entity manager to be closed but the EntityManager.close method should not be concurrently invoked while the application is in an EntityManager invocation.
The container must throw the TransactionRequiredException if a transaction-scoped persistence context is used and the EntityManager persist, remove, merge, or refresh method is invoked when no transaction is active.
For stateful session beans with extended persistence contexts:
* The container creates an entity manager by calling EntityManagerFactory.createEntityManager when a stateful session bean is created that declares a dependency on an entity manager with PersistenceContextType.EXTENDED. (See section 7.6.3).
* The container closes the entity manager by calling EntityManager.close after the stateful session bean and all other stateful session beans that have inherited the same persistence context as the entity manager have been removed.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses container managed transaction demarcation, and the entity manager is not already associated with the current JTA transaction, the container associates the entity manager with the current JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction. If there is a different persistence context already associated with the JTA transaction, the container throws the EJBException.
* When a business method of the stateful session bean is invoked, if the stateful session bean uses bean managed transaction demarcation and a UserTransaction is begun within the method, the container associates the persistence context with the JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction.
The container must throw the IllegalStateException if the application calls EntityManager.close on a container-managed entity manager.
[87] It is not required that these contracts be used when a third-party persistence provider is not used: the container might use these same APIs or its might use its own internal APIs.
[88] The container may choose to pool EntityManagers: it instead of creating and closing in each case, it may acquire one from its pool and call clear() on it.
{quote}
One challenge with introducing an entity manager (per EntityManagerFactory) cache, is knowing when to close EntityManagers after certain errors have occurred on the EntityManager:
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], we can try to retrieve an entity manager from the cache (cache reference can be passed into the TransactionScopedEntityManager proxy constructor), if cache is empty, then create a new entity manager to return.
* In https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav..., if caching is enabled, we should call EntityManager.clear(), instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any further exception thrown by the call to em.close().
* If an entity manager is in a bad state, we shouldn't place it back in the cache. This may really be the same as the previous bullet but I wanted to mention it as a separate bullet, since we may need to add more error checking for the persistence throwing exceptions in [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...] or/and other places.
* In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], if caching is enabled, we should call EntityManager.clear() instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any any further exception thrown by the call to em.close().
* Lastly, we should update [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], to deal with releasing the entity manager cache before calling entityManagerFactory.close(). Since, [https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManagerFacto...] says that the entity managers will be closed automatically, we probably can just clear the cache of EntityManagers, instead of actually calling EntityManager.close() on each one in the cache.
* Also ensure that SynchronizationType is respected, so we don't mix SynchronizationType.UNSYNCHRONIZED + SynchronizationType.SYNCHRONIZED types. Perhaps we need a cache slot for each SynchronizationType.
Also, the reference to the cache of EntityManagers, will be invoked by multiple (concurrent) threads and such, the cache storage should be written to be thread safe.
EntityManager cache settings can be:
* No cache (default)
* ThreadLocal cache (only cached at the application thread level)
* Per EntityManagerFactory cache (cache is shared between multiple threads), this would need to be proven to be leak free (especially with CDI beans). Cache size would be configurable.
> allow EntityManager caching in the JPA container
> ------------------------------------------------
>
> Key: WFLY-11233
> URL: https://issues.jboss.org/browse/WFLY-11233
> Project: WildFly
> Issue Type: Enhancement
> Components: JPA / Hibernate
> Reporter: Scott Marlow
> Assignee: Scott Marlow
> Priority: Major
>
> It could be interesting to see if caching EntityManager instances (per EntityManagerFactory) could improve performance for applications, that could benefit from that.
> The JPA 2.2 specification mentions the below, pay particular attention to the text "whether entity manager instances are sometimes reused" in section 7.8.2, also look at mention of [88]:
> {quote}
> 7.8 Requirements on the Container
> 7.8.1 Application-managed Persistence Contexts
> When application-managed persistence contexts are used, the container must instantiate the entity manager factory and expose it to the application via JNDI. The container might use internal APIs to create the entity manager factory, or it might use the PersistenceProvider.createContainerEntityManagerFactory method. However, the container is required to support third-party persistence providers, and in this case the container must use the PersistenceProvider.createContainerEntityManagerFactory method to create the entity manager factory and the EntityManagerFactory.close method to destroy the entity manager factory prior to shutdown (if it has not been previously closed by the application).
> 7.8.2 Container Managed Persistence Contexts
> The container is responsible for managing the lifecycle of container-managed persistence contexts, for injecting EntityManager references into web components and session bean and message-driven bean components, and for making EntityManager references available to direct lookups in JNDI. When operating with a third-party persistence provider, the container uses the contracts defined in section 7.9 to create and destroy container-managed persistence contexts. It is undefined whether a new entity manager instance is created for every persistence context, or whether entity manager instances are sometimes reused. Exactly how the container maintains the association between persistence context and JTA transaction is not defined. If a persistence context is already associated with a JTA transaction, the container uses that persistence context for subsequent invocations within the scope of that transaction, according to the semantics for persistence context propagation defined in section 7.6.4.
> 7.9 Runtime Contracts between the Container and Persistence Provider
> This section describes contracts between the container and the persistence provider for the pluggability of third-party persistence providers. Containers are required to support these pluggability contracts. [87]
> 7.9.1 Container Responsibilities
> For the management of a transaction-scoped persistence context, if there is no EntityManager already associated with the JTA transaction:
> * The container creates a new entity manager by calling EntityManagerFactory.createEntityManager when the first invocation of an entity manager with PersistenceContextType.TRANSACTION occurs within the scope of a business method executing in the JTA transaction.
> * After the JTA transaction has completed (either by transaction commit or rollback), the container closes the entity manager by calling EntityManager.close. [88] Note that the JTA transaction may rollback in a background thread (e.g., as a result of transaction timeout), in which case the container should arrange for the entity manager to be closed but the EntityManager.close method should not be concurrently invoked while the application is in an EntityManager invocation.
> The container must throw the TransactionRequiredException if a transaction-scoped persistence context is used and the EntityManager persist, remove, merge, or refresh method is invoked when no transaction is active.
> For stateful session beans with extended persistence contexts:
> * The container creates an entity manager by calling EntityManagerFactory.createEntityManager when a stateful session bean is created that declares a dependency on an entity manager with PersistenceContextType.EXTENDED. (See section 7.6.3).
> * The container closes the entity manager by calling EntityManager.close after the stateful session bean and all other stateful session beans that have inherited the same persistence context as the entity manager have been removed.
> * When a business method of the stateful session bean is invoked, if the stateful session bean uses container managed transaction demarcation, and the entity manager is not already associated with the current JTA transaction, the container associates the entity manager with the current JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction. If there is a different persistence context already associated with the JTA transaction, the container throws the EJBException.
> * When a business method of the stateful session bean is invoked, if the stateful session bean uses bean managed transaction demarcation and a UserTransaction is begun within the method, the container associates the persistence context with the JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction.
> The container must throw the IllegalStateException if the application calls EntityManager.close on a container-managed entity manager.
> [87] It is not required that these contracts be used when a third-party persistence provider is not used: the container might use these same APIs or its might use its own internal APIs.
> [88] The container may choose to pool EntityManagers: it instead of creating and closing in each case, it may acquire one from its pool and call clear() on it.
> {quote}
> One challenge with introducing an entity manager (per EntityManagerFactory) cache, is knowing when to close EntityManagers after certain errors have occurred on the EntityManager:
> * In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], we can try to retrieve an entity manager from the cache (cache reference can be passed into the TransactionScopedEntityManager proxy constructor), if cache is empty, then create a new entity manager to return.
> * In https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav..., if caching is enabled, we should call EntityManager.clear(), instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any further exception thrown by the call to em.close().
> * If an entity manager is in a bad state, we shouldn't place it back in the cache. This may really be the same as the previous bullet but I wanted to mention it as a separate bullet, since we may need to add more error checking for the persistence throwing exceptions in [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...] or/and other places.
> * In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], if caching is enabled, we should call EntityManager.clear() instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any any further exception thrown by the call to em.close().
> * Lastly, we should update [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], to deal with releasing the entity manager cache before calling entityManagerFactory.close(). Since, [https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManagerFacto...] says that the entity managers will be closed automatically, we probably can just clear the cache of EntityManagers, instead of actually calling EntityManager.close() on each one in the cache.
> * Also ensure that SynchronizationType is respected, so we don't mix SynchronizationType.UNSYNCHRONIZED + SynchronizationType.SYNCHRONIZED types. Perhaps we need a cache slot for each SynchronizationType.
> EntityManager cache settings can be:
> * No cache (default)
> * ThreadLocal cache (only cached at the application thread level)
> * Per EntityManagerFactory cache (cache is shared between multiple threads, so make it thread safe), this would need to be proven to be leak free (especially with CDI beans). Cache size would be configurable.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 8 months
- 1
- 0
[JBoss JIRA] (WFLY-11233) allow EntityManager caching in the JPA container
by Scott Marlow (Jira)
[ https://issues.jboss.org/browse/WFLY-11233?page=com.atlassian.jira.plugin... ]
Scott Marlow reassigned WFLY-11233:
-----------------------------------
Assignee: Scott Marlow
> allow EntityManager caching in the JPA container
> ------------------------------------------------
>
> Key: WFLY-11233
> URL: https://issues.jboss.org/browse/WFLY-11233
> Project: WildFly
> Issue Type: Enhancement
> Components: JPA / Hibernate
> Reporter: Scott Marlow
> Assignee: Scott Marlow
> Priority: Major
>
> It could be interesting to see if caching EntityManager instances (per EntityManagerFactory) could improve performance for applications, that could benefit from that.
> The JPA 2.2 specification mentions the below, pay particular attention to the text "whether entity manager instances are sometimes reused" in section 7.8.2, also look at mention of [88]:
> {quote}
> 7.8 Requirements on the Container
> 7.8.1 Application-managed Persistence Contexts
> When application-managed persistence contexts are used, the container must instantiate the entity manager factory and expose it to the application via JNDI. The container might use internal APIs to create the entity manager factory, or it might use the PersistenceProvider.createContainerEntityManagerFactory method. However, the container is required to support third-party persistence providers, and in this case the container must use the PersistenceProvider.createContainerEntityManagerFactory method to create the entity manager factory and the EntityManagerFactory.close method to destroy the entity manager factory prior to shutdown (if it has not been previously closed by the application).
> 7.8.2 Container Managed Persistence Contexts
> The container is responsible for managing the lifecycle of container-managed persistence contexts, for injecting EntityManager references into web components and session bean and message-driven bean components, and for making EntityManager references available to direct lookups in JNDI. When operating with a third-party persistence provider, the container uses the contracts defined in section 7.9 to create and destroy container-managed persistence contexts. It is undefined whether a new entity manager instance is created for every persistence context, or whether entity manager instances are sometimes reused. Exactly how the container maintains the association between persistence context and JTA transaction is not defined. If a persistence context is already associated with a JTA transaction, the container uses that persistence context for subsequent invocations within the scope of that transaction, according to the semantics for persistence context propagation defined in section 7.6.4.
> 7.9 Runtime Contracts between the Container and Persistence Provider
> This section describes contracts between the container and the persistence provider for the pluggability of third-party persistence providers. Containers are required to support these pluggability contracts. [87]
> 7.9.1 Container Responsibilities
> For the management of a transaction-scoped persistence context, if there is no EntityManager already associated with the JTA transaction:
> * The container creates a new entity manager by calling EntityManagerFactory.createEntityManager when the first invocation of an entity manager with PersistenceContextType.TRANSACTION occurs within the scope of a business method executing in the JTA transaction.
> * After the JTA transaction has completed (either by transaction commit or rollback), the container closes the entity manager by calling EntityManager.close. [88] Note that the JTA transaction may rollback in a background thread (e.g., as a result of transaction timeout), in which case the container should arrange for the entity manager to be closed but the EntityManager.close method should not be concurrently invoked while the application is in an EntityManager invocation.
> The container must throw the TransactionRequiredException if a transaction-scoped persistence context is used and the EntityManager persist, remove, merge, or refresh method is invoked when no transaction is active.
> For stateful session beans with extended persistence contexts:
> * The container creates an entity manager by calling EntityManagerFactory.createEntityManager when a stateful session bean is created that declares a dependency on an entity manager with PersistenceContextType.EXTENDED. (See section 7.6.3).
> * The container closes the entity manager by calling EntityManager.close after the stateful session bean and all other stateful session beans that have inherited the same persistence context as the entity manager have been removed.
> * When a business method of the stateful session bean is invoked, if the stateful session bean uses container managed transaction demarcation, and the entity manager is not already associated with the current JTA transaction, the container associates the entity manager with the current JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction. If there is a different persistence context already associated with the JTA transaction, the container throws the EJBException.
> * When a business method of the stateful session bean is invoked, if the stateful session bean uses bean managed transaction demarcation and a UserTransaction is begun within the method, the container associates the persistence context with the JTA transaction and, if the persistence context is of type SynchronizationType.SYNCHRONIZED, the container calls EntityManager.joinTransaction.
> The container must throw the IllegalStateException if the application calls EntityManager.close on a container-managed entity manager.
> [87] It is not required that these contracts be used when a third-party persistence provider is not used: the container might use these same APIs or its might use its own internal APIs.
> [88] The container may choose to pool EntityManagers: it instead of creating and closing in each case, it may acquire one from its pool and call clear() on it.
> {quote}
> One challenge with introducing an entity manager (per EntityManagerFactory) cache, is knowing when to close EntityManagers after certain errors have occurred on the EntityManager:
> * In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], we can try to retrieve an entity manager from the cache (cache reference can be passed into the TransactionScopedEntityManager proxy constructor), if cache is empty, then create a new entity manager to return.
> * In https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav..., if caching is enabled, we should call EntityManager.clear(), instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any further exception thrown by the call to em.close().
> * If an entity manager is in a bad state, we shouldn't place it back in the cache. This may really be the same as the previous bullet but I wanted to mention it as a separate bullet, since we may need to add more error checking for the persistence throwing exceptions in [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...] or/and other places.
> * In [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], if caching is enabled, we should call EntityManager.clear() instead of EntityManager.close(), however, if an exception is thrown (on call to em.clear()), the entity manager shouldn't be put in the cache, instead we can try to close it and log/ignore any any further exception thrown by the call to em.close().
> * Lastly, we should update [https://github.com/wildfly/wildfly/blob/master/jpa/subsystem/src/main/jav...], to deal with releasing the entity manager cache before calling entityManagerFactory.close(). Since, [https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManagerFacto...] says that the entity managers will be closed automatically, we probably can just clear the cache of EntityManagers, instead of actually calling EntityManager.close() on each one in the cache.
> Also, the reference to the cache of EntityManagers, will be invoked by multiple (concurrent) threads and such, the cache storage should be written to be thread safe.
> EntityManager cache settings can be:
> * No cache (default)
> * ThreadLocal cache (only cached at the application thread level)
> * Per EntityManagerFactory cache (cache is shared between multiple threads)
> We will also want to specify the EntityManager cache size.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 8 months
- 1
- 0
[JBoss JIRA] (DROOLS-3169) [DMN Designer] Last Context Entry differentiation
by Edson Tirelli (Jira)
[ https://issues.jboss.org/browse/DROOLS-3169?page=com.atlassian.jira.plugi... ]
Edson Tirelli commented on DROOLS-3169:
---------------------------------------
[~manstis] , the ideal solution is to do what is described in the standard: the result row should not have a label and be simply a literal expression cell:
!Screenshot 2018-10-23 18.37.56.png|thumbnail!
Please note that the result row is optional.
> [DMN Designer] Last Context Entry differentiation
> -------------------------------------------------
>
> Key: DROOLS-3169
> URL: https://issues.jboss.org/browse/DROOLS-3169
> Project: Drools
> Issue Type: Enhancement
> Components: DMN Editor
> Affects Versions: 7.14.0.Final
> Reporter: Jozef Marko
> Assignee: Michael Anstis
> Priority: Major
> Labels: drools-tools
> Attachments: Screenshot 2018-10-23 18.37.56.png, Screenshot from 2018-10-22 17-35-07.png
>
>
> The last Context Entry, shown in the attachment, should be differentiated to other Context Entries. Currently we differentiate it just by the Name *Default* that user can not change.
> We should improve this in one of the following ways:
> - Keep name *Default*, change font to italics and use grey background color
> - Merge the *Default* and *Value* cells of last entry and remove the name *Default*
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 8 months
- 1
- 0
[JBoss JIRA] (DROOLS-3169) [DMN Designer] Last Context Entry differentiation
by Edson Tirelli (Jira)
[ https://issues.jboss.org/browse/DROOLS-3169?page=com.atlassian.jira.plugi... ]
Edson Tirelli updated DROOLS-3169:
----------------------------------
Attachment: Screenshot 2018-10-23 18.37.56.png
> [DMN Designer] Last Context Entry differentiation
> -------------------------------------------------
>
> Key: DROOLS-3169
> URL: https://issues.jboss.org/browse/DROOLS-3169
> Project: Drools
> Issue Type: Enhancement
> Components: DMN Editor
> Affects Versions: 7.14.0.Final
> Reporter: Jozef Marko
> Assignee: Michael Anstis
> Priority: Major
> Labels: drools-tools
> Attachments: Screenshot 2018-10-23 18.37.56.png, Screenshot from 2018-10-22 17-35-07.png
>
>
> The last Context Entry, shown in the attachment, should be differentiated to other Context Entries. Currently we differentiate it just by the Name *Default* that user can not change.
> We should improve this in one of the following ways:
> - Keep name *Default*, change font to italics and use grey background color
> - Merge the *Default* and *Value* cells of last entry and remove the name *Default*
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 8 months
- 1
- 0
[JBoss JIRA] (DROOLS-3177) Move to public API RegistryContext
by Daniele Zonca (Jira)
Daniele Zonca created DROOLS-3177:
-------------------------------------
Summary: Move to public API RegistryContext
Key: DROOLS-3177
URL: https://issues.jboss.org/browse/DROOLS-3177
Project: Drools
Issue Type: Enhancement
Components: Scenario Simulation and Testing
Reporter: Daniele Zonca
Assignee: Daniele Zonca
RegistryContext interface is inside drools-core but should be moved to public to be able to use it for custom commands
Remove drools-core dependency from scenario simulation backend module after that
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (DROOLS-3156) Explore using a full screen view instead of a dialog.
by Liz Clayton (Jira)
[ https://issues.jboss.org/browse/DROOLS-3156?page=com.atlassian.jira.plugi... ]
Liz Clayton commented on DROOLS-3156:
-------------------------------------
[~manstis]Thanks!
> Explore using a full screen view instead of a dialog.
> ------------------------------------------------------
>
> Key: DROOLS-3156
> URL: https://issues.jboss.org/browse/DROOLS-3156
> Project: Drools
> Issue Type: Sub-task
> Reporter: Liz Clayton
> Assignee: Liz Clayton
> Priority: Major
> Attachments: Move.png, full-screen.png
>
>
> * Porting the list in the dialog view to a full screen would better support editing Advanced options such as Data type restrictions.
> * A lot of other editors have a "Data Object" tab (to import classes from other packages); so DMN having a "Data Types" tab would offer some degree of consistency.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (DROOLS-3156) Explore using a full screen view instead of a dialog.
by Michael Anstis (Jira)
[ https://issues.jboss.org/browse/DROOLS-3156?page=com.atlassian.jira.plugi... ]
Michael Anstis commented on DROOLS-3156:
----------------------------------------
Hi [~uxdlc], as discussed on Slack, decision table constraints will be a property of the decision table and not something _baked_ into the Type definition.
> Explore using a full screen view instead of a dialog.
> ------------------------------------------------------
>
> Key: DROOLS-3156
> URL: https://issues.jboss.org/browse/DROOLS-3156
> Project: Drools
> Issue Type: Sub-task
> Reporter: Liz Clayton
> Assignee: Liz Clayton
> Priority: Major
> Attachments: Move.png, full-screen.png
>
>
> * Porting the list in the dialog view to a full screen would better support editing Advanced options such as Data type restrictions.
> * A lot of other editors have a "Data Object" tab (to import classes from other packages); so DMN having a "Data Types" tab would offer some degree of consistency.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (SWSQE-456) Adjust Workload tests to KIALI-1284
by Hayk Hovsepyan (Jira)
[ https://issues.jboss.org/browse/SWSQE-456?page=com.atlassian.jira.plugin.... ]
Hayk Hovsepyan commented on SWSQE-456:
--------------------------------------
https://github.com/Kiali-QE/kiali-qe-python/pull/88
> Adjust Workload tests to KIALI-1284
> -----------------------------------
>
> Key: SWSQE-456
> URL: https://issues.jboss.org/browse/SWSQE-456
> Project: Kiali QE
> Issue Type: QE Task
> Reporter: Hayk Hovsepyan
> Assignee: Hayk Hovsepyan
> Priority: Major
>
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0