Saturday, 26 January 2013

Hibernate is a high-performance Object/Relational persistence and query service. The most flexible and powerful Object/Relational solution on the market, Hibernate takes care of the mapping from Java classes to database tables and from Java data types to SQL data types. It provides data query and retrieval facilities that significantly reduce development time. Hibernate’s design goal is to relieve the developer from 95% of common data persistence-related programming tasks by eliminating the need for manual, hand-crafted data processing using SQL and JDBC.  However, unlike many other persistence solutions, Hibernate does not hide the power of SQL from you and guarantees that your investment in relational technology and knowledge is as valid as always.


Above diagram explains the Hibernate architecture broadly. Use of Hibernate to persist data at first we will need an Entity class (mapped with database table) that will be instantiated by created by Hibernate, an instance of SessionFactory will be made. Factory design pattern is implemented by SessionFactory and it loads hibernate.cfg.xml file. Session object that is made from SessionFactory object is acted as a single connection with database, this connection is made by an instance of Session interface. Transaction API in Hibernate abstracts the JDBC or JTA transaction to the application.

  • Configuration : Configuration instance is used to provide the application to assign properties and mapped the documents when the SessionFactory is creating.

  • SessionFactory : SessionFactory is responsible for creating a Session instances to communicate with the database. SessionFactory object is a thread safe (immutable) and it is created once as per database.

  • TransactionFactory : TransactionFactory is responsible for generating a Transaction instances.

  • ConnectionProvider : Using ConnectionProvider Hibernate obtains a JDBC connections.

  • Session : Session interface is a major runtime interface between an Application and Hibernate. Main functionality of Session is to create, read, and delete operations of the mapped entity classe's instance.

  • Query : This interface represents a Hibernate query as Object-Oriented. An instance of Query is found by Session.createQuery().

  • Criteria : Criteria is used to retrieve entities by criterion objects.

  • Components of Hibernate Architecture: There are three main components of Hibernate Architecture :
    • Connection Management : This service allows database connection management in an effective manner.
    • Transaction Management : This service allows for executing a several database statements at a time.
    • Object Relational Mapping : ORM technique is used for mapping the data representation from an object-oriented model to a relational database.

When Hibernate is used with the above all three components then it is called FullCream architecture while it is called Lite architecture if there is only ORM component is used.

Why is Hibernate better than JDBC

1) Relational Persistence for JAVA
Working with both Object-Oriented software and Relational Database is complicated task with JDBC because there is mismatch between how data is represented in objects versus relational database. So with JDBC, developer has to write code to map an object model's data representation to a relational data model and its corresponding database schema. Hibernate is flexible and powerful ORM solution to map Java classes to database tables. Hibernate itself takes care of this mapping using XML files so developer does not need to write code for this.

2) Transparent Persistence
The automatic mapping of Java objects with database tables and vice versa is called Transparent Persistence. Hibernate provides transparent persistence and developer does not need to write code explicitly to map database tables tuples to application objects during interaction with RDBMS. With JDBC this conversion is to be taken care of by the developer manually with lines of code.

3) Support for Query Language
JDBC supports only native Structured Query Language (SQL). Developer has to find out the efficient way to access database, i.e to select effective query from a number of queries to perform same task. Hibernate provides a powerful query language Hibernate Query Language (independent from type of database) that is expressed in a familiar SQL like syntax and includes full support for polymorphic queries. Hibernate also supports native SQL statements. It also selects an effective way to perform a database manipulation task for an application.

4) Database Dependent Code
Application using JDBC to handle persistent data (database tables) having database specific code in large amount. The code written to map table data to application objects and vice versa is actually to map table fields to object properties. As table changed or database changed then it’s essential to change object structure as well as to change code written to map table-to-object/object-to-table. Hibernate provides this mapping itself. The actual mapping between tables and application objects is done in XML files. If there is change in Database or in any table then the only need to change XML file properties.

5) Maintenance Cost
With JDBC, it is developer’s responsibility to handle JDBC result set and convert it to Java objects through code to use this persistent data in application. So with JDBC, mapping between Java objects and database tables is done manually. Hibernate reduces lines of code by maintaining object-table mapping itself and returns result to application in form of Java objects. It relieves programmer from manual handling of persistent data, hence reducing the development time and maintenance cost.

