Hibernate interview questions

This blog is just for revision .

• What is ORM ?

Object Relational Mapping : Object to database tables .

• Explain Core Classes in hibernate .

1. Configuration : load xml file .
2. SessionFactory : thread safe
3. Session : get connection with database , not thread safe , used to perform CRUD operations .
4. Transaction :  commit and rollback operations . unit of work.
5. Query : common query language for any type of database.
6. Criteria : add restrictions and projections

• Explain Hibernate configuration file 

contains database details used to initialize session factory .

• Explain Hibernate Mapping file 

contains table and column details also contains the entity bean mapping .

• Explain state of the entity in the persistence context .

Session is the persistence context which is used to manage relationship of the entities .

1. transient : newly created object 
2. persistent : associated with session ( session.save)
3. detached : session closed 

• How to use hibernate in spring ?

In application context.xml file specify

1. the datasource bean  DriverManagerDataSource  
• specify the username /password or jndi
2. sessionfactory bean LocalSessionFactoryBean
3. transaction bean HibernateTransactionManager
4. tx:annotation driven 

• What is hibernate dialect.

Different dialect for different databases
MySqlDialect , Oracle Dialect ,Db2 Dialect.

• What are the different consistency anomalies in hibernate .

1. dirty read .reading uncommitted data
2. non repeatable read : second read returns different values for a row
3. phantom read : second read returns different number of rows 

• Explain isolation level .

1. Read uncommitted
2. Read committed :  

      4. Repeatable Read : second read will return same value 

      8. synchronized : does not allow concurrency

Isolation level is set using property hibernate.connection.isolation 

• Explain the locking strategy based on isolation level .

1. Read uncommitted : no lock 
2. Read committed : lock on committed data

      4. Repeatable Read : lock on a block of  SQL

      8. Synchronized : full lock on table .

• In which scenario repeatable read will return different data .

If the read is based on a condition and another thread inserts a row in database . Now for the second read we may get the new also if it satisfies the condition .

• What is Caching in hibernate ?

1. First level Catch : session cache of hibernate , enabled by default 
2. Second Level Cache : optional , eg : Ehcache 
3. Query Level Cache : cached query results . set hibernate.cache.use_query_cache property to true. 

• What are the concurrency strategies for second level cache?

1. Transactional : synchronized with the database .
2. Read-write : if the transaction is not committed , the entity is fetched from database and referred from the cache .
3. non strict read write : cache updated after data committed
4. read only : used when data never gets changed .

• What is dirty checking?

When hibernate loads an entity it keeps a copy of it in the memory, on tx.commit it compares the entity and the copy . If there are any changes, update statement is executed in the database.

• Explain session.get

1. Hits the database immediately.
2. If record is not available in the database it returns null.

• Explain session.load

1. Returns proxy object without hitting the database.
2. If the record is not available and when we try to access it through the proxy object we get Object Not Found Exception.

• What is the difference between get and load ?

in case of no records in the database get returns null and load throws an exception .

• What is the difference between save and persist ?

save return the id and persists returns nothing .persist marks the entity as persistent , does not generate Insert statement outside transaction boundaries . session.save on detached object will create a new row , session.persist on detached object will throw persistentobjectexception.

What is the difference between session.save and session.saveorupdate
save will insert the record if the Id is not available and throw exception if the Id is available. Saveorupdate will insert the record if the Id is not available, else it will update it.

• What is the difference between update and merge ?

Update is used to update the persistent entity and Merge is used to update a detached entity .

• What is the difference between session.flush and transaction.commit ?

flush synchronizes the persistent store with the state held  in memory .
commit commits the record to the database .

• Explain Criteria

Used to filter record

cr =Session.createCriteria
cr.list();

• Explain Restrictions

Used to add condition s to the query to compare the columns
Cr.add( Restrictions.eq("id" , 10));

• Explain Projections

Used to call an aggregate method . Min , max , count .
Cr.setProjection( Projections.max("id"));

• What is Declarative transaction management  ?

 transaction handling is not a part of business logic . 

using @Transactional :

• What is Programmatic transaction management ?

transaction management is a part of business logic . 

• Explain Different transaction manager used in spring .

1. DataSourceTransactionManager : uses datasource 
2. HibernateTransactionManager : uses sessionfactory
3. JpaTransactionManager : uses entitiymanagerfactory 

• Explain transaction propagation ?

