Explore topic-wise InterviewSolutions in .

A concurrency strategy is a mediator which responsible for storing items of data in the cache and retrieving them from the cache. If you are going to enable a second-level cache, you will have to decide, for each persistent class and collection, which cache concurrency strategy to use.

• Transactional − Use this strategy for read-mostly data where it is critical to prevent stale data in concurrent transactions,in the rare case of an update.

• Read-write − Again use this strategy for read-mostly data where it is critical to prevent stale data in concurrent transactions,in the rare case of an update.

• Nonstrict-read-write − This strategy makes no guarantee of consistency between the cache and the database. Use this strategy if data hardly ever changes and a small likelihood of stale data is not of critical concern.

• Read-only − A concurrency strategy suitable for data which never changes. Use it for reference data only.

Second level cache is an optional cache and first-level cache will always be consulted before any attempt is made to locate an object in the second-level cache. The second-level cache can be configured on a per-class and per-collection basis and mainly responsible for caching objects across sessions.

The first-level cache is the Session cache and is a mandatory cache through which all requests must pass. The Session object keeps an object under its own power before committing it to the database.

There are following differences between get() and load() methods.

• get() returns null if no data is present where as load throws ObjectNotFoundException exception in such case.

• get() always hits the database whereas load() method doesn't hit the database.

• get() returns actual object whereas load() returns proxy object.

• A central feature of Hibernate, proxies, depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods.

• All classes that do not extend or implement some specialized classes and interfaces required by the EJB framework.

session.save saves the object and returns the id of the instance whereas persist do not return anything after saving the instance.

No, Session is not thread-safe.

Yes, SessionFactory is a thread-safe and can be accessed by multiple threads simultaneously.

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.

In One-to-Many mapping association, an object can be 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.

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.

<many-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 an other object.

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.

This is mapped with a <map> element and initialized with java.util.TreeMap. The sort attribute can be set to either a comparator or natural ordering.

This is mapped with a <map> element and initialized with java.util.HashMap.

This is mapped with a <bag> or <ibag> element and initialized with java.util.ArrayList.

This is mapped with a <list> element and initialized with java.util.ArrayList.

This is mapped with a <set> element and initialized with java.util.TreeSet. The sort attribute can be set to either a comparator or natural ordering.

This is mapped with a <set> element and initialized with java.util.HashSet.

The <property> element is used to map a Java class property to a column in the database table. The name attribute of the element refers to the property in the class and the column attribute refers to the column in the database table. The type attribute holds the hibernate mapping type, this mapping types will convert from Java to SQL data type.

The <generator> element within the id element is used to automatically generate the primary key values. Set the class attribute of the generator element is set to native to let hibernate pick up either identity, sequence or hilo algorithm to create primary key depending upon the capabilities of the underlying database.

The <id> element maps the unique ID attribute in class to the primary key of the database table. The name attribute of the id element refers to the property in the class and the column attribute refers to the column in the database table. The type attribute holds the hibernate mapping type, this mapping types will convert from Java to SQL data type.

The <class> elements are used to define specific mappings from a Java classes to the database tables. The Java class name is specified using the name attribute of the class element and the database table name is specified using the table attribute.

The mapping document is an XML document having <hibernate-mapping> as the root element which contains all the <class> elements.

An Object/relational mappings are usually defined in an XML document. This mapping file instructs Hibernate how to map the defined class or classes to the database tables. We should save the mapping document in a file with the format <classname>.hbm.xml.

There are following main rules of persistent classes, however, none of these rules are hard requirements.

• All Java classes that will be persisted need a default constructor.

• All classes should contain an ID in order to allow easy identification of your objects within Hibernate and the database. This property maps to the primary key column of a database table.

• All attributes that will be persisted should be declared private and have getXXX and setXXX methods defined in the JavaBean style.

• A central feature of Hibernate, proxies, depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods.

• All classes that do not extend or implement some specialized classes and interfaces required by the EJB framework.

Java classes whose objects or instances will be stored in database tables are called persistent classes in Hibernate.

Session.saveOrUpdate either saves(Object) or updates(Object) the given instance.

Session.update updates the state of the given instance from the underlying database.

Session.save saves the state of the given instance from the underlying database.

Session.refresh re-reads the state of the given instance from the underlying database.