6) Optimize Performance
Caching is retention of data, usually in application to reduce disk access. Hibernate, with Transparent Persistence, cache is set to application work space. Relational tuples are moved to this cache as a result of query. It improves performance if client application reads same data many times for same write. Automatic Transparent Persistence allows the developer to concentrate more on business logic rather than this application code. With JDBC, caching is maintained by hand-coding.

7) Automatic Versioning and Time Stamping
By database versioning one can be assured that the changes done by one person is not being roll backed by another one unintentionally. Hibernate enables developer to define version type field to application, due to this defined field Hibernate updates version field of database table every time relational tuple is updated in form of Java class object to that table. So if two users retrieve same tuple and then modify it and one user save this modified tuple to database, version is automatically updated for this tuple by Hibernate. When other user tries to save updated tuple to database then it does not allow to save it because this user does not has updated data. In JDBC there is no check that always every user has updated data. This check has to be added by the developer.

8) Open-Source, Zero-Cost Product License
Hibernate is an open source and free to use for both development and production deployments.

9) Enterprise-Class Reliability and Scalability
Hibernate scales well in any environment, no matter if use it in-house Intranet that serves hundreds of users or for mission-critical applications that serve hundreds of thousands. JDBC can not be scaled easily.

Advantages and Disadvantages of Using Hibernate

Advantages of Hibernate

  • Hibernate is better than plain JDBC: You can use Hibernate which generates the SQL on the fly and then automatically executes the necessary SQL statements. This saves a lot of development and debugging time of the developer. Writing JDBC statement, setting the parameters, executing query and processing the result by hand is lot of work. Hibernate will save all tedious efforts.

  • Mapping of Domain object to relational database: Hibernate maps your domain object with the relational database.     Now you can concentrate on your business logic rather than managing the data in database.

  • Layered architecture: Hibernate is layers architecture and you can use the components as per your application need.

  • JPA Provider: Hibernate can work as JPA     provider in JPA based applications.

  • Standard ORM: Hibernate is standard ORM solutions and it also supports JPA.

  • Database Independent: Hibernate is database independent and you can use any database of your choice.

  • Caching Framework: There are many caching framework that works with Hibernate. You can use any one in your application to improve the performance of your application.

Disadvantages of Hibernate

  • Lots of API to learn: A lot of effort is required to learn Hibernate. So, not very easy to learn hibernate easily.

  • Debugging: Sometimes debugging and performance tuning becomes difficult.

  • Slower than JDBC: Hibernate is slower than pure JDBC as it is generating lots of SQL statements in runtime.

  • Not suitable for Batch processing: It advisable to use pure JDBC for batch processing.

Hibernate Configuration

Hibernate configuration is managed by an instance of org.hibernate.cfg.Configuration. An instance of org.hibernate.cfg.Configuration represents an entire set of mappings of an application’s Java types to an SQL database. The org.hibernate.cfg.Configuration is used to build an immutable org.hibernate.SessionFactory. The mappings are compiled from various XML mapping files or from Java 5 Annotations.
Hibernate provides following types of configurations
  1. hibernate.cfg.xml – A standard XML file which contains hibernate configuration and which resides in root of application’s CLASSPATH
  2. – A Java compliant property file which holds key value pair for different hibernate configuration strings.
  3. Programmatic configuration – This is the manual approach. The configuration can be defined in Java class.

Fetching strategies that can increase Performance

Hibernate uses a fetching strategy to retrieve associated objects if the application needs to navigate the association. Fetch strategies can be declared in the O/R mapping metadata, or over-ridden by a particular HQL or Criteria query.

Hibernate defines the following fetching strategies:
  • Join fetching: Hibernate retrieves the associated instance or collection in the same SELECT, using an OUTER JOIN.
  • Select fetching: a second SELECT is used to retrieve the associated entity or collection. Unless you explicitly disable lazy fetching by specifying lazy="false", this second select will only be executed when you access the association.
  • Subselect fetching: a second SELECT is used to retrieve the associated collections for all entities retrieved in a previous query or fetch. Unless you explicitly disable lazy fetching by specifying lazy="false", this second select will only be executed when you access the association.
Batch fetching: an optimization strategy for select fetching. Hibernate retrieves a batch of entity instances or collections in a single SELECT by specifying a list of primary or foreign keys.
Categories: , , , ,

1 comment:

  1. Java Online Training Java Online Training Java Online Training Java Online Training Java Online Training Java Online Training

    Hibernate Online Training Hibernate Online Training Spring Online Training Spring Online Training Spring Batch Training Online Spring Batch Training Online


Find me on Facebook! Follow me on Twitter!