JOURNALDEV

1. What is Hibernate Framework?

Object-relational mapping or ORM is the programming technique to map application
domain model objects to the relational database tables. Hibernate is java based ORM tool
that provides framework for mapping application domain objects to the relational database
tables and vice versa.

Hibernate provides reference implementation of Java Persistence API, that makes it a great
choice as ORM tool with benefits of loose coupling. We can use Hibernate persistence
API for CRUD operations. Hibernate framework provide option to map plain old java
objects to traditional database tables with the use of JPA annotations as well as XML
based configuration.

Similarly hibernate configurations are flexible and can be done from XML configuration
file as well as programmatically. For a quick overview of hibernate framework usage, you
can go through Hibernate Beginners Tutorial.

2. What is Java Persistence API (JPA)?

Java Persistence API (JPA) provides specification for managing the relational data in
applications. Current JPA version 2.1 was started in July 2011 as JSR 338. JPA 2.1 was
approved as final on 22 May 2013.

JPA specifications is defined with annotations in javax.persistence package. Using JPA

annotation helps us in writing implementation independent code.

3. What are the important benefits of using Hibernate

Framework?
Some of the important benefits of using hibernate framework are:

1. Hibernate eliminates all the boiler-plate code that comes with JDBC and takes care of
managing resources, so we can focus on business logic.
2. Hibernate framework provides support for XML as well as JPA annotations, that makes
our code implementation independent.
3. Hibernate provides a powerful query language (HQL) that is similar to SQL. However,
HQL is fully object-oriented and understands concepts like inheritance, polymorphism and
association.
4. Hibernate is an open source project from Red Hat Community and used worldwide. This
makes it a better choice than others because learning curve is small and there are tons of
online documentations and help is easily available in forums.
 5. Hibernate is easy to integrate with other Java EE frameworks, it’s so popular that Spring
Framework provides built-in support for integrating hibernate with Spring applications.
6. Hibernate supports lazy initialization using proxy objects and perform actual database
queries only when it’s required.
7. Hibernate cache helps us in getting better performance.
8. For database vendor specific feature, hibernate is suitable because we can also execute
native sql queries.

Overall hibernate is the best choice in current market for ORM tool, it contains all the
features that you will ever need in an ORM tool.

4. What are the advantages of Hibernate over JDBC?

Some of the important advantages of Hibernate framework over JDBC are:

1. Hibernate removes a lot of boiler-plate code that comes with JDBC API, the code looks
more cleaner and readable.
2. Hibernate supports inheritance, associations and collections. These features are not
present with JDBC API.
3. Hibernate implicitly provides transaction management, in fact most of the queries can’t
be executed outside transaction. In JDBC API, we need to write code for transaction
management using commit and rollback. Read more at JDBC Transaction Management.
4. JDBC API throws SQLException that is a checked exception, so we need to write a
lot of try-catch block code. Most of the times it’s redundant in every JDBC call and used for
transaction management. Hibernate wraps JDBC exceptions and
throw JDBCException or HibernateException un-checked exception, so we
don’t need to write code to handle it. Hibernate built-in transaction management removes
the usage of try-catch blocks.
5. Hibernate Query Language (HQL) is more object oriented and close to java programming
language. For JDBC, we need to write native sql queries.
6. Hibernate supports caching that is better for performance, JDBC queries are not cached
hence performance is low.
7. Hibernate provide option through which we can create database tables too, for JDBC
tables must exist in the database.
8. Hibernate configuration helps us in using JDBC like connection as well as JNDI
DataSource for connection pool. This is very important feature in enterprise application
and completely missing in JDBC API.
9. Hibernate supports JPA annotations, so code is independent of implementation and
easily replaceable with other ORM tools. JDBC code is very tightly coupled with the
application.
5. Name some important interfaces of Hibernate framework?
Some of the important interfaces of Hibernate framework are:
 1. SessionFactory (org.hibernate.SessionFactory): SessionFactory is an immutablethread-
safe cache of compiled mappings for a single database. We need to initialize
SessionFactory once and then we can cache and reuse it. SessionFactory instance is used to
get the Session objects for database operations.
2. Session (org.hibernate.Session): Session is a single-threaded, short-lived object
representing a conversation between the application and the persistent store. It wraps
JDBC java.sql.Connection and works as a factory
for org.hibernate.Transaction. We should open session only when it’s
required and close it as soon as we are done using it. Session object is the interface
between java application code and hibernate framework and provide methods for CRUD
operations.
3. Transaction (org.hibernate.Transaction): Transaction is a single-threaded, short-lived
object used by the application to specify atomic units of work. It abstracts the application
from the underlying JDBC or JTA transaction. A org.hibernate.Session might span multiple
org.hibernate.Transaction in some cases.
6. What is hibernate configuration file?
Hibernate configuration file contains database specific configurations and used to initialize
SessionFactory. We provide database credentials or JNDI resource information in the
hibernate configuration xml file. Some other important parts of hibernate configuration file
is Dialect information, so that hibernate knows the database type and mapping file or class
details.

