Chapter 23 - Hibernate/ORM Flashcards

Question

EntityManager in JPA vs. Session in Hibernate:

Answer 1

EntityManager: JPA Perspective: EntityManager is an interface in the Java Persistence API (JPA) that is used to interact with the persistence context. Functionality: It is used to perform CRUD operations, manage entity lifecycle, and handle transactions. JPA Implementation: In JPA, the EntityManager is implemented by various JPA providers, such as Hibernate, EclipseLink, etc. Session in Hibernate: Hibernate Perspective: Session is a core interface in Hibernate that represents a single-threaded unit of work and maintains a cache of persistent objects. Functionality: It is used to perform CRUD operations, manage the persistence context (first-level cache), and handle transactions. Hibernate Specific: The Session interface is specific to Hibernate and is not part of the JPA specification. Relationship: In the context of Hibernate being used as the JPA provider, the EntityManager implementation provided by Hibernate internally uses a Session to interact with the database. This means that when you obtain an EntityManager from Hibernate, it is essentially using a Session under the hood to manage entities and transactions.

Answer 2

Purpose: The SessionFactory is a factory class in Hibernate that is used to create Session instances. It is a thread-safe and immutable object that is typically created during application startup and used throughout the application's lifecycle. Lifecycle: The SessionFactory is expensive to create, so it is usually created once and reused throughout the application. It maintains mappings between application domain classes and database tables, as well as other configuration settings. Usage: In Hibernate, you configure the SessionFactory with your application's database connection details, entity mappings, and other settings. Once configured, you use the SessionFactory to create Session instances for performing database operations.

Answer 3

New or Transient: An entity object is in the new or transient state when it has just been instantiated using the new operator. It is not associated with a persistence context and has no representation in the database. Managed: An entity object becomes managed when it is associated with a persistence context, typically through the persist() or merge() methods of EntityManager. In this state, any changes to the entity object are detected and synchronized with the database when the persistence context is flushed. Detached: An entity object becomes detached when it was previously managed but is no longer associated with a persistence context. This can happen when the persistence context is closed, or the entity is explicitly detached using the detach() method of EntityManager. Removed: An entity object becomes removed when it is marked for deletion using the remove() method of EntityManager. It is still associated with a persistence context until the transaction is committed, at which point it is deleted from the database.

Answer 4

JPA allows you to propagate the state transition from a parent entity to a child. For this purpose, the JPA javax.persistence.CascadeType defines various cascade types: ALL - cascades all entity state transitions. PERSIST - cascades the entity persist operation. MERGE - cascades the entity merge operation. REMOVE - cascades the entity remove operation. REFRESH - cascades the entity refresh operation. DETACH - cascades the entity detach operation. Additionally, the CascadeType.ALL will propagate any Hibernate-specific operation, which is defined by the org.hibernate.annotations.CascadeType enum: SAVE_UPDATE - cascades the entity saveOrUpdate operation. REPLICATE - cascades the entity replicate operation. LOCK - cascades the entity lock operation.

Answer 5

The JPA Query Language (JPQL) can be considered as an object oriented version of SQL. Users familiar with SQL should find JPQL very easy to learn and use. The JPA Criteria API provides an alternative way for building dynamic queries, based on Java objects that represent query elements (replacing string based JPQL). JPA also provides a way for building static queries, as named queries, using the @NamedQuery and @NamedQueries annotations. It is considered to be a good practice in JPA to prefer named queries over dynamic queries when possible. The Hibernate Query Language (HQL) and Java Persistence Query Language (JPQL) are both object model focused query languages similar in nature to SQL. JPQL is a heavily-inspired-by subset of HQL. A JPQL query is always a valid HQL query, the reverse is not true, however.

Answer 6

Caching is a feature that is being used in applications to improve the performance. Cache is positioned between the database and the application and usually the data of database queries gets cached (local copy) in disk or memory so that subsequent calls for the same data can be served by cache only. Caching is important to Hibernate as well. It utilizes a multilevel caching scheme as explained below. Hibernate cache is 3 levels of caching: Cache of the first level (First-level cache) Second-level cache (Second-level cache) Query cache

Answer 7

Hibernate first level cache is associated with the Session object. Hibernate first level cache is enabled by default and there is no way to disable it. However hibernate provides methods through which we can delete selected objects from the cache or clear the cache completely. Any object cached in a session will not be visible to other sessions and when the session is closed, all the cached objects will also be lost.

Answer 8

Second level cache can be enabled for a process or cluster scope. In this cache the state of a persistent object is stored (in a disassembled) form and not as a complete instance. Second level cache is optional and can be configured to cache at a class, collection level. It is very important to know that second level cache is at a SessionFactory level, which means all sessions of same session factory will share the cache data.