Session.get returns the persistent instance of the given named entity with the given identifier, or null if there is no such persistent instance.

Session.delete removes a persistent instance from the datastore.

Session.createSQLQuery creates a new instance of SQLQuery for the given SQL query string.

Session.createQuery creates a new instance of Query for the given HQL query string.

Session.createCriteria creates a new Criteria instance, for the given entity class, or a superclass of an entity class.

Session.beginTransaction method begins a unit of work and returns the associated Transaction object.

Instances may exist in one of the following three states at a given point in time −

• transient − A new instance of a a persistent class which is not associated with a Session and has no representation in the database and no identifier value is considered transient by Hibernate.

• persistent − You can make a transient instance persistent by associating it with a Session. A persistent instance has a representation in the database, an identifier value and is associated with a Session.

• detached − Once we close the Hibernate Session, the persistent instance will become a detached instance.

Criteria object are used to create and execute object oriented criteria queries to retrieve objects.

Query objects use SQL or Hibernate Query Language (HQL) string to retrieve data from the database and create objects. A Query instance is used to bind query parameters, limit the number of results returned by the query, and finally to execute the query.

A Transaction represents a unit of work with the database and most of the RDBMS supports transaction functionality. Transactions in Hibernate are handled by an underlying transaction manager and transaction (from JDBC or JTA).

This is an optional object and Hibernate applications may choose not to use this interface, instead managing transactions in their own application code.

A Session is used to get a physical connection with a database. The Session object is lightweight and designed to be instantiated each time an interaction is needed with the database. Persistent objects are saved and retrieved through a Session object.

The session objects should not be kept open for a long time because they are not usually thread safe and they should be created and destroyed them as needed.

Configuration object is used to create a SessionFactory object which inturn configures Hibernate for the application using the supplied configuration file and allows for a Session object to be instantiated. The SessionFactory is a thread safe object and used by all the threads of an application.

The SessionFactory is heavyweight object so usually it is created during application start up and kept for later use. You would need one SessionFactory object per database using a separate configuration file. So if you are using multiple databases then you would have to create multiple SessionFactory objects.

The Configuration object is the first Hibernate object you create in any Hibernate application and usually created only once during application initialization. It represents a configuration or properties file required by the Hibernate.

The Configuration object provides two keys components −

• Database Connection − This is handled through one or more configuration files supported by Hibernate. These files are hibernate.properties and hibernate.cfg.xml.

• Class Mapping Setup

This component creates the connection between the Java classes and database tables.

Following are the key components/objects of Hibernate −

• Configuration − Represents a configuration or properties file required by the Hibernate.

• SessionFactory − Configures Hibernate for the application using the supplied configuration file and allows for a Session object to be instantiated.

• Session − Used to get a physical connection with a database.

• Transaction − Represents a unit of work with the database and most of the RDBMS supports transaction functionality.

• Query − Uses SQL or Hibernate Query Language (HQL) string to retrieve data from the database and create objects.

• Criteria − Used to create and execute object oriented criteria queries to retrieve objects.

Hibernate supports a variety of other technologies, including the following −

• XDoclet Spring

• J2EE

• Eclipse plug-ins

• Maven

Hibernate supports almost all the major RDBMS. Following is list of few of the database engines supported by Hibernate.

• HSQL Database Engine

• DB2/NT

• MySQL

• PostgreSQL

• FrontBase

• Oracle

• Microsoft SQL Server Database

• Sybase SQL Server

• Informix Dynamic Server

Following are the advantages of using Hibernate.

• Hibernate takes care of mapping Java classes to database tables using XML files and without writing any line of code.

• Provides simple APIs for storing and retrieving Java objects directly to and from the database.

• If there is change in Database or in any table then the only need to change XML file properties.

• Abstract away the unfamiliar SQL types and provide us to work around familiar Java Objects.

• Hibernate does not require an application server to operate.

• Manipulates Complex associations of objects of your database.

• Minimize database access with smart fetching strategies.

• Provides Simple querying of data.

There are several persistent frameworks and ORM options in Java.

• Enterprise JavaBeans Entity Beans

• Java Data Objects

• Castor

• TopLink

• Spring DAO

• Hibernate

An ORM system has following advantages over plain JDBC