Working with objects in Java

Printer Quick Response Code in Java Working with objects

Manual detachment of entity instances An entity instance becomes detached when it leaves the persistence context. A method on the EntityManager allows you to clear the persistence context and detach all persistent instances:

EntityManager em = emf.createEntityManager(); EntityTransaction tx = em.getTransaction(); tx.begin(); Item item = em.find(Item.class, new Long(1234)); em.clear(); item.setDescription(...); // Detached entity instance! tx.commit(); em.close();

After the item is retrieved, you clear the persistence context of the EntityManager. All entity instances that have been managed by that persistence context are now detached. The modification of the detached instance isn t synchronized with the database during commit.

Where is eviction of individual instances The Hibernate Session API features the evict(object) method. Java Persistence doesn t have this capability. The reason is probably only known by some expert group members we can t explain it. (Note that this is a nice way of saying that experts couldn t agree on the semantics of the operation.) You can only clear the persistence context completely and detach all persistent objects. You have to fall back to the Session API as described in chapter 2, section 2.2.4, Switching to Hibernate interfaces, if you want to evict individual instances from the persistence context.

Obviously you also want to save any modifications you made to a detached entity instance at some point. Merging detached entity instances Whereas Hibernate offers two strategies, reattachment and merging, to synchronize any changes of detached objects with the database, Java Persistence only offers the latter. Let s assume you ve retrieved an item entity instance in a previous persistence context, and now you want to modify it and save these modifications.

EntityManager em = emf.createEntityManager(); EntityTransaction tx = em.getTransaction(); tx.begin(); Item item = em.find(Item.class, new Long(1234));

tx.commit(); em.close(); item.setDescription(...); // Detached entity instance! EntityManager em2 = emf.createEntityManager(); EntityTransaction tx2 = em2.getTransaction(); tx2.begin(); Item mergedItem = (Item) em2.merge(item); tx2.commit(); em2.close();

The item is retrieved in a first persistence context and merged, after modification in detached state, into a new persistence context. The merge() operation does several things: First, the Java Persistence engine checks whether a persistent instance in the persistence context has the same database identifier as the detached instance you re merging. Because, in our code examples, there is no equal persistent instance in the second persistence context, one is retrieved from the database through lookup by identifier. Then, the detached entity instance is copied onto the persistent instance. In other words, the new description that has been set on the detached item is also set on the persistent mergedItem, which is returned from the merge() operation. If there is no equal persistent instance in the persistence context, and a lookup by identifier in the database is negative, the merged instance is copied onto a fresh persistent instance, which is then inserted into the database when the second persistence context is synchronized with the database. Merging of state is an alternative to reattachment (as provided by native Hibernate). Refer to our earlier discussion of merging with Hibernate in section 9.3.2, Merging the state of a detached object ; both APIs offer the same semantics, and the notes there apply for JPA mutatis mutandis. You re now ready to expand your Java SE application and experiment with the persistence context and detached objects in Java Persistence. Instead of only storing and loading entity instances in a single unit of work, try to use several and try to merge modifications of detached objects. Don t forget to watch your SQL log to see what s going on behind the scenes. Once you ve mastered basic Java Persistence operations with Java SE, you ll probably want to do the same in a managed environment. The benefits you get from JPA in a full EJB 3.0 container are substantial. No longer do you have to manage EntityManager and EntityTransaction yourself. You can focus on what you re supposed to do: load and store objects.