MZs Notes - Pg 159

[Niranjan Deshpande]

I was reading the section

Identify correct and incorrect statements or examples about application-managed
persistence contexts. - [EJB_3.0_PERSISTENCE] 5.7; 5.7.1.1; 5.7.1.2; 5.7.1.3; 5.7.1.4 - PDF Page 159

After the text, there are three four sample codes.

I was trying to figure out what those samples explain, in context of the relevant text?
Can any one help me please.

[Devaka Cooray]

Howdy Niranjan,

I would like to kindly suggest you to feel kind to post the exact code here which makes you confused; so that we can help you quickly.

[Niranjan Deshpande]

Hi Devaka,

Here are those listings -

*********************************************************************************************************
                                                                                     Example 1
*********************************************************************************************************
/*
* Container-managed transaction demarcation is used.
* Session bean creates and closes an entity manager in
* each business method.
*/
@Stateless
public class ShoppingCartImpl implements ShoppingCart {
@PersistenceUnit
private EntityManagerFactory emf;
public Order getOrder(Long id) {
EntityManager em = emf.createEntityManager();
Order order = (Order)em.find(Order.class, id);
em.close();
return order;
}
public Product getProduct() {
EntityManager em = emf.createEntityManager();
Product product = (Product) em.createQuery("select p from Product p where p.name = :name")
.setParameter("name", name)
.getSingleResult();
em.close();
return product;
}
public LineItem createLineItem(Order order, Product product, int quantity) {
EntityManager em = emf.createEntityManager();
LineItem li = new LineItem(order, product, quantity);
order.getLineItems().add(li);
em.persist(li);
em.close();
return li; // remains managed until JTA transaction ends
}
}

/*
* Container-managed transaction demarcation is used.
* Session bean creates entity manager in PostConstruct
* method and clears persistence context at the end of each
* business method.
*/
@Stateless
public class ShoppingCartImpl implements ShoppingCart {
@PersistenceUnit
private EntityManagerFactory emf;
private EntityManager em;
@PostConstruct
public void init()
em = emf.createEntityManager();
}
public Order getOrder(Long id) {
Order order = (Order)em.find(Order.class, id);
em.clear(); // entities are detached
return order;
}
public Product getProduct() {
Product product = (Product) em.createQuery("select p from Product p where p.name = :name")
.setParameter("name", name)
.getSingleResult();
em.clear();
return product;
}
public LineItem createLineItem(Order order, Product product, int quantity) {
em.joinTransaction();
LineItem li = new LineItem(order, product, quantity);
order.getLineItems().add(li);
em.persist(li);
// persistence context is flushed to database;
// all updates will be committed to database on tx commit
em.flush();
// entities in persistence context are detached
em.clear();
return li;
}
@PreDestroy
public void destroy()
em.close();
}
}

*********************************************************************************************************
                                                                                     Example 3
*********************************************************************************************************
//Container-managed transaction demarcation is used
@Stateful
public class ShoppingCartImpl implements ShoppingCart {
@PersistenceUnit
private EntityManagerFactory emf;
private EntityManager em;
private Order order;
private Product product;
@PostConstruct
public void init() {
em = emf.createEntityManager();
}
public void initOrder(Long id) {
order = em.find(Order.class, id);
}
public void initProduct(String name) {
product = (Product) em.createQuery("select p from Product p where p.name = :name")
.setParameter("name", name)
.getSingleResult();
}
public LineItem createLineItem(int quantity) {
em.joinTransaction();
LineItem li = new LineItem(order, product, quantity);
order.getLineItems().add(li);
return li;
}
@Remove
public void destroy() {
em.close();
}
}

*********************************************************************************************************
                                                                                     Example 4
*********************************************************************************************************
Example of application-managed Persistence Context with Resource Transaction
// Usage in an ordinary Java class
public class ShoppingCart {
private EntityManager em;
private EntityManagerFactory emf;
public ShoppingCart() {
emf = Persistence.createEntityManagerFactory("orderMgt");
em = emf.createEntityManager();
}
private Order order;
private Product product;
public void initOrder(Long id) {
order = em.find(Order.class, id);
}
public void initProduct(String name) {
product = (Product) em.createQuery("select p from Product p where p.name = :name")
.setParameter("name", name)
.getSingleResult();
}
public LineItem createLineItem(int quantity) {
em.getTransaction().begin();
LineItem li = new LineItem(order, product, quantity);
order.getLineItems().add(li);
em.getTransaction().commit();
return li;
}
public void destroy() {
em.close();
emf.close();
}
}

[Charles O'Leary]

Hi All, Any takers?

[Frits Walraven]

Hi Charles,

This is a question related to the SCBCD5 exam (EE5) and is more or less about JPA. In the EE5-version of the EJB exam JPA is included, whereas in the EE6 version JPA has its own certification.

Please also note that EJB Certification (EE5) is related to JPA 1.0 and JPA Cerification (EE6) is related to JPA 2.0.

Apart from that what were your thoughts about this question?

[Charles O'Leary]

Hi,

Are there better and/or more comments for these 4 examples for (EE5) exam prep?

For example, one thing I think I possibly need take away from these examples is that persistence context is separate from how the entity manager processes underlying transactions, also illustrated by the 2nd and 3rd examples with em.joinTransaction(). It appears that although all these examples are application-managed persistence context, clearly 3 are container managed (JTA) transactions, while the other is resource local transaction. Is that appropriate? Are there better and/or more appropriate comments?


The last example "Example of application-managed Persistence Context with Resource Transaction" has a interesting title for folks that may want to incorrectly think in terms of persistence context "defining" transaction processing?