Hibernate

A common question in hibernate interview questions and answers, don't miss this one.

The core interfaces of Hibernate framework are used to configure the application, store and retrieve objects and control transactions. The interfaces are: 

1. Configuration: The Configuration objects are used to configure the application by setting the configuration file and mapping documents' location, retrieving the Hibernate - specific properties etc It also helps create the SessionFactory.  
2. SessionFactory: The SessionFactory provides obtains Session instances to the application. SessionFactory instances are not lightweight, and usually, one instance is created for the whole application. If the application accesses multiple databases, it needs one per database. SessionFactory is thread-safe and can hold a second-level cache of data that is reusable between transactions at a process, or cluster, level. 
3. Session: The Session is a persistence manager that manages operations like storing and retrieving objects. Instances of Session are inexpensive to create and destroy. Session objects are not thread-safe and have to be destroyed once their usefulness is over. Session holds a mandatory first-level cache of persistent objects that are used when navigating the object graph or looking up objects by identifier. 
4. Query: This interface is used to query the database and control how the query execution takes place. Queries are written using HQL or in the native SQL language of the database being used. A Query instance allows for binding query parameters, limiting the number of results returned by the query and executing the query. A Query instance cannot be used outside the Session in which it has been created 
5. Criteria: This interface is used to create and execute queries that are criteria based. Such criteria-based queries are called object-oriented criteria queries.  
6. Transaction: A transaction represents a unit of work. When an application performs some operations on a database, it is called a transaction. We can have multiple operations within a single transaction and a single commit to commit all the operations at once. If a transaction fails or an operation fails, the transaction can be rolled back. This interface is an optional interface that the application may use or choose to handle its DB operations and transactions through its own code. 

Hibernate caching improves the performance of the application by pooling the object in the cache. It is useful when we have to fetch the same data multiple times. 

There are mainly two types of caching: first level cache and second level cache. 

• First Level Caching:

This cache is associated with the session object and is enabled by default. It cannot be disabled. The first level cache data is not available to entire application. Hibernate provides methods which can be used to flush the cache or delete specific objects from the cache. Cached objects are not visible to the other sessions in the application and when the session is closed, all the cache objects are removed from memory. 

The session evict() method is used to remove an object from the cache. The session clear() method clears the cache entirely. The session contains() method is used to check if an object exists in the cache. It returns true if the object exists and false if it does not. 

• Second Level Caching: 

SessionFactory object holds the second level cache data. The data stored in the second level cache will be available to entire application. But we need to enable it explicitly. 

The Hibernate architecture includes many objects such as persistent object, session factory, transaction factory, connection factory, session, transaction etc. Of these the more important ones are as below: 

1. SessionFactory: The SessionFactory is a heavyweight object and is created when the application starts. It is created by providing it with the Configuration object which has the database configurations. If the application is using multiple databases, one SessionFactory object per database has to be created using a separate configuration file for each. The SessionFactory object configures the application using the configuration file and allows for Session object initiation. It is a thread-safe object and is used by all the threads of an application.  
2. Session: A session object is created when the application needs a physical connection with the database. It is a lightweight object and is instantiated each time the application interacts with the database. Persistent objects are saved and retrieved through a Session object. A Session object is not thread safe and therefore should be created and destroyed as needed. 
3. Transaction: A Transaction means an operation, or a set of operations have been performed on the database. A transaction manager monitors and handles the transactions.  This is an optional object and the application may want to use their own application code for any database operations instead of using a Transaction. The org.hibernate.Transaction interface provides methods for transaction management.  

 There can be 4 types of association mapping in hibernate. 

1. One to One: A one-to-one association is similar to many-to-one association with a difference that the column will be set as unique. For example, an address object can be associated with a single employee object. <one-to-one> element is used to define one-to-one association. The name attribute is set to the defined variable in the parent class. The column attribute is used to set the column name in the parent table which is set to unique so that only one object can be associated with another object. 
2. One to Many: In One-to-Many mapping association, an object can be associated with multiple objects. For example, Employee object relates to many Certificate objects. A One-to-Many mapping can be implemented using a Set java collection that does not contain any duplicate element. <one-to-many> element of set element indicates that one object relates to many other objects. 
3. Many to One: A many-to-one association is the most common kind of association where an Object can be associated with multiple objects. For example, a same address object can be associated with multiple employee objects. <many-to-one> element is used to define many-to-one association. The name attribute is set to the defined variable in the parent class. The column attribute is used to set the column name in the parent table. 
4. Many to Many: A Many-to-Many mapping can be implemented using a Set java collection that does not contain any duplicate element. <many-to-many> element indicates that one object relates to many other objects and column attributes are used to link intermediate column. 