7. What is hibernate mapping file?

Hibernate mapping file is used to define the entity bean fields and database table column
mappings. We know that JPA annotations can be used for mapping but sometimes XML
mapping file comes handy when we are using third party classes and we can’t use
annotations.

8. Name some important annotations used for Hibernate

mapping?
Hibernate supports JPA annotations and it has some other annotations
in org.hibernate.annotationspackage. Some of the important JPA and hibernate
annotations used are:

1. javax.persistence.Entity: Used with model classes to specify that they are entity beans.
2. javax.persistence.Table: Used with entity beans to define the corresponding table name
in database.
3. javax.persistence.Access: Used to define the access type, either field or property.
Default value is field and if you want hibernate to use getter/setter methods then you need
to set it to property.
4. javax.persistence.Id: Used to define the primary key in the entity bean.
 5. javax.persistence.EmbeddedId: Used to define composite primary key in the entity
bean.
6. javax.persistence.Column: Used to define the column name in database table.
7. javax.persistence.GeneratedValue: Used to define the strategy to be used for
generation of primary key. Used in conjunction
with javax.persistence.GenerationTypeenum.
8. javax.persistence.OneToOne: Used to define the one-to-one mapping between two
entity beans. We have other similar annotations
as OneToMany, ManyToOne and ManyToMany
9. org.hibernate.annotations.Cascade: Used to define the cascading between two entity
beans, used with mappings. It works in conjunction
with org.hibernate.annotations.CascadeType
10. javax.persistence.PrimaryKeyJoinColumn: Used to define the property for foreign key.
Used
with org.hibernate.annotations.GenericGeneratorand org.hibe
rnate.annotations.Parameter

Here are two classes showing usage of these annotations.

package com.journaldev.hibernate.model;

import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import org.hibernate.annotations.Cascade;

@Entity
@Table(name = "EMPLOYEE")
@Access(value=AccessType.FIELD)
public class Employee {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "emp_id")
private long id;

@Column(name = "emp_name")
private String name;
 @OneToOne(mappedBy = "employee")
@Cascade(value =
org.hibernate.annotations.CascadeType.ALL)
private Address address;

//getter setter methods

}

package com.journaldev.hibernate.model;

import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;

@Entity
@Table(name = "ADDRESS")
@Access(value=AccessType.FIELD)
public class Address {

@Id
@Column(name = "emp_id", unique = true, nullable = false)
@GeneratedValue(generator = "gen")
@GenericGenerator(name = "gen", strategy = "foreign",
parameters = { @Parameter(name = "property", value =
"employee") })
private long id;

@Column(name = "address_line1")
private String addressLine1;

@OneToOne
@PrimaryKeyJoinColumn
private Employee employee;

//getter setter methods

}
9. What is Hibernate SessionFactory and how to configure it?
 SessionFactory is the factory class used to get the Session objects. SessionFactory is
responsible to read the hibernate configuration parameters and connect to the database and
provide Session objects. Usually an application has a single SessionFactory instance and
threads servicing client requests obtain Session instances from this factory.

The internal state of a SessionFactory is immutable. Once it is created this internal state is
set. This internal state includes all of the metadata about Object/Relational Mapping.

SessionFactory also provide methods to get the Class metadata and Statistics instance to
get the stats of query executions, second level cache details etc.

10.Hibernate SessionFactory is thread safe?

Internal state of SessionFactory is immutable, so it’s thread safe. Multiple threads can
access it simultaneously to get Session instances.

11.What is Hibernate Session and how to get it?

Hibernate Session is the interface between java application layer and hibernate. This is the
core interface used to perform database operations. Lifecycle of a session is bound by the
beginning and end of a transaction.

Session provide methods to perform create, read, update and delete operations for a
persistent object. We can execute HQL queries, SQL native queries and create criteria
using Session object.

12.Hibernate Session is thread safe?

Hibernate Session object is not thread safe, every thread should get it’s own session
instance and close it after it’s work is finished.

13.What is difference between openSession and

