5/2/2017. The entity manager. The entity manager. Entities lifecycle and manipulation

Size: px

Start display at page:

Download "5/2/2017. The entity manager. The entity manager. Entities lifecycle and manipulation"

Beverley Crawford
5 years ago
Views:

1 Entities lifecycle and manipulation Software Architectures and Methodologies - JPA: Entities lifecycle and manipulation Dipartimento di Ingegneria dell'informazione Laboratorio Tecnologie del Software Università di Firenze enrico.vicario@unifi.it, JPA static perspective about how data have to be moved back and forth between database tables and objects state specified through mapping metadata annotations (or files) JPA dynamic perspective about when data have to be moved during the runtime about the lifecycle of objects i.e. how and when an object becomes persistent, or stops to be considered persistent controlled through method calls and other actions that trigger these transitions 1 The Entity Manager the bridge between the OO and relational sides manages the lifecycle of entities the EntityManager quietly tries to keep entities synched with the database automatically as long as they are persistent (or attached ) i.e. within the reach of the Entity Manager the EntityManager also provides SQL-like CRUD operations with querying syntax created to work with entity objects 2 3

2 EntityManager an Interface in the package javax.persistence along with EntityManagerFactory, Query, EntityManager main methods persist(), gettransaction(), merge(), refresh() find(), createquery(), clear(), close() control the state of Entities along a persistence lifecycle persistence lifecycle the set of states and state transitions with respect to persistence management unit of work a set of operations in the application that may affect persistent instances persistence context a cache that memorizes all the modifications and state changes made to objects during a unit of work more details follow 4 5 persist() saves (persists) an entity into the database Make an instance managed and persistent public void persist(object anentity); persist() must be in the scope of a transaction EntityManager em = emfactory.createentitymanager();... em.gettransaction().begin(); em.persist(anentity); em.gettransaction().commit(); 6 gettransaction() retrieves a transaction object can be used to manually begin and commit a transaction throws an exception if the transaction is not locally managed (e.g. it is managed by a JTA Entity Manager) public EntityTransaction gettransaction(); 7

3 about the lifecycle of entity objects an object created with new is Transient persist() changes the object state to Persistent also known as attached if the entity was already persistent, throws an exception find() finds an entity instance by its primary key returns the entity, or null if the entity does not exists public <T> T find(class<t> anentityclass, Object primarykey); the retrieved entity is in the persistent (attached) state 8 9 createquery() creates a query using a JPQL statement (see later the syntax of JPQL queries) Entities retrieved through the execution of a Query are set in the Persistent state public Query createquery(string querydefinition); the returned Query can then be executed with getresultlist() or getsingleresult() methods which return a List or a single retrieved entity 10 11

4 remove() removes the entity instance from the database requires to be in the scope of a transaction the entity is moved into the removed state scheduled to be deleted at the end of a unit of work public void remove(object anentity); Persistence context close() Set of objects under reach of the EntityManager (more later) closes an application-managed entity manager public void close(); clear() clears the persistence context, causing all persistent entities to become detached changes to entities that have not been synchronized to the database will not be persisted public void clear(); 14 EntityManager em = emfactory.createentitymanager();... em.gettransaction().begin(); em.persist(anentity); em.gettransaction().commit(); em.close(); 15

5 merge() and refresh() both operations synchronize the state of an entity with the database in opposite directions merge() writes the entity state to the database and returns a persistent entity refresh() writes the state of the database to the entity, overwriting changes merge() writes the state of an entity onto the database returns the persistent instance whose state was merged requires to be in the scope of a transaction refresh() refreshes the state of an Entity with values from the database overwrites changes made to the entity, if any requires to be in the scope of a transaction public void refresh(object anentity); public <T> T merge(t anentity); 18 19

6 The Persistence Lifecycle merge() and refresh() make the entity state Persistent JPA is a transparent persistence mechanism classes are unaware of their own persistence capability the application logic is unaware of whether the state of objects it operates on is persisted or it temporarily exists only in memory the application does not need to concern itself with the state of an object in the persistence lifecycle Yet, the state in the persistence lifecycle is relevant determines the application impact on the database 4 states: Transient, Persistent, Detached, Removed the final picture The Persistence Lifecycle Transient Objects objects created through the new operator are initially in the transient state they are not associated with any database table row their state is lost when they are ready for garbage collection (i.e. they are no longer referenced by any other object) a transient entity can become persistent through explicit invokation of entitymanager.persist() or when it is referenced by an instance in persistent state in both cases, the entity becomes persistent at the end of the transaction 22 23