Both these methods are used when the object has to be converted from detached to persistent state.The differences between update() and merge() methods are as below.

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

...   
SessionFactory sf = obj.buildSessionFactory();   
Session s1 = sf.openSession();   
Employee e1 = (Employee) s1.get(Employee.class, Integer.valueOf(101));//passing id of employee 
s1.saveOrUpdate(e1); 
s1.close(); 
e1.setSalary(70000);   
Session s2 = sf.openSession();   
Employee e2 = (Employee) s2.get(Employee.class, Integer.valueOf(101));//passing same id 
Transaction tx=s2.beginTransaction();   
s2.update(e1); //throws exception 
s2.merge(e1);   
tx.commit();   
s2.close();   

In a single session, only one persistent object can be maintained with a specific primary key. In the above example, the Employee object e1 is stored in the session cache. When the session is closed, e1 will be converted to detached state. If we have to update the Employee object e1 with the new values, we need another session. In the second session, if we try to update e1, an exception is thrown. Now we will call merge in session2 and changes of e1 will be merged in e2 as e2 has the same id as e1. 

 Hibernate configuration file: This file contains a set of configuration settings related to the database and other related parameters which is required by Hibernate for connecting to the database. This file is placed in the root directory of the application’s classpath. Some properties that are configured in this file are: 

• hibernate.connection.driver_class: which is the JDBC driver class for database connection 
• hibernate.connection.url: which is the url to the database instance 
• hibernate.connection.username: is the username to the database instance 
• hibernate.connection.password: is the password to the database instance 
• hibernate.connection.autocommit: is to allow autocommit mode to the JDBC connection 

Hibernate Mapping file: This file contains the mapping of a POJO class to the table. Giving the POJO class the same name as the table and having class properties corresponding to the column names helps in avoiding confusions while mapping the class properties to the table columns.An object normally contains 3 properties - identity, state and behavior. The identity and behavior of the object has to be avoided when storing the object state (value) in the database. This is taken care of by mapping. A Hibernate application can have multiple mapping files for mapping the classes to the tables.Mapping can be done using XML or Annotations. Syntax for creating a mapping file in XML is as below: 

<hibernate-mapping> 
<class name="POJO class name" table="table name in database"> 
                            <id name="variable name" column="column name in database" type="java/hibernate type" /> 
                            <property name="variable1 name" column="column name in database" type="java/hibernate type" /> 
                            <property name="variable2 name" column="column name in database" type="java/hibernate type" /> 
                   </class> 
<hibernate-mapping> 

It's no surprise that this one pops up often in hibernate tricky interview questions.

Using Hibernate Annotations has the following drawbacks: 

• Annotations are included in the code and any changes made to the Annotations lead to code recompilation whereas an XML mapping file is placed outside the code file. So changes can be made without recompilation 
• If migrating from a legacy environment like Hibernate 2 or Hibernate 3, the pre-existing POJO source code need not be altered due to it using XML mapping and working well which means you will not inject known good code with possible bugs. 
• Using Annotations does not separate behavior and the POJO class. All information is in a single file. 
• Some annotations can cause lifecycle mismatches and should be avoided. 
• Some examples of bad annotations are ORM mapping, database configuration, hard-coded config for items that may vary between deployment environments, validations that may vary depending on context. 

Let us look at a simple scenario. As we know every bit of data, be it source code, a compiled class, an object, or anything has a lifecycle associated with it. Suppose we add Hibernate Annotations to our Java code especially if we are connecting to a database and are expecting only this class to connect to the database. The table columns are mapped to the class using the annotations. Now let us assume that we use this class in an API and have consumed the API in a different project. Now the annotations we had used will leak into our API causing mismatches as the database and the tables are different. So, we end up using mapping tools to translate between different layers of the beans in a system. This is an example of the disadvantages of using annotations. 