using @Transactional( propagation=Propagation.

1. REQUIRED : (default) if transaction is available use it otherwise create a new one. 
2. REQUIRES_NEW : create a new transaction , commit / rollback is independent .
3. NESTED : uses outer transaction but creates a savepoint to allow partial rollback and commit .

• What is readOnly in @Transactional ?

used for only read operations

• What are Value Types .

1. Basic 
2. Composite / Embedded
3. Collection : for one to many .

• Explain Many to Many .

Tables : Person , Project, PersonProject 

Entities :

Person : on projects set attribute add

1. @ManyToMany 
2. @JoinTable ( name=PersonProject , joinColums=@JoinColum , inverseJoinColumns=@JoinColum  )

Project: on persons set attribute add

1.  @ManyToMany(mappedBy = "projects")

• Explain One to Many

Tables : Person , Address

Entities :

•   Explain Cascade type :

In case of mapping like one to one,or one to many , cascade type defines how changes in the entity will cascade to the mapped entity .
@ oneToMany cascade = Cascade Type.ALL

1. All
2. Persist
3. Merge
4. Refresh
5. Remove
6. Detach

• How to lazy load the mapped classes

@oneToMany fetch = Fetch type.Lazy

• What are the fetching strategies ?

1. Join Fetching 
2. Select Fetching 
3. Sub select Fetching 
4. Batch Fetching 

• How to handle multiple databases ?

1. @Table (schema= "")
2. create two sessionfactory , use @Qualifier

• How to handle distributed databases ?

use XA datasource , if  transaction is failed in one database , the entire transaction is roll backed .

• What is the difference between jdbc and JTA?

2 phase commit can be handled using JTA only .

•  Explain different ways of creating  EntityManager ?

1. Container Managed : 

@PersistenceContext

EntityManager entityManager; 

2. Application Managed 

EntityManagerFactory emf = Persistence.createEntityManagerFactory("org.model.student");

• Explain  Anomalies in DBMS

1. Update : multiple rows needs to be updated to update a data .

2. Insert : cannot insert a row without supplementary data.

3. Delete : unable to delete a data as this will cause the important information to be deleted.

• Explain Normalization

  Normalization is the process of organizing data in a relational database to reduce data redundancy and eliminate insertion, update, and deletion anomalies by decomposing tables while preserving data integrity.

  Terminology

  1. Attribute – A column in a table.
  2. Candidate Key – A minimal set of attributes that uniquely identifies a row. A table can have multiple candidate keys; one is chosen as the Primary Key.
  3. Prime Attribute – An attribute that is part of any candidate key (not just the primary key).
  4. Non-prime Attribute – An attribute that is not part of any candidate key.
  5. Super Key – Any set of one or more attributes that uniquely identifies a row. A candidate key is a minimal super key.
  6. Functional Dependency (A → B) – Attribute B is functionally dependent on A, meaning each value of Adetermines exactly one value of B.
  7. Transitive Dependency – If A → B and B → C, then A → C. Here, C is transitively dependent on A.

  Normal Forms

  1NF (First Normal Form)

  • Every attribute contains atomic (indivisible) values.
  • No repeating groups or arrays.

  2NF (Second Normal Form)

  • Must already be in 1NF.
  • Every non-prime attribute must be fully functionally dependent on the entire candidate key (i.e., no partial dependency on part of a composite key).

  3NF (Third Normal Form)

  • Must already be in 2NF.
  • No transitive dependency of a non-prime attribute on a candidate key.

  BCNF (Boyce-Codd Normal Form)

• For every functional dependency X → Y, X must be a super key.

Normal Form	Example
1NF	Employee(EmployeeId, Name, PhoneNumbers) → PhoneNumbers = "9876,9123" violates 1NF. Store one phone number per row or in a separate table.
2NF	Sales(OrderId, ProductId, ProductName, Quantity) with composite PK (OrderId, ProductId) → ProductName depends only on ProductId, not the full key, so move it to a Product table.
3NF	Employee(EmployeeId, Name, DepartmentId, DepartmentName) → DepartmentName depends on DepartmentId, not directly on EmployeeId, so move DepartmentName to a Department table.
BCNF	EmployeeProject(EmployeeId, ProjectId, ManagerId) where ManagerId → ProjectId and EmployeeId + ProjectId → ManagerId → Since ManagerId is not a super key, this violates BCNF and should be decomposed.

Easy way to remember

• 1NF: No multiple values in a column.

• 2NF: No partial dependency on a composite key.

• 3NF: No transitive dependency.

• BCNF: Every determinant must be a super key.