getCurrentSession?
Hibernate SessionFactory getCurrentSession() method returns the session bound to the
context. But for this to work, we need to configure it in hibernate configuration file. Since
this session object belongs to the hibernate context, we don’t need to close it. Once the
session factory is closed, this session object gets closed.
 <property
name="hibernate.current_session_context_class">thread</prope
rty>
Hibernate SessionFactory openSession() method always opens a new session. We should
close this session object once we are done with all the database operations. We should
open a new session for each request in multi-threaded environment.

There is another method openStatelessSession() that returns stateless session, for more
details with examples please read Hibernate openSession vs getCurrentSession.

14.What is difference between Hibernate Session get() and

load() method?
Hibernate session comes with different methods to load data from database. get and load
are most used methods, at first look they seems similar but there are some differences
between them.

1. get() loads the data as soon as it’s called whereas load() returns a proxy object and loads
data only when it’s actually required, so load() is better because it support lazy loading.
2. Since load() throws exception when data is not found, we should use it only when we
know data exists.
3. We should use get() when we want to make sure data exists in the database.

For clarification regarding the differences, please read Hibernate get vs load.

15.What is hibernate caching? Explain Hibernate first level

cache?
As the name suggests, hibernate caches query data to make our application faster.
Hibernate Cache can be very useful in gaining fast application performance if used
correctly. The idea behind cache is to reduce the number of database queries, hence
reducing the throughput time of the application.

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.

For better explanation, please read Hibernate First Level Cache.

16.How to configure Hibernate Second Level Cache using
EHCache?
EHCache is the best choice for utilizing hibernate second level cache. Following steps are
required to enable EHCache in hibernate application.

1. Add hibernate-ehcache dependency in your maven project, if it’s not maven then add
corresponding jars.
2.
3. <dependency>
4. <groupId>org.hibernate</groupId>
5. <artifactId>hibernate-ehcache</artifactId>
6. <version>4.3.5.Final</version>
7. </dependency>
8. Add below properties in hibernate configuration file.
9.
10. <property
name="hibernate.cache.region.factory_class">org.hibernat
e.cache.ehcache.EhCacheRegionFactory</property>
11.
12. <!-- For singleton factory -->
13. <!-- <property
name="hibernate.cache.region.factory_class">org.hibernat
e.cache.ehcache.SingletonEhCacheRegionFactory</property>
14. -->
15.
16. <!-- enable second level cache and query cache -->
17. <property
name="hibernate.cache.use_second_level_cache">true</prop
erty>
18. <property
name="hibernate.cache.use_query_cache">true</property>
19. <property
name="net.sf.ehcache.configurationResourceName">/myehcac
he.xml</property>
20. Create EHCache configuration file, a sample file myehcache.xml would look like below.
21.
22. <?xml version="1.0" encoding="UTF-8"?>
23. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance"
24. xsi:noNamespaceSchemaLocation="ehcache.xsd"
updateCheck="true"
25. monitoring="autodetect" dynamicConfig="true">
26.
27. <diskStore path="java.io.tmpdir/ehcache" />
28.
29. <defaultCache maxEntriesLocalHeap="10000"
eternal="false"
30. timeToIdleSeconds="120" timeToLiveSeconds="120"
diskSpoolBufferSizeMB="30"
31. maxEntriesLocalDisk="10000000"
diskExpiryThreadIntervalSeconds="120"
32. memoryStoreEvictionPolicy="LRU"
statistics="true">
33. <persistence strategy="localTempSwap" />
34. </defaultCache>
35.
36. <cache name="employee" maxEntriesLocalHeap="10000"
eternal="false"
37. timeToIdleSeconds="5" timeToLiveSeconds="10">
38. <persistence strategy="localTempSwap" />
39. </cache>
40.
41. <cache
name="org.hibernate.cache.internal.StandardQueryCache"
42. maxEntriesLocalHeap="5" eternal="false"
timeToLiveSeconds="120">
43. <persistence strategy="localTempSwap" />
44. </cache>
45.
46. <cache
name="org.hibernate.cache.spi.UpdateTimestampsCache"
47. maxEntriesLocalHeap="5000" eternal="true">
48. <persistence strategy="localTempSwap" />
49. </cache>
50. </ehcache>
51. Annotate entity beans with @Cache annotation and caching strategy to use. For
example,
52.
53. import org.hibernate.annotations.Cache;
54. import
org.hibernate.annotations.CacheConcurrencyStrategy;
55.
56. @Entity
57. @Table(name = "ADDRESS")
58. @Cache(usage=CacheConcurrencyStrategy.READ_ONLY,
region="employee")
59. public class Address {
60.
61. }
That’s it, we are done. Hibernate will use the EHCache for second level caching,
read Hibernate EHCache Example for a complete example with explanation.
 What are different states of an entity bean?