The highlighted line defines “cascade=Cascade Type.ALL” and it essentially means that any change that happens to Employee Entity must cascade to all associated entities (Accounts Entity in this case) also. This means that if you save an employee into the database, then all associated accounts will also be saved into the database. If an Employee is deleted, then all accounts associated with that Employee will also be deleted. But if we want to cascade only the save operation but not the delete operation, we need to clearly specify it using below code.

@OneToMany(cascade=CascadeType.PERSIST, fetch = FetchType.LAZY) 
@JoinColumn(name="EMPLOYEE_ID") 
private Set<AccountEntity> accounts; 

Now only when the save() or persist() methods are called using employee instance, will the accounts be persisted.If any other method is called on session, its effect will not affect/cascade to the accounts entity.

One of the main aspects of JPA is that it helps to propagate Parent to Child relationships. This behavior is possible through CascadeTypes. The CascadeTypes supported by JPA are:  

1. CascadeType.PERSIST : This cascade type means that save() or persist() operations cascade from the parent or owning entity to related entities. 
2. CascadeType.MERGE :This cascade type means that related entities are merged when the parent or owning entity is merged. 
3. CascadeType.REFRESH : This cascade type refreshes the related entities when the owning or parent entity calls the refresh() operation. 
4. CascadeType.REMOVE : This cascade types removes all related entities associations when the owning entity is deleted. 
5. CascadeType.DETACH : This cascade type detaches all related entities if a “manual detach” occurs. 
6. CascadeType.ALL : When all the cascade operations have to be applied to the owning or parent entity, the cascade type all is used. 

The cascade configuration option accepts an array of CascadeTypes. The below example shows how to add the refresh and merge operations in the cascade operations for a One-to-Many relationship: 

@OneToMany(cascade={CascadeType.REFRESH, CascadeType.MERGE}, fetch = FetchType.LAZY) 
@JoinColumn(name="EMPLOYEE_ID") 
private Set<AccountEntity> accounts; 

Cascading is useful only for Parent - Child associations where the parent entity state transitions cascade to the child entity.  

Hibernate needs information for mapping the POJO classes and their properties with the tables and their columns in the database. The configuration settings for this mapping are done through annotations or through XML configuration file. The XML mapping document defines the mapping between the properties of the POJO classes and the corresponding table columns in the database. Below is the syntax for the XML mapping document. 

<?xml version="1.0"?> 
 <!DOCTYPE hibernate-mapping PUBLIC 
 "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"> 
<hibernate-mapping> 
 <class name=“name of the persistence class or POJO class” table=“The table name from the database”> 
 <id name="id" column= “column name”> 
 <generator class="increment"/> 
 </id> 
 <property name="text" column="Persistance_message"/> 
 <many-to-one name="name of the relationship" cascade="cascade type" column="column name"/> 
 </class> 
</hibernate-mapping> 

The tag <hibernate-mapping> is the main tag for an xml mapping document. This tag specifies that this document has the mapping details between the persistent class and the table columns. Using XML mapping document avoids a full redeploy where the entire application has to be recompiled which would be the case if annotations were used. Annotations are ideal when the object model is persisted in the same way every time. Annotations become a liability if the code is used as an API where the mappings will change. In such situations, XML mapping is the answer. Another advantage to XML mapping is that it keeps the POJO class and its behavior separate. 

JPA annotations are used to map Java persistent classes with their corresponding tables in the database. Hibernate is one of the more popular implementations of the JPA specifications. All the JPA annotations are defined in the javax.persistence package. Along with JPA annotations, Hibernate also supports some other annotations which are available in org.hibernate.annotations package. Some of the important annotations are:

1. javax.persistence.Entity: This is used with POJO classes to specify that they are entity beans.
2. javax.persistence.Table: This is used with entity beans to define the corresponding table name in database.
3. javax.persistence.Access: This is 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: This is used to define the primary key in the entity bean.
5. javax.persistence.EmbeddedId: This is used to define composite primary key in the entity bean.
6. javax.persistence.Column: This is used to define the column name in database table.
7. javax.persistence.GeneratedValue: This is used to define the strategy to be used for generation of primary key. It is used along with javax.persistence.GenerationType enum.
8. javax.persistence.OneToOne: This is used to define the one-to-one mapping between two entity beans. Other similar annotations are OneToMany, ManyToOne and ManyToMany
9. org.hibernate.annotations.Cascade: This is 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: This is used to define the property for foreign key. It is used along with org.hibernate.annotations.GenericGenerator and org.hibernate.annotations.Parameter