7 The Persistence Lifecycle Persistent Objects a persistent instance has a database identity may be an object instantiated with new by the application and then made persistent or it may be an instance retrieved from the database by a query or a find operation, or by navigating the object graph from another persistent instance (see later) persistent instances are associated with a persistence context see later Persistent Objects Persistent Objects an example an example The Note object has just been created, so it s Transient 26 27

8 Persistent Objects Persistent Objects an example an example After persisting the entity inside of a transaction, the entity becomes persistent until the entitymanager is closed note.settitle("a better title"); The entity is still persistent, so every change made to its properties will be flushed to the database when the Entity Manager is closed Persistent Objects The Persistence Lifecycle This is particularly useful when retrieving an object from the database with the intent of modifying it Note note = entitymanager.find(note.class, noteid); note.settitle("another title"); No explicit operation has been called from the Entity Manager, but since the object is in persistent state, all the changes will be flushed to the database 30 31

9 Removed Objects The Persistence Lifecycle an entity can be deleted in several ways with an explicit remove() operation of the entity manager with a cascading operation by removing all references to it an object is in the removed state If it has been scheduled for deletion at the end of a unit of work, but it is still in the persistence context until the unit of work completes it will be deleted from the database as soon as the unit of work completes any references to it in the application should be discarded Detached Objects Detached Objects If a persistence context is closed all objects are moved to the detached state still contain persistent data, which may soon be stale they may be referenced by some object in the application and can thus be changed but, they are no longer guaranteed to be eventually synchronized with database state objects can be brought back to the persistent state by merging the state of the entity to the state of the database note.settitle("a better title"); The entity isdetached, the changes will not be synced to the database 34 35

10 Detached Objects Detached Objects note.settitle("a better title"); note.settitle("a better title"); entitymanager = //a new entity manager instance The entity isdetached, the changes will not be synced to the database. A new Entity Manager instance must be created and this entity has to be merged in order to become persistent again (attached to the new instanceof Entity Manager) 36 Note mergednote = entitymanager.merge(note); mergednote.setdate( new Date() ); Remark: mergednote becomes attached, instead, note remains detached 37 persistence lifecycle the set of states and state transitions with respect to persistence management unit of work a set of operations in the application that may affect persistent instances persistence context a cache that memorizes all the modifications and state changes made to objects during a unit of work more details follow an EntityManager has a persistence context all entities in persistent state in a unit of work are cached in this context an entity instance is persistent when it is contained within a persistence context and it can be acted upon by an entity manager the persistence context provides a scope for various useful operations (in Hibernate) automatic dirty checking transactional write-behind first-level cache 38 39

11 Automatic Dirty Checking the state of persistent instances in a persistence context is synchronized with the database at the end of the unit of work when a unit of work completes, state held in memory is propagated to the database by the execution of SQL statements Transaction-Level Write-Behind Hibernate propagates state changes to the database as late as possible hiding this detail from the application in so doing, Hibernate tries to keep lock-times in the database as short as possible Hibernate keeps track of which objects in memory have been changed and updates only the database rows that are impacted (not all rows corresponding to objects in memory) First-Level Cache the persistence context remembers all persistent entity instances handled in a unit of work enables repeatable read for entities from a unit of work-scoped cache e.g. when a find() lookup is invoked Hibernate first checks the persistence context for the current unit of work if the entity is found there, no database hit occurs Note note = ModelFactory.note(); Note anothernoteinstance = entitymanager.find(note.class, note.getid()); entitymanager.clear(); anothernoteinstance = entitymanager.find(note.class, note.getid()); 42 43

12 Entity is recovered from cache Note note = ModelFactory.note(); Note anothernoteinstance = entitymanager.find(note.class, note.getid()); If we use an application managed Entity Manager (as we did until now) the scope of the persistence context is defined by the user the context lives as long as the Entity Manager lives until close() is called when clear() is called, the persistence context is cleared, causing all persistent entities to become detached Entity is recovered from database entitymanager.clear(); Clear the persistence context, causing all persistent entities to become detached anothernoteinstance = entitymanager.find(note.class, note.getid()); in a container managed Entity Manager, the scope is determined by a transaction Entities become detached as soon as the transaction is closed The scope transaction can be defined by the user see this later, with containers and dependency injection 46

5/2/2017. Querying. Querying. Querying. Entities can be retrieved using EntityManager.find() when the primary key is known

5/2/2017. Querying. Querying. Querying. Entities can be retrieved using EntityManager.find() when the primary key is known Querying Software Architectures and Methodologies - Entities can be retrieved using EntityManager.find() when the primary key is known JPA: Querying to obtain the primary key either the key is natural