The document discusses JPA entity states, persistence context, and the first-level cache. It describes the four entity states: transient, persistent, removed, and detached. It explains that the persistence context manages entity lifecycles and acts as a first-level cache. The first-level cache remembers entities in the current transaction and allows find calls to return entities without database hits, providing repeatable reads.

1. JPA Entity Manager

2. Topics covered
1. JPA Entity States
2. About persistence context
3. First-Level cache

3. JPA Entity States

4. Transient State
● Newly created entity instances with new Java operator are called to be in transient state.
● This entity remains transient until a call to entityManager#persist() is made or
● It is referenced by already-persisted instance and enabled cascading of state for mapped
association.

5. Persistent State
● A persistent entity instance has a representation in the database.
● It does have a database identity eg., primary key
● This entity is either retrieved from DB by execution of a query, by database identifier lookup, or
by getting reference from another persistence entity.
● This entity is always associated with persistence context.

6. Removed State
An entity is in removed state if
1. A call to entityManager#remove() was made on that entity.
2. It is removed from mapped collection with orphan removal enabled.

7. Detached State
An entity is in detached state if your application have reference to an entity instance after the
persistence context is closed.

8. What is Persistence Context
● Is responsible for monitoring and managing lifecycle of all entities in persistent state.
● Allows persistent engine to perform automatic dirty checking of changes to entity instances in
persistence context
● It acts as a first-level cache for all queries. (This is important to understand)
● Persistence context is created every time you create EntityManager

9. First Level Cache
1. It remembers all the entity instances handled in a unit of work (txn).
2. If a call to find(id) is made, hibernate will first check current unit of work in persistence
context. If hibernate finds the entity in persistence context, it will return and no database hit
occurs.
3. All consecutive find(id) calls to the same entity will be served from this cache and will yield the
same result.
4. This acts as a repeatable read for your application.
5. This setting is always “on” and can’t be turned off.

10. Thank You
Reference: Java persistence with Hibernate