About persistence context inheritance and transaction context

[Himai Minh]

According to this document :https://access.redhat.com/documentation/en-US/JBoss_Enterprise_Application_Platform/4.2/html/Hibernate_EntityManager_User_Guide/sect-Hibernate_EntityManager_User_Guide-EJB_container_environment-Persistence_context_propagation.html

If a stateful session bean with an extended persistence context instantiates another stateful session bean with an extended persistence context, the extended persistence context is inherited by the second stateful session bean. If the second stateful session bean is called with a different transaction context than the first, an IllegalStateException is thrown

I ran the chapter 6 example , persistenceContextInheritance:

@Stateful
@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
public class DepartmentManager {
    @PersistenceContext(unitName="EmployeeService",
                       type=PersistenceContextType.EXTENDED)
    EntityManager em;
    Department dept;
    @EJB AuditService audit;
    @EJB EmployeeManager manager;

    public void init(int deptId) {
        dept = em.find(Department.class, deptId);
        manager.init(dept.getId());
    }

@Stateful
@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
public class EmployeeManager {
    @PersistenceContext(unitName="EmployeeService",
                        type=PersistenceContextType.EXTENDED)
    EntityManager em;

    //The pc is inherited from the DepartmentManager. But this method is running in a different transaction than its calling method.
    public void init(int deptId) {
    	Department dept = em.find(Department.class,deptId);
    	if (dept == null){
    	   System.out.println("Department is not found in employee manager");
    	}
    	else{
    		System.out.println("Department "+ deptId +" is found by the employee manager");
    	}
    }
    
    @Remove
    public void finished() {
    }
}

Based on the quote, it should not work because the init() of EmployeeManager is in a new transaction context due to the REQUIRES_NEW.
But it works.

[Himai Minh]

In my opinion, the 7.6.3.1 Requirements for pc propagation does not say too much detail about when a pc should be propagation or should not when a pc is inherited from the calling bean.

Let's say stateful Bean A has method1.
stateful Bean B (inherits A's pc)  has method2.
Bean A injects Bean A and  method1 calls method2.
What if  method2's transaction is a new transaction ?
The JSR 317 does not say if the the inherited PC  should be run in the parent's PC; otherwise an exception must be thrown.

[Frits Walraven]

What if  method2's transaction is a new transaction ?  

From the same spec section, let me try to write it a little bit different:

If a component is called and there is

no JTA transaction or

the JTA transaction is not propagated,

then the persistence context is not propagated.

So in your example "What if  method2's transaction is a new transaction ?" the JTA transaction is not propagated (REQUIRES_NEW will suspend the active JTA transaction and the container will start a new JTA transaction) which means that the persistence context is also not propagated.

[Himai Minh]

Hi, I tried to modify the chapter 6's persistenceContextInheritance example,

@Stateful
@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
public class DepartmentManager {
    @PersistenceContext(unitName="EmployeeService",
                       type=PersistenceContextType.EXTENDED)
    EntityManager em;
    Department dept;
    @EJB AuditService audit;
    @EJB EmployeeManager manager;

    public void init(int deptId) {
        dept = em.find(Department.class, deptId);
        Employee emp99= new Employee();
        emp99.setId(99);
        emp99.setDepartment(dept);
        em.persist(emp99);
        manager.init(dept.getId());
    }
    

@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
public class EmployeeManager {
    @PersistenceContext(unitName="EmployeeService",
                        type=PersistenceContextType.EXTENDED)
    EntityManager em;

    public void init(int deptId) {
    	Department dept = em.find(Department.class,deptId);
    	Employee emp99 = em.find(Employee.class, 99);
    	if (emp99==null){
    		 System.out.println("Employee 99 is not found.");
    	}
    	else{
    		System.out.println("Employee 99 is found.");
    	}
    	if (dept == null){
    	   System.out.println("Department is not found in employee manager");
    	}
    	else{
    		System.out.println("Department "+ deptId +" is found by the employee manager");
    	}
    }

The employee manager starts a new transaction, but it still inherits the persistence context from department manager even though employee manager uses a new JTA transaction.
It prints "Employee 99 is found."
I guess the employee 99 has already persisted in the DB before the department manager finishes the transaction it init() method.

[Himai Minh]

This time, I use BMT instead of CMT.
Assume there is no employee 99 in the DB

@Stateful 
@TransactionManagement(TransactionManagementType.BEAN)
public class DepartmentManager {
    @PersistenceContext(unitName="EmployeeService",
                       type=PersistenceContextType.EXTENDED)
    EntityManager em;
    Department dept;
    @EJB AuditService audit;
    @EJB EmployeeManager manager;
    @Resource SessionContext context;
    public void init(int deptId) {
        dept = em.find(Department.class, deptId);
        try{
           context.getUserTransaction().begin();
           Employee emp99= new Employee();
           emp99.setId(99);
           emp99.setDepartment(dept);
           em.persist(emp99);
           manager.init(dept.getId());
        }
        catch(Exception e){
        	throw new EJBException (e);
        }
    }

@Stateful
@TransactionManagement(TransactionManagementType.BEAN)
public class EmployeeManager {
    @PersistenceContext(unitName="EmployeeService",
                        type=PersistenceContextType.EXTENDED)
    EntityManager em;
    @Resource SessionContext context;
    public void init(int deptId) {
    	Department dept = em.find(Department.class,deptId);
    	try{
    		context.getUserTransaction().begin();
    	   Employee emp99 = em.find(Employee.class, 99);
    	   if (emp99==null){
    		 System.out.println("Employee 99 is not found.");
    	   }
    	    else{
    		System.out.println("Employee 99 is found.");
    	   }
    	}
    	catch (Exception e){
    		throw new EJBException(e);
    	}
    	if (dept == null){
    	   System.out.println("Department is not found in employee manager");
    	}
    	else{
    		System.out.println("Department "+ deptId +" is found by the employee manager");
    	}
    }
    

The department manager persists employee 99, but has not committed yet. Then, it calls the employee manager, which can find employee 99 from the entity manager.
The DB still does not have employee 99 in the table.
To my surprise, employee manager uses a different JTA transaction. But it can inherit the persistence context from the JTA transaction of department manager.

[Himai Minh]

Another example for reference and comparison.
I use stateless bean with persistence type=transaction. Obviously, the persistence context is not propagated from one stateless bean to another.

@Stateless
@TransactionManagement(TransactionManagementType.BEAN)
public class DepartmentManager {
    @PersistenceContext(unitName="EmployeeService",
                       type=PersistenceContextType.TRANSACTION)
    EntityManager em;
    Department dept;
    @EJB AuditService audit;
    @EJB EmployeeManager manager;
    @Resource SessionContext context;
    public void init(int deptId) {
        dept = em.find(Department.class, deptId);
        try{
          context.getUserTransaction().begin();
           Employee emp99= new Employee();
           emp99.setId(99);
           emp99.setDepartment(dept);
           em.persist(emp99);
           manager.init(dept.getId());
           context.getUserTransaction().commit();
       }
      catch(Exception e){
        	throw new EJBException (e);
        }
    }

@Stateless
 @TransactionManagement(TransactionManagementType.BEAN)
public class EmployeeManager {
    @PersistenceContext(unitName="EmployeeService",
                        type=PersistenceContextType.TRANSACTION)
    EntityManager em;
    @Resource SessionContext context;
    public void init(int deptId) {
    	Department dept = em.find(Department.class,deptId);
    	try{
    		context.getUserTransaction().begin();
    	   Employee emp99 = em.find(Employee.class, 99);
    	   if (emp99==null){
    		 System.out.println("Employee 99 is not found.");
    	   }
    	    else{
    		System.out.println("Employee 99 is found.");
    	   }
    	   context.getUserTransaction().commit();
    	}
    	catch (Exception e){
    		throw new EJBException(e);
    	}
    	if (dept == null){
    	   System.out.println("Department is not found in employee manager");
    	}
    	else{
    		System.out.println("Department "+ deptId +" is found by the employee manager");
    	}
    }
    

Output: employee 99 is not found.

[Frits Walraven]

To my surprise, employee manager uses a different JTA transaction. But it can inherit the persistence context from the JTA transaction of department manager.

hmmm, interesting but I see what is happening: there is an exception for Stateful Session beans:

7.6.2.1 Inheritance of Extended Persistence Context
If a stateful session bean instantiates a stateful session bean (executing in the same EJB container instance) which also has such an extended persistence context, the extended persistence context of the first stateful session bean is inherited by the second stateful session bean and bound to it, and this rule recursively applies—independently of whether transactions are active or not at the point of the creation of the stateful session beans.