Answer 9

By default, the data of HQL queries are not cached. If application fires HQL statement in the same or different session, multiple times, then data of the query can be cached. To do so we need to enable, we need to first set hibernate.cache.use_query_cache="true" in hibernate.cfg.xml file . Setting up this property will create additional two required cache regions. One to store the data and one to hold the last updated timestamps. The query cache is similar to the second level cache. But unlike it, the key to the cache data is not the object identifier, but the set of query parameters. And the data itself is the identifiers of the objects that match the query criteria. Thus, it is rational to use this cache with the second-level cache.

Answer 10

JDBC (Java Database Connectivity) is an API (Application Programming Interface) in Java that allows Java applications to interact with databases. It provides methods and interfaces to connect to a database, send queries, and retrieve results.

Answer 11

Hibernate uses JDBC for all database communications. Hibernate internally uses JDBC to interact with the database.

Answer 12

The Transaction is a single-threaded, short-lived object used by the application to demarcate individual physical transaction boundaries. The EntityTransaction is the JPA equivalent and both act as an abstraction API to isolate the application from the underlying transaction system in use (JDBC or JTA).

Answer 13

In the Hibernate framework, we have a Transaction interface that defines the unit of work. It maintains abstraction from the transaction implementation (JTA, JDBC). A transaction is associated with a Session and instantiated by calling session.beginTransaction(). The methods of Transaction interface are as follows: void begin() - starts a new transaction. void commit() - ends the unit of work unless we are in FlushMode.NEVER. void rollback() - forces this transaction to rollback. void setTimeout(int seconds) - it sets a transaction timeout for any transaction started by a subsequent call to begin on this instance. boolean isAlive() - checks if the transaction is still alive. void registerSynchronization(Synchronization s) - registers a user synchronization callback for this transaction. boolean wasCommited() - checks if the transaction is committed successfully. boolean wasRolledBack() - checks if the transaction is rolled back successfully.

Answer 14

The key difference between the get() method and load() method is that load() method will throw an exception if an object with id passed to them is not found, but get() method will return null. The second important difference is that load() method can return proxy without hitting the database unless required (when you access any attribute other than id) but the get() method always go to the database, so sometimes using the load() method can be faster than the get() method.

Answer 15

Let's describe each of the units shown in the above architecture. EntityManagerFactory - This is a factory class of EntityManager. It creates and manages multiple EntityManager instances. EntityManager - It is an Interface, it manages the persistence operations on objects. It works like a factory for Query instance. Entity - Entities are the persistence objects, stored as records in the database. EntityTransaction - It has one-to-one relationship with EntityManager. For each EntityManager, operations are maintained by EntityTransaction class. Persistence - This class contains static methods to obtain EntityManagerFactory instance. Query - This interface is implemented by each JPA vendor to obtain relational objects that meet the criteria.

Answer 16

An EntityManager instance is associated with a persistence context. A persistence context is a set of entity instances in which for any persistent entity identity there is a unique entity instance. Within the persistence context, the entity instances and their lifecycle are managed. The EntityManager API is used to create and remove persistent entity instances, to find entities by their primary key, and to query over entities. In short, a connection to a database is represented by an EntityManager instance, which also provides functionality for performing operations on a database. Many applications require multiple database connections during their lifetime. For instance, in a web application, it is common to establish a separate database connection, using a separate EntityManager instance, for every HTTP request.

Answer 17

Step1: First create an instance of EntityManagerFactory class using the Persistence class. EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("PERSISTENCE"); Persistence - Persistence is a bootstrap class that is used to obtain an EntityManagerFactory interface. createEntityManagerFactory() method - The role of this method is to create and return an EntityManagerFactory for the named persistence unit. Thus, this method contains the name of the persistence unit passed in the Persistence.xml file. Step 2: Obtaining an EntityManager Once we have an EntityManagerFactory we can easily obtain an EntityManager instance: EntityManager entityManager = entityManagerFactory.createEntityManager(); EntityManager - An EntityManager is an interface createEntityManager() method - It creates new application-managed EntityManager Step 3: Using an EntityTransaction Operations that modify database content, such as a store, update, and delete should only be performed within an active transaction. Given an EntityManager, entityManager, it is very easy to begin a transaction: entityManager.getTransaction().begin(); getTransaction() method - This method returns the resource-level EntityTransaction object. begin() method - This method is used to start the transaction. Step 4: Closing EntityManagerFactory and EntityManager Resources The EntityManagerFactory is also used to close the database once we are finished using it: entityManagerFactory.close(); When the connection to the database is no longer needed the EntityManager can be closed: entityManager.close();