Need assistance in understanding JPA ManyToMany code example (Java EE 5)

[Jack Bush]

Hi All,

I would value your expertise on explaining how this JPA ManyToMany code (chapter 5) example below from Java EE 5 with Netbeans 6 book:

@Entity
 01 @Table(name = "CUSTOMER", catalog = "", schema = "APP")
 02 public class Customer implements Serializable {
 03     @Id
 04     @Basic(optional = false)
 05     @Column(name = "CUSTOMER_ID", nullable = false)
 06     @OneToMany(mappedBy = "customer")
 07     private Collection<CustomerOrder> customerOrderCollection;
 08     @OneToMany(mappedBy = "customer")
 09 
 10     public Customer(Integer customerId) {
 11         this.customerId = customerId;
 12     }
 13     ………..   
 14     public Collection<CustomerOrder> getCustomerOrderCollection() {
 15         return customerOrderCollection;
 16     }
 17 
 18     public void setCustomerOrderCollection(Collection<CustomerOrder> customerOrderCollection) {
 19         this.customerOrderCollection = customerOrderCollection;
 20     }
 21 }

 01 @Entity
 02 @Table(name = "CUSTOMER_ORDER", catalog = "", schema = "APP")
 03 public class CustomerOrder implements Serializable {
 04     @Id
 05     @Basic(optional = false)
 06     @Column(name = "CUSTOMER_ORDER_ID", nullable = false)
 07     private Integer customerOrderId;
 08    @ManyToMany
 09     @JoinTable(name = "ORDER_ITEM", joinColumns = {@JoinColumn(name = "CUSTOMER_ORDER_ID", referencedColumnName = "CUSTOMER_ORDER_ID")}, inverseJoinColumns = {@JoinColumn(name = "ITEM_ID", referencedColumnName = "ITEM_ID")})
 10     private Collection<Item> itemCollection;
 11     @ManyToOne
 12     @JoinColumn(name = "CUSTOMER_ID", referencedColumnName = "CUSTOMER_ID")
 13     private Customer customer;
 14     public CustomerOrder(Integer customerOrderId) {
 15         this.customerOrderId = customerOrderId;
 16     }
 17      ………
 18     public void setCustomerOrderId(Integer customerOrderId) {
 19         this.customerOrderId = customerOrderId;
 20     }
 21 
 22     public Collection<Item> getItemCollection() {
 23         return itemCollection;
 24     }
 25 
 26     public void setItemCollection(Collection<Item> itemCollection) {
 27         this.itemCollection = itemCollection;
 28     }
 29 
 30     public Customer getCustomer() {
 31         return customer;
 32     }
 33 
 34     public void setCustomer(Customer customer) {
 35         this.customer = customer;
 36     }
 37 }

 01 @Entity
 02 @Table(name = "ITEM", catalog = "", schema = "APP")
 03 public class Item implements Serializable {
 04     private static final long serialVersionUID = 1L;
 05     @Id
 06     @Basic(optional = false)
 07     @Column(name = "ITEM_ID", nullable = false)
 08     private Integer itemId;
 09     @ManyToMany(mappedBy = "itemCollection")
 10     private Collection<CustomerOrder> customerOrderCollection;
 11 
 12     public Item(Integer itemId) {
 13         this.itemId = itemId;
 14     }
 15      …….
 16     public Collection<CustomerOrder> getCustomerOrderCollection() {
 17         return customerOrderCollection;
 18     }
 19 
 20     public void setCustomerOrderCollection(Collection<CustomerOrder> customerOrderCollection) {
 21         this.customerOrderCollection = customerOrderCollection;
 22     }
 23 }

 01 public class CustomerOrderJpaController {
 02     @Resource
 03     private UserTransaction utx = null;
 04     @PersistenceUnit(unitName = "jsfjpacrudPU")
 05     private EntityManagerFactory emf = null;
 06 
 07     public EntityManager getEntityManager() {
 08         return emf.createEntityManager();
 09     }
 10 
 11     public void create(CustomerOrder customerOrder) throws PreexistingEntityException, RollbackFailureException, Exception {
 12         if (customerOrder.getItemCollection() == null) {
 13             customerOrder.setItemCollection(new ArrayList<Item>());
 14         }
 15         EntityManager em = null;
 16         try {
 17             utx.begin();
 18             em = getEntityManager();
 19             Customer customer = customerOrder.getCustomer();
 20             if (customer != null) {
 21                 customer = em.getReference(customer.getClass(), customer.getCustomerId());
 22                 customerOrder.setCustomer(customer);
 23             }
 24             Collection<Item> attachedItemCollection = new ArrayList<Item>();
 25             for (Item itemCollectionItemToAttach : customerOrder.getItemCollection()) {
 26                 itemCollectionItemToAttach = em.getReference(itemCollectionItemToAttach.getClass(), itemCollectionItemToAttach.getItemId());
 27                 attachedItemCollection.add(itemCollectionItemToAttach);
 28             }
 29             customerOrder.setItemCollection(attachedItemCollection);
 30             em.persist(customerOrder);
 31             if (customer != null) {
 32                 customer.getCustomerOrderCollection().add(customerOrder);
 33                 customer = em.merge(customer);
 34             }
 35             for (Item itemCollectionItem : customerOrder.getItemCollection()) {
 36                 itemCollectionItem.getCustomerOrderCollection().add(customerOrder);
 37                 itemCollectionItem = em.merge(itemCollectionItem);
 38             }
 39             utx.commit();
 40             ……..
 41         } finally {
 42             if (em != null) {
 43                 em.close();
 44             }
 45         }
 46     }

What I am not clear about is the following area in create() of CustomerOrderJpaController where there appears to be a lot of re-assigning of entity data back to itself:
( i ) Why is there a need to locate the customer entity with em.getReference() on line 21 when the value has already been found on line 19 (ManyToOne with CustomerOrder owning)?
( ii ) What is the purpose of lines 25 – 27 and especially why is variable itemCollectionItemToAttach being re-assigned to all items found in itself (line 26)? Is it assembling a list of new items to be included into this customerOrder entity object? (ManyToMany – CustomerOrder owning)
( iii ) Why not use em.find() instead of em.getReference()? I thought em.find() is better because it returns NULL when there are no record found and it doesn’t throw an exception?

I am running JDK 1.6.0_23, NB6.9.1, GF 2.1 (Java EE 5) on Windows XP.

Your feedback would be much appreciated to enlightening in this key yet complex technology.

Thanks in advance,

Jack

[James Sutherland]

The issues is that the CustomerOrder is a detached object (serialzied possibly). So in order to persist it in the current persistence context its references must be fixed to reference their objects from the current persistence context.

In theory they could just do,

customerOrder = em.merge(customerOrder);

As merge should fix everything up. But perhaps they ran into an issue with merge, or wanted to use persist for some reason.

As to using getReference() instead of find(), they already know the object exists so getReference() can be more efficient as it can just return a stub (of coarse they then access the reference, so it would need to be instantiated anyway).

[Jack Bush]

Hi James,

Thank you very much for filling in the puzzle and enlighten me with how JPA work. You appear to be providing consistent support in this forum in the recent years.

The one liner em.merge(customerOrder) is tempting but must admit that past experiences have resulted in duplicate records being added. So this approach is a long winded way of using em.persist() but will be more reliable instead.

Btw, my intention is to persist Item record through CustomerOrderJpaController.create(). In other word, only uni-directional ManyToMany entity relationship between CustomerOrder & Item is required in this case. Yet the used of mappedBy (line 9 of Item class) as a constraint, to keep both CustomerOrder & Item (foreign keys in CUSTOMERORDER_ITEM) records unique. Moreover, the bi-directional entities setup was not meant to allow persisting from both CustomerOrderJpaController & ItemJpaController but only to keep both sides of data normalized. Can you comment on whether this is the right approach? If not, please suggest an alternative approach to achieve the same objective.

Thanks again,

Jack