An entity bean instance can exist is one of the three states.

1. Transient: When an object is never persisted or associated with any session, it’s in
transient state. Transient instances may be made persistent by calling save(), persist() or
saveOrUpdate(). Persistent instances may be made transient by calling delete().
2. Persistent: When an object is associated with a unique session, it’s in persistent state.
Any instance returned by a get() or load() method is persistent.
3. Detached: When an object is previously persistent but not associated with any session,
it’s in detached state. Detached instances may be made persistent by calling update(),
saveOrUpdate(), lock() or replicate(). The state of a transient or detached instance may
also be made persistent as a new persistent instance by calling merge().
2. What is use of Hibernate Session merge() call?
Hibernate merge can be used to update existing values, however this method create a copy
from the passed entity object and return it. The returned object is part of persistent context
and tracked for any changes, passed object is not tracked. For example program,
read Hibernate merge.

3. What is difference between Hibernate save(),

saveOrUpdate() and persist() methods?
Hibernate save can be used to save entity to database. Problem with save() is that it can be
invoked without a transaction and if we have mapping entities, then only the primary
object gets saved causing data inconsistencies. Also save returns the generated id
immediately.

Hibernate persist is similar to save with transaction. I feel it’s better than save because we
can’t use it outside the boundary of transaction, so all the object mappings are preserved.
Also persist doesn’t return the generated id immediately, so data persistence happens when
needed.

Hibernate saveOrUpdate results into insert or update queries based on the provided data. If
the data is present in the database, update query is executed. We can use saveOrUpdate()
without transaction also, but again you will face the issues with mapped objects not getting
saved if session is not flushed. For example usage of these methods, read Hibernate save
vs persist.

4. What will happen if we don’t have no-args constructor

in Entity bean?
 Hibernate uses Reflection API to create instance of Entity beans, usually when you call
get() or load() methods. The method Class.newInstance() is used for this and it requires
no-args constructor. So if you won’t have no-args constructor in entity beans, hibernate
will fail to instantiate it and you will get HibernateException.

5. What is difference between sorted collection and

ordered collection, which one is better?
When we use Collection API sorting algorithms to sort a collection, it’s called sorted list.
For small collections, it’s not much of an overhead but for larger collections it can lead to
slow performance and OutOfMemory errors. Also the entity beans should
implement Comparable or Comparatorinterface for it to work, read more at java object list
sorting.

If we are using Hibernate framework to load collection data from database, we can use it’s
Criteria API to use “order by” clause to get ordered list. Below code snippet shows you
how to get it.

List<Employee> empList =
session.createCriteria(Employee.class)
.addOrder(Order.desc("id")
).list();
Ordered list is better than sorted list because the actual sorting is done at database level,
that is fast and doesn’t cause memory issues.

6. What are the collection types in Hibernate?

There are five collection types in hibernate used for one-to-many relationship mappings.

1. Bag
2. Set
3. List
4. Array
5. Map
7. How to implement Joins in Hibernate?
There are various ways to implement joins in hibernate.

1. Using associations such as one-to-one, one-to-many etc.

2. Using JOIN in the HQL query. There is another form “join fetch” to load associated data
simultaneously, no lazy loading.
3. We can fire native sql query and use join keyword.
 Why we should not make Entity Class final?
Hibernate use proxy classes for lazy loading of data, only when it’s needed. This is done
by extending the entity bean, if the entity bean will be final then lazy loading will not be
possible, hence low performance.

 What is HQL and what are it’s benefits?

Hibernate Framework comes with a powerful object-oriented query language – Hibernate
Query Language (HQL). It’s very similar to SQL except that we use Objects instead of
table names, that makes it more close to object oriented programming.

Hibernate query language is case-insensitive except for java class and variable names. So
SeLeCT is the same as sELEct is the same as SELECT, but
com.journaldev.model.Employee is not same as com.journaldev.model.EMPLOYEE.

The HQL queries are cached but we should avoid it as much as possible, otherwise we will
have to take care of associations. However it’s a better choice than native sql query
because of Object-Oriented approach. Read more at HQL Example.

 What is Query Cache in Hibernate?

Hibernate implements a cache region for queries resultset that integrates closely with the
hibernate second-level cache.

This is an optional feature and requires additional steps in code. This is only useful for
queries that are run frequently with the same parameters. First of all we need to configure
below property in hibernate configuration file.

<property
name="hibernate.cache.use_query_cache">true</property>
And in code, we need to use setCacheable(true) method of Query, quick example looks
like below.

Query query = session.createQuery("from Employee");

query.setCacheable(true);
query.setCacheRegion("ALL_EMP");
 Can we execute native sql query in hibernate?
 Hibernate provide option to execute native SQL queries through the use
of SQLQuery object.

For normal scenarios, it is however not the recommended approach because we loose
benefits related to hibernate association and hibernate first level caching. Read more
at Hibernate Native SQL Query Example.

 What is the benefit of native sql query support in

hibernate?
Native SQL Query comes handy when we want to execute database specific queries that
are not supported by Hibernate API such as query hints or the CONNECT keyword in
Oracle Database.

 What is Named SQL Query?

Hibernate provides Named Query that we can define at a central location and use them
anywhere in the code. We can created named queries for both HQL and Native SQL.

Hibernate Named Queries can be defined in Hibernate mapping files or through the use of
JPA annotations @NamedQuery and @NamedNativeQuery.

 What are the benefits of Named SQL Query?

Hibernate Named Query helps us in grouping queries at a central location rather than
letting them scattered all over the code.
Hibernate Named Query syntax is checked when the hibernate session factory is created,
thus making the application fail fast in case of any error in the named queries.
Hibernate Named Query is global, means once defined it can be used throughout the
application.

However one of the major disadvantage of Named query is that it’s hard to debug, because
we need to find out the location where it’s defined.

 What is the benefit of Hibernate Criteria API?

Hibernate provides Criteria API that is more object oriented for querying the database and
getting results. We can’t use Criteria to run update or delete queries or any DDL
statements. It’s only used to fetch the results from the database using more object oriented
approach.
 Some of the common usage of Criteria API are:

1. Criteria API provides Projection that we can use for aggregate functions such as sum(),
min(), max() etc.
2. Criteria API can be used with ProjectionList to fetch selected columns only.
3. Criteria API can be used for join queries by joining multiple tables, useful methods are
createAlias(), setFetchMode() and setProjection()
4. Criteria API can be used for fetching results with conditions, useful methods are add()
where we can add Restrictions.
5. Criteria API provides addOrder() method that we can use for ordering the results.

Learn some quick examples at Hibernate Criteria Example.

 How to log hibernate generated sql queries in log

files?
We can set below property for hibernate configuration to log SQL queries.

<property name="hibernate.show_sql">true</property>
However we should use it only in Development or Testing environment and turn it off in
production environment.

 What is Hibernate Proxy and how it helps in lazy

loading?
Hibernate uses proxy object to support lazy loading. Basically when you load data from
tables, hibernate doesn’t load all the mapped objects. As soon as you reference a child or
lookup object via getter methods, if the linked entity is not in the session cache, then the
proxy code will go to the database and load the linked object. It uses javassist to
effectively and dynamically generate sub-classed implementations of your entity objects.

 How to implement relationships in hibernate?

We can easily implement one-to-one, one-to-many and many-to-many relationships in
hibernate. It can be done using JPA annotations as well as XML based configurations. For
better understanding, you should go through following tutorials.

1. Hibernate One to One Mapping

2. Hibernate One to Many Mapping
3. Hibernate Many to Many Mapping
2. How transaction management works in Hibernate?
Transaction management is very easy in hibernate because most of the operations are not
permitted outside of a transaction. So after getting the session from SessionFactory, we
can call session beginTransaction()to start the transaction. This method returns the
Transaction reference that we can use later on to either commit or rollback the transaction.

Overall hibernate transaction management is better than JDBC transaction management

because we don’t need to rely on exceptions for rollback. Any exception thrown by session
methods automatically rollback the transaction.

3. What is cascading and what are different types of

cascading?
When we have relationship between entities, then we need to define how the different
operations will affect the other entity. This is done by cascading and there are different
types of it.

Here is a simple example of applying cascading between primary and secondary entities.

import org.hibernate.annotations.Cascade;

@Entity
@Table(name = "EMPLOYEE")
public class Employee {

@OneToOne(mappedBy = "employee")
@Cascade(value = org.hibernate.annotations.CascadeType.ALL)
private Address address;

}
Note that Hibernate CascadeType enum constants are little bit different from
JPA javax.persistence.CascadeType, so we need to use the Hibernate CascadeType
and Cascade annotations for mappings, as shown in above example.
Commonly used cascading types as defined in CascadeType enum are:

1. None: No Cascading, it’s not a type but when we don’t define any cascading then no
operations in parent affects the child.
2. ALL: Cascades save, delete, update, evict, lock, replicate, merge, persist. Basically
everything
3. SAVE_UPDATE: Cascades save and update, available only in hibernate.
4. DELETE: Corresponds to the Hibernate native DELETE action, only in hibernate.
 5. DETATCH, MERGE, PERSIST, REFRESH and REMOVE – for similar operations
6. LOCK: Corresponds to the Hibernate native LOCK action.
7. REPLICATE: Corresponds to the Hibernate native REPLICATE action.
4. How to integrate log4j logging in hibernate
application?
Hibernate 4 uses JBoss logging rather than slf4j used in earlier versions. For log4j
configuration, we need to follow below steps.

1. Add log4j dependencies for maven project, if not maven then add corresponding jar
files.
2. Create log4j.xml configuration file or log4j.properties file and keep it in the classpath.
You can keep file name whatever you want because we will load it in next step.
3. For standalone projects, use static block to configure log4j
using DOMConfigurator or PropertyConfigurator. For web applications,
you can use ServletContextListener to configure it.

That’s it, our setup is ready. Create org.apache.log4j.Loggerinstance in the java

classes and start logging. For complete example code, you should go through Hibernate
log4j example and Servlet log4j example.

 How to use application server JNDI DataSource with

Hibernate framework?
For web applications, it’s always best to allow servlet container to manage the connection
pool. That’s why we define JNDI resource for DataSource and we can use it in the web
application. It’s very easy to use in Hibernate, all we need is to remove all the database
specific properties and use below property to provide the JNDI DataSource name.

<property
name="hibernate.connection.datasource">java:comp/env/jdbc/My
LocalDB</property>
For a complete example, go through Hibernate JNDI DataSource Example.

 How to integrate Hibernate and Spring frameworks?

Spring is one of the most used Java EE Framework and Hibernate is the most popular
ORM framework. That’s why Spring Hibernate combination is used a lot in enterprise
applications. The best part with using Spring is that it provides out-of-box integration
support for Hibernate with Spring ORM module. Following steps are required to integrate
Spring and Hibernate frameworks together.
 1. Add hibernate-entitymanager, hibernate-core and spring-orm dependencies.
2. Create Model classes and corresponding DAO implementations for database operations.
Note that DAO classes will use SessionFactory that will be injected by Spring Bean
configuration.
3. If you are using Hibernate 3, you need to
configure org.springframework.orm.hibernate3.LocalSessionFac
toryBeanor org.springframework.orm.hibernate3.annotation.
AnnotationSessionFactoryBeanin Spring Bean configuration file. For
Hibernate 4, there is single
class org.springframework.orm.hibernate4.LocalSessionFactor
yBeanthat should be configured.
4. Note that we don’t need to use Hibernate Transaction Management, we can leave it to
Spring declarative transaction management using @Transactional annotation.

For complete example go through Spring Hibernate Integration and Spring MVC

Hibernate Integration.

2. What is HibernateTemplate class?

When Spring and Hibernate integration started, Spring ORM provided two helper classes
– HibernateDaoSupport and HibernateTemplate. The reason to use them was to get the
Session from Hibernate and get the benefit of Spring transaction management. However
from Hibernate 3.0.1, we can use SessionFactorygetCurrentSession() method to get the
current session and use it to get the spring transaction management benefits. If you go
through above examples, you will see how easy it is and that’s why we should not use
these classes anymore.

One other benefit of HibernateTemplate was exception translation but that can be

achieved easily by using @Repositoryannotation with service classes, shown in above
spring mvc example. This is a trick question to judge your knowledge and whether you are
aware of recent developments or not.

3. How to integrate Hibernate with Servlet or Struts2

web applications?
Hibernate integration with Servlet or Struts2 needs to be done
using ServletContextListener, a complete example can be found at Hibernate Struts2
Integration Example.

4. Which design patterns are used in Hibernate

framework?
 Some of the design patterns used in Hibernate Framework are:

1. Domain Model Pattern – An object model of the domain that incorporates both
behavior and data.
2. Data Mapper – A layer of Mappers that moves data between objects and a database
while keeping them independent of each other and the mapper itself.
3. Proxy Pattern for lazy loading
4. Factory pattern in SessionFactory
 What are best practices to follow with Hibernate
framework?
Some of the best practices to follow in Hibernate are:

1. Always check the primary key field access, if it’s generated at the database layer then
you should not have a setter for this.
2. By default hibernate set the field values directly, without using setters. So if you want
hibernate to use setters, then make sure proper access is defined
as @Access(value=AccessType.PROPERTY).
3. If access type is property, make sure annotations are used with getter methods and not
setter methods. Avoid mixing of using annotations on both filed and getter methods.
4. Use native sql query only when it can’t be done using HQL, such as using database
specific feature.
5. If you have to sort the collection, use ordered list rather than sorting it using Collection
API.
6. Use named queries wisely, keep it at a single place for easy debugging. Use them for
commonly used queries only. For entity specific query, you can keep them in the entity
bean itself.
7. For web applications, always try to use JNDI DataSource rather than configuring to
create connection in hibernate.
8. Avoid Many-to-Many relationships, it can be easily implemented using bidirectional
One-to-Many and Many-to-One relationships.
9. For collections, try to use Lists, maps and sets. Avoid array because you don’t get benefit
of lazy loading.
10. Do not treat exceptions as recoverable, roll back the Transaction and close the Session.
If you do not do this, Hibernate cannot guarantee that in-memory state accurately
represents the persistent state.
11. Prefer DAO pattern for exposing the different methods that can be used with entity
bean
12. Prefer lazy fetching for associations
 What is Hibernate Validator Framework?
Data validation is integral part of any application. You will find data validation at
presentation layer with the use of Javascript, then at the server side code before processing
it. Also data validation occurs before persisting it, to make sure it follows the correct
format.
 Validation is a cross cutting task, so we should try to keep it apart from our business logic.
That’s why JSR303 and JSR349 provides specification for validating a bean by using
annotations. Hibernate Validator provides the reference implementation of both these bean
validation specs. Read more at Hibernate Validation Example.

 What is the benefit of Hibernate Tools Eclipse plugin?

Hibernate Tools plugin helps us in writing hibernate configuration and mapping files
easily. The major benefit is the content assist to help us with properties or xml tags to use.
It also validates them against the Hibernate DTD files, so we know any mistakes before
hand. Learn how to install and use at Hibernate Tools Eclipse Plugin.

JAVATPOINT

1) What is hibernate?

Hibernate is an open-source and lightweight ORM tool that is used to store,

manipulate, and retrieve data from the database.

more details...

2) What is ORM?

ORM is an acronym for Object/Relational mapping. It is a programming strategy to

map object with the data stored in the database. It simplifies data creation, data
manipulation, and data access.
3) Explain hibernate architecture?

Hibernate architecture comprises of many interfaces such as Configuration,

SessionFactory, Session, Transaction, etc.

more
details... 

4) What are the core interfaces of Hibernate?

The core interfaces of Hibernate framework are:

o Configuration
o SessionFactory
o Session
 o Query
o Criteria
o Transaction

5) Mention some of the advantages of using ORM over

JDBC.

ORM has the following advantages over JDBC:

o Application development is fast.

o Management of transaction.
o Generates key automatically.
o Details of SQL queries are hidden.

6) Define criteria in terms of Hibernate.

The objects of criteria are used for the creation and execution of the object-oriented
criteria queries.

7) List some of the databases supported by Hibernate.

Some of the databases supported by Hibernate are:

o DB2
o MySQL
o Oracle
o Sybase SQL Server
o Informix Dynamic Server
o HSQL
o PostgreSQL
o FrontBase

8) List the key components of Hibernate.

Key components of Hibernate are:

o Configuration
o Session
o SessionFactory
o Criteria
o Query
o Transaction

9) Mention two components of Hibernate configuration

object.

Database Connection

Class Mapping Setup

10) How is SQL query created in Hibernate?

The SQL query is created with the help of the following syntax:

Session.createSQLQuery

11) What does HQL stand for?

Hibernate Query Language

12) How is HQL query created?

The HQL query is created with the help of the following syntax:

Session.createQuery
13) How can we add criteria to a SQL query?

A criterion is added to a SQL query by using the Session.createCriteria.

14) Define persistent classes.

Classes whose objects are stored in a database table are called as persistent classes.

15) What is SessionFactory?

SessionFactory provides the instance of Session. It is a factory of Session. It holds the

data of second level cache that is not enabled by default.

more details...

16) Is SessionFactory a thread-safe object?

Yes, SessionFactory is a thread-safe object, many threads cannot access it

simultaneously.

17) What is Session?

It maintains a connection between the hibernate application and database.

It provides methods to store, update, delete or fetch data from the database such as
persist(), update(), delete(), load(), get() etc.

It is a factory of Query, Criteria and Transaction i.e. it provides factory methods to

return these instances.
more details...

18) Is Session a thread-safe object?

No, Session is not a thread-safe object, many threads can access it simultaneously. In
other words, you can share it between threads.

19) What is the difference between session.save() and

session.persist() method?
No. save() persist()

1 returns the identifier (Serializable) Return nothing because its return

) of the instance. type is void.

2 Syn: public Serializable save(Object Syn: public void persist(Object o)

) o)

20) What is the difference between get and load method?

The differences between get() and load() methods are given below.

No. get() load()

1 Returns null if an object is Throws ObjectNotFoundException if an

) not found. object is not found.

2 get() method always hit load() method doesn't hit the database.

) the database.

3 It returns the real object, It returns proxy object.

) not the proxy.
 4 It should be used if you It should be used if you are sure that
) are not sure about the instance exists.
existence of instance.

21) What is the difference between update and merge

method?

The differences between update() and merge() methods are given below.

No. The update() method merge() method

1 Update means to edit something. Merge means to combine

) something.

2 update() should be used if the session merge() should be used if

) doesn't contain an already persistent you don't know the state of
state with the same id. It means an the session, means you want
update should be used inside the session to make the modification at
only. After closing the session, it will any time.
throw the error.

Let's try to understand the difference by the example given below:

1. ...  
2. SessionFactory factory = cfg.buildSessionFactory();  
3. Session session1 = factory.openSession();  
4.    
5. Employee e1 = (Employee) session1.get(Employee.class, Integer.valueOf(101));/
/passing id of employee  
6. session1.close();  
7.    
8. e1.setSalary(70000);  
9.    
10. Session session2 = factory.openSession();  
11. Employee e2 = (Employee) session1.get(Employee.class, Integer.valueOf(101));/
/passing same id  
12.   
13. Transaction tx=session2.beginTransaction();  
14. session2.merge(e1);  
15.   
16. tx.commit();  
17. session2.close();  

After closing session1, e1 is in detached state. It will not be in the session1 cache. So
if you call update() method, it will throw an error.

Then, we opened another session and loaded the same Employee instance. If we call
merge in session2, changes of e1 will be merged in e2.

22) What are the states of the object in hibernate?

There are 3 states of the object (instance) in hibernate.

1. Transient: The object is in a transient state if it is just created but has no

primary key (identifier) and not associated with a session.
2. Persistent: The object is in a persistent state if a session is open, and you just
saved the instance in the database or retrieved the instance from the database.
3. Detached: The object is in a detached state if a session is closed. After
detached state, the object comes to persistent state if you call lock() or
update() method.

23) What are the inheritance mapping strategies?

There are 3 ways of inheritance mapping in hibernate.

1. Table per hierarchy

2. Table per concrete class
3. Table per subclass

more details...

24) How to make an immutable class in hibernate?

 If you mark a class as mutable="false", the class will be treated as an immutable
class. By default, it is mutable="true".

25) What is automatic dirty checking in hibernate?

The automatic dirty checking feature of Hibernate, calls update statement

automatically on the objects that are modified in a transaction.

Let's understand it by the example given below:

1. ...  
2. SessionFactory factory = cfg.buildSessionFactory();  
3. Session session1 = factory.openSession();  
4. Transaction tx=session2.beginTransaction();  
5.    
6. Employee e1 = (Employee) session1.get(Employee.class, Integer.valueOf(101));  
7.    
8. e1.setSalary(70000);  
9.    
10. tx.commit();  
11. session1.close();  

Here, after getting employee instance e1 and we are changing the state of e1.

After changing the state, we are committing the transaction. In such a case, the state
will be updated automatically. This is known as dirty checking in hibernate.

26) How many types of association mapping are possible

in hibernate?

There can be 4 types of association mapping in hibernate.

1. One to One
2. One to Many
3. Many to One
 4. Many to Many

27) Is it possible to perform collection mapping with One-

to-One and Many-to-One?

No, collection mapping can only be performed with One-to-Many and Many-to-Many.

28) What is lazy loading in hibernate?

Lazy loading in hibernate improves the performance. It loads the child objects on
demand.

Since Hibernate 3, lazy loading is enabled by default, and you don't need to do
lazy="true". It means not to load the child objects when the parent is loaded.

29) What is HQL (Hibernate Query Language)?

Hibernate Query Language is known as an object-oriented query language. It is like a

structured query language (SQL).

The main advantage of HQL over SQL is:

1. You don't need to learn SQL

2. Database independent
3. Simple to write a query

30) What is the difference between first level cache and

second level cache?
No. First Level Cache Second Level Cache
1 First Level Cache Second Level Cache is associated
) is associated with Session. with SessionFactory.

2 It is enabled by default. It is not enabled by default.

)