about second stateful bean with a different Tx context than the first stateful bean

[Himai Minh]

In 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 created an example base on the book:

@Stateful
public class EmployeeService {
    @PersistenceContext(unitName="EmployeeService", type=PersistenceContextType.EXTENDED)
    private EntityManager em;
    @EJB
    AuditService audit;

  ...
    public void createEmployee2(Employee emp) {
        em.persist(emp);
        audit.logTransaction2(emp.getId(), "created employee");
    }

@Stateful
public class AuditService {
    @PersistenceContext(unitName="EmployeeService", type=PersistenceContextType.EXTENDED)
    private EntityManager em;
    
    public void logTransaction(int empId, String action) {
        
        if (em.find(Employee.class, empId) == null) {
            throw new IllegalArgumentException("Unknown employee id");
        }
        LogRecord lr = new LogRecord(empId, action);
        em.persist(lr);
    }
    
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
   
    public void logTransaction2(int empId, String action) {
        logTransaction(empId, action);
    }

But when I tried this example, logTransaction2 is running in a different transaction than createEmployee2 , but it still works. I am not sure why.
The quote says the second stateful bean with extended pc running in a different transaction will get an exception.

[Frits Walraven]

But when I tried this example, logTransaction2 is running in a different transaction than createEmployee2 , but it still works. I am not sure why.
The quote says the second stateful bean with extended pc running in a different transaction will get an exception.

To make this work you should have two different clients each of them starting transaction (by calling a method) on the stateful session bean and then invoke the method that will invoke the other bean:

CL1 -> SFSB1.method1() in Transaction T1 with extended PersistenceContext1
CL2 -> SFSB2.method2() in Transaction T2 with extended PersistenceContext2

CL1 -> SFSB1.method3() which will invoke SFSB2.method4()

As soon as the SFSB2.method4() is called you will have the persistence context clash and receive an EJBException.

[Himai Minh]

Hi, Frits. To demo what you described in the previous post:

@Stateful
public class AuditService {
     //This persistence context uses a different unit name to make sure it is different from the persistence context in EmployeeService bean
    //If the unitName is also  "EmployeeService", it will be the same persistence context as EmployeeService. Then method3 will not throw any exception.
    @PersistenceContext(unitName="EmployeeService1", type=PersistenceContextType.EXTENDED)
    private EntityManager em;
  
   
    public void method2(){
    	System.out.println("Audit service: do nothing in method2");
    }
    
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void method4(int empId){
    	Employee foundEmployee = em.find(Employee.class, empId);
    	if ( foundEmployee == null) {
            throw new IllegalArgumentException("Unknown employee id in method 4.");
        }
    	else{
    		 System.out.println("Audit service also found employee id "+ foundEmployee.getId());
    	}
    }
    @Remove
    public void finish(){ System.out.println("Audit Service bean is to be removed.");}
}

@Stateful
public class EmployeeService {
    @PersistenceContext(unitName="EmployeeService", type=PersistenceContextType.EXTENDED)
    private EntityManager em;
    @EJB
    AuditService audit;
    public void method1(){
    	 System.out.println("Employee service bean : Do nothing in method 1");
    }
    public void method3(int empId){
    	Employee createdEmployee = new Employee();
    	createdEmployee.setId(empId);
    	createdEmployee.setName("Just_Joined_member");
    	createdEmployee.setSalary(0);
    	 em.persist(createdEmployee);
    	System.out.println("Employee service bean calls audit service bean:");
    	 //call method4 inside method3
    	audit.method4(createdEmployee.getId());
    }
    @Remove
    public void finish(){ System.out.println("Employee Service bean is to be removed.");}
}

@WebServlet(name="EmployeeServlet", 
            urlPatterns="/EmployeeServlet")
@EJB(name="ejb/EmployeeService", beanInterface=EmployeeService.class)
public class EmployeeServiceServlet extends HttpServlet {
 
   
    EmployeeService service;
    public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        printHtmlHeader(out);
        
         service = (EmployeeService) request.getSession().getAttribute("EmployeeService");
        if (service == null) {
            try {
                service = (EmployeeService)
                    new InitialContext().lookup("java:comp/env/ejb/EmployeeService");
                request.getSession().setAttribute("EmployeeService", service);
                System.out.println("Looked up service...");
            } catch (Exception e) {
            	System.out.println("Service bean not found.");
                throw new ServletException(e);
            }
        }
        // This servlet client calls method 1 in transaction 1
        service.method1();
        
      
       //add employee id = 200 to the persistence context
        else if (action.equals("call audit")){
        	 service.method3(200);
        }
      ...    
    }
    ...
    private void printHtmlHeader(PrintWriter out) throws IOException {
        out.println("<body>");
        out.println("<html>");
        out.println("<head><title>" + TITLE + "</title></head>");
        out.println("<center><h1>" + TITLE + "</h1></center>");
        out.println("<p>" + DESCRIPTION + "</p>");
        out.println("<hr/>");
        out.println("<form action=\"EmployeeServlet\" method=\"POST\">");
        // form to create
        out.println("<h3>Create an Employee</h3>");
        out.println("<table><tbody>");
        out.println("<tr><td>Id:</td><td><input type=\"text\" name=\"createId\"/>(int)</td></tr>");
        out.println("<tr><td>Name:</td><td><input type=\"text\" name=\"name\"/>(String)</td></tr>");
        out.println("<tr><td>Salary:</td><td><input type=\"text\" name=\"salary\"/>(long)</td>" +
                    "<td><input name=\"action\" type=\"submit\" value=\"Create\"/></td>" +
                    "<td><input name=\"action\" type=\"submit\" value=\"Create2\"/></td>" +
                    "<td><input name=\"action\" type=\"submit\" value=\"call audit\"</td></tr>");
        
        out.println("</tbody></table>");
        out.println("<hr/>");
    }
     ...
}

@WebServlet(name="AuditServlet", 
urlPatterns="/AuditServlet")
@EJB(name="ejb/AuditService", beanInterface=AuditService.class)
public class AuditServiceServlet extends HttpServlet {
	 AuditService service;
	    public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	        response.setContentType("text/html");
	     
	         service = (AuditService) request.getSession().getAttribute("AuditService");
	        if (service == null) {
	            try {
	                service = (AuditService)
	                    new InitialContext().lookup("java:comp/env/ejb/AuditService");
	                request.getSession().setAttribute("EmployeeService", service);
	                System.out.println("Looked up  audit service...");
	            } catch (Exception e) {
	            	System.out.println("Audit Service bean not found.");
	                throw new ServletException(e);
	            }
	        }

                  //This servlet client calls method2 in transaction 2
	         service.method2();   
	    }
	 ...
	    
}

<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
	<persistence-unit name="EmployeeService">
	    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
	    <jta-data-source>jdbc/txScopedPersistenceContext</jta-data-source>
        <class>examples.model.Employee</class>
        <properties>
           <property name ="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
	        <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/txScopedPersistenceContext"/>
	        <property name="javax.persistence.jdbc.user" value="root" />
	        <property name="javax.persistence.jdbc.password" value="sesame"/>
	    </properties>
  </persistence-unit>
  <persistence-unit name="EmployeeService1">
	    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
	    <jta-data-source>jdbc/txScopedPersistenceContext</jta-data-source>
        <class>examples.model.Employee</class>
        <properties>
           <property name ="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
	        <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/txScopedPersistenceContext"/>
	        <property name="javax.persistence.jdbc.user" value="root" />
	        <property name="javax.persistence.jdbc.password" value="sesame"/>
	    </properties>
  </persistence-unit>
</persistence>

I first call the method 1 by calling the servlet (client 1)  :http://localhost:8080/txScopedPersistenceContext/EmployeeServlet
Then, I call the method 2 by calling the second servlet (client2):http://localhost:8080/txScopedPersistenceContext/AuditServlet
Next, I click on the call audit button as shown in the diagram.
But what I get is EJB exception, not IllegalStateException as described:

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.

[Himai Minh]

One more trial is that I remove the REQUIRES_NEW transaction attribute in method4 of audit service bean, I got a EJBTransactionRollbackException from method 4.
But it is still not a illegalStateException. I guess the document that I mentioned in the previous post is specific to JBoss.

//Inside audit bean
 //comment out this attribute, so that method 4 runs in the same transaction as method 3 of employee service bean
// @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void method4(int empId){
    	Employee foundEmployee = em.find(Employee.class, empId);
    	if ( foundEmployee == null) {
            throw new IllegalArgumentException("Unknown employee id in method 4.");
        }
    	else{
    		 System.out.println("Audit service also found employee id "+ foundEmployee.getId());
    	}
    }

[Frits Walraven]

Interesting...

I would have expected an EJBException in your last setup or did method4() throw a IllegalArgumentException ? If that is the case then the outcome is correct because the client (EmployeeService) runs under the same transaction as the bean (AuditService) and a RuntimeException (= System Exception) is thrown from the latter. The RuntimeException is turned into ab EJBTransactionRollbackException by the container (check my EJB notes example 6.4).


This is what the specs say about the Persistence Context Propagation

7.6.3.1 Requirements for Persistence Context Propagation
...
If a component is called and the JTA transaction is propagated into that component:

If the component is a stateful session bean to which an extended persistence context has been bound and there is a different persistence context bound to the JTA transaction, an EJBException is thrown by the container.

According to the specs the extended PersistenceContext is created as soon as the Stateful Session Bean is created, but maybe JBoss pospones that until the first method is called on the EntityManager (like in a non-extended PersistenceContext). Try to persist an Entity in both method1 and method2 and see what happens.

[Himai Minh]

Hi, Frits.
I modified the code:

@Stateful
public class EmployeeService {
    @PersistenceContext(unitName="EmployeeService", type=PersistenceContextType.EXTENDED)
    private EntityManager em;
    @EJB
    AuditService audit;
 ...
    
    public void method1(int empId){
    	System.out.println("Employee service: add employee 100");
    	if ( em.find(Employee.class, empId) == null){
    	Employee createdEmployee = new Employee();
    	createdEmployee.setId(empId);
    	createdEmployee.setName("Just_Joined_in_m1");
    	createdEmployee.setSalary(0);
    	em.persist(createdEmployee);
    	}
    }
    public void method3(int empId){
    	Employee createdEmployee = new Employee();
    	createdEmployee.setId(empId);
    	createdEmployee.setName("Just_Joined_member_in_m3");
    	createdEmployee.setSalary(0);
    	 em.persist(createdEmployee);
    	 System.out.println("Employee service bean asks audit service bean to find employee 300 created in m3:");
         audit.method4(createdEmployee.getId());
         System.out.println("Employee service bean asks audit service bean to find employee 100 created in m1:");
         audit.method4(100);
         System.out.println("Employee service bean asks audit service bean to find employee 200 created in m2:");
         audit.method4(200);
    }
    @Remove
    public void finish(){ System.out.println("Employee Service bean is to be removed.");}
}

@Stateful
public class AuditService {
    @PersistenceContext(unitName="EmployeeService1", type=PersistenceContextType.EXTENDED)
    private EntityManager em;
    
   ...
    public void method2(int empId){
    	System.out.println("Audit service: add employee 200");
    	if (em.find(Employee.class, empId) == null){
    	Employee createdEmployee = new Employee();
    	createdEmployee.setId(empId);
    	createdEmployee.setName("Just_Joined_in_m2");
    	createdEmployee.setSalary(0);
    	em.persist(createdEmployee);
    	}
    }
    
 
    public void method4(int empId){
    	Employee foundEmployee = em.find(Employee.class, empId);
    	if ( foundEmployee == null) {
            throw new IllegalArgumentException("Unknown employee id in method 4.");
        }
    	else{
    		 System.out.println("Audit service also found employee id "+ foundEmployee.getId());
    	}
    }
    @Remove
    public void finish(){ System.out.println("Audit Service bean is to be removed.");}
}

Client 1  calls the employee servlet that persists employee 100.
Client 2 calls the audit serlvet that persists employee 200.

public class EmployeeServiceServlet extends HttpServlet {

    private final String TITLE = 
        "Chapter 6: Tx-scoped Persistence Context Example";
    
    private final String DESCRIPTION = 
        "This example shows the basic use of a tx-scoped persistence " +
        "context. The second create button shows what happens (an exception) when the " +
        "'logTransaction' operation is marked REQUIRES_NEW";

   // @EJB EmployeeService service;
    EmployeeService service;
    public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        printHtmlHeader(out);
        
         service = (EmployeeService) request.getSession().getAttribute("EmployeeService");
        if (service == null) {
            try {
                service = (EmployeeService)
                    new InitialContext().lookup("java:comp/env/ejb/EmployeeService");
                request.getSession().setAttribute("EmployeeService", service);
                System.out.println("Looked up service...");
            } catch (Exception e) {
            	System.out.println("Service bean not found.");
                throw new ServletException(e);
            }
        }
        //start a transaction by adding employee id =100
        service.method1(100);
        
        // process request
        String action = request.getParameter("action");
        if (action == null) {
            // do nothing if no action requested
        ....
        }
        else if (action.equals("call audit")){
        	//add employee 300
        	 service.method3(300);
        }
      ... 
    }

public class AuditServiceServlet extends HttpServlet {
	 AuditService service;
	    public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	        response.setContentType("text/html");
	     
	         service = (AuditService) request.getSession().getAttribute("AuditService");
	        if (service == null) {
	            try {
	                service = (AuditService)
	                    new InitialContext().lookup("java:comp/env/ejb/AuditService");
	                request.getSession().setAttribute("EmployeeService", service);
	                System.out.println("Looked up  audit service...");
	            } catch (Exception e) {
	            	System.out.println("Audit Service bean not found.");
	                throw new ServletException(e);
	            }
	        }
	         //start a transaction by creating an employee id =200
	         service.method2(200);   
	    }

It throws EJBTransactionRollback exception when method3 calls method4 and employee 300 is not persisted as the transaction is rolled back.
It is because audit bean throws the illegal argument exception saying employee 300 is not found. Why audit bean cannot find employee 300 ?
It is because the persistence context from employee service bean cannot propagate to audit service bean. Audit bean is  using a different pc.

Employee service: add employee 100
2017-03-22T21:14:08.863-0400|Info: Looked up  audit service...
2017-03-22T21:14:08.863-0400|Info: Audit service: add employee 200
2017-03-22T21:14:13.071-0400|Info: Employee service: add employee 100
2017-03-22T21:14:13.071-0400|Info: Employee service bean asks audit service bean to find employee 300 created in m3:
2017-03-22T21:14:13.080-0400|Warning: A system exception occurred during an invocation on EJB AuditService, method: public void examples.stateless.AuditService.method4(int)
2017-03-22T21:14:13.080-0400|Warning: javax.ejb.TransactionRolledbackLocalException: Exception thrown from bean
at com.sun.ejb.containers.EJBContainerTransactionManager.checkExceptionClientTx(EJBContainerTransactionManager.java:662)
 ...
at examples.stateless.__EJB31_Generated__AuditService__Intf____Bean__.method4(Unknown Source)
at examples.stateless.EmployeeService.method3(EmployeeService.java:55)
...
Caused by: java.lang.IllegalArgumentException: Unknown employee id in method 4.
at examples.stateless.AuditService.method4(AuditService.java:56)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

[Himai Minh]

One more modification:

@Stateful
public class AuditService {
     //I changed unitName "EmployeeService1" into "EmployeeService". So, the pc of Audit Service bean will be the same as the pc of employee Service bean
    @PersistenceContext(unitName="EmployeeService", type=PersistenceContextType.EXTENDED)
    private EntityManager em;
     ...

Employee service: add employee 100
2017-03-22T21:31:12.636-0400|Info: Looked up  audit service...
2017-03-22T21:31:12.638-0400|Info: Audit service: add employee 200
2017-03-22T21:31:16.864-0400|Info: Employee service: add employee 100
2017-03-22T21:31:16.864-0400|Info: Employee service bean asks audit service bean to find employee 300 created in m3:
2017-03-22T21:31:16.880-0400|Info: Audit service also found employee id 300
2017-03-22T21:31:16.880-0400|Info: Employee service bean asks audit service bean to find employee 100 created in m1:
2017-03-22T21:31:16.880-0400|Info: Audit service also found employee id 100
2017-03-22T21:31:16.880-0400|Info: Employee service bean asks audit service bean to find employee 200 created in m2:
2017-03-22T21:31:16.880-0400|Info: Audit service also found employee id 200

The employee service bean persists employee 300. Then, the audit bean can find this employee 300.  
The pc of employee service bean propagates to the audit bean.
Audit bean can find employee 100 because it has been in the DB already.

[Himai Minh]

I made one more modification to the audit bean:

//Let method4 starts a new transaction which is different from method3 from employee bean:
@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void method4(int empId){
    	Employee foundEmployee = em.find(Employee.class, empId);
    	if ( foundEmployee == null) {
            throw new IllegalArgumentException("Unknown employee id in method 4.");
        }
    	else{
    		 System.out.println("Audit service also found employee id "+ foundEmployee.getId());
    	}
    }

To my surprise, it works:

Employee service: add employee 100
2017-03-22T21:36:52.546-0400|Info: Looked up  audit service...
2017-03-22T21:36:52.546-0400|Info: Audit service: add employee 200
2017-03-22T21:36:56.637-0400|Info: Employee service: add employee 100
2017-03-22T21:36:56.637-0400|Info: Employee service bean asks audit service bean to find employee 300 created in m3:
2017-03-22T21:36:56.637-0400|Info: Audit service also found employee id 300
2017-03-22T21:36:56.637-0400|Info: Employee service bean asks audit service bean to find employee 100 created in m1:
2017-03-22T21:36:56.637-0400|Info: Audit service also found employee id 100
2017-03-22T21:36:56.637-0400|Info: Employee service bean asks audit service bean to find employee 200 created in m2:
2017-03-22T21:36:56.637-0400|Info: Audit service also found employee id 200

But the document says this:
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.

By the way, the document is from JBoss Hibernate, not from JSR 317.
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