Introduction to Hibernate

Hibernate is an open source object/relational mapping tool for Java. Hibernate lets you develop persistent classes following common Java idiom - including association, inheritance, polymorphism, composition and the Java collections framework.

Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities and can significantly reduce development time otherwise spent with manual data handling in SQL and JDBC.

Hibernates goal is to relieve the developer from 95 percent of common data persistence related programming tasks.

Hibernate is Free Software. The LGPL license is sufficiently flexible to allow the use of Hibernate in both open source and commercial projects (see the LicenseFAQ for details). Hibernate is available for download at http://www.hibernate.org/. This tutorial aims to provide insight into Hibernate version 3.0RC and its usage

Some of the main features of hibernate are listed below and we have tried to explain some of them in detail later in this tutorial.


Transparent persistence without byte code processing
            Transparent persistence
            JavaBeans style properties are persisted
            No build-time source or byte code generation / processing
            Support for extensive subset of Java collections API
            Collection instance management
            Extensible type system
            Constraint transparency
            Automatic Dirty Checking
            Detached object support
Object-oriented query language
            Powerful object-oriented query language
            Full support for polymorphic queries
            New Criteria queries
            Native SQL queries
Object / Relational mappings
            Three different O/R mapping strategies
            Multiple-objects to single-row mapping
            Polymorphic associations
            Bidirectional associations
            Association filtering
            Collections of basic types
            Indexed collections
            Composite Collection Elements
            Lifecycle objects
Automatic primary key generation
            Multiple synthetic key generation strategies
            Support for application assigned identifiers
            Support for composite keys
Object/Relational mapping definition
            XML mapping documents
            Human-readable format
            XDoclet support
HDLCA (Hibernate Dual-Layer Cache Architecture)
            Thread safeness
            Non-blocking data access
            Session level cache
            Optional second-level cache
            Optional query cache
            Works well with others
High performance
           Lazy initialization
            Outer join fetching
            Batch fetching
            Support for optimistic locking with versioning/timestamping
            Highly scalable architecture
            High performance
            No "special" database tables
            SQL generated at system initialization time
            (Optional) Internal connection pooling and   PreparedStatement caching
J2EE integration
            JMX support
            Integration with J2EE architecture (optional)
            New JCA support
High level architecture of Hibernate can be described as shown in following illustration.

Hibernate makes use of persistent objects commonly called as POJO (POJO = "Plain Old Java Object".) along with XML mapping documents for persisting objects to the database layer. The term POJO refers to a normal Java objects that does not serve any other special role or implement any special interfaces of any of the Java frameworks (EJB, JDBC, DAO, JDO, etc...).

Rather than utilize byte code processing or code generation, Hibernate uses runtime reflection to determine the persistent properties of a class. The objects to be persisted are defined in a mapping document, which serves to describe the persistent fields and associations, as well as any subclasses or proxies of the persistent object. The mapping documents are compiled at application startup time and provide the framework with necessary information for a class. Additionally, they are used in support operations, such as generating the database schema or creating stub Java source files.

Typical Hibernate code

sessionFactory = new Configuration().configure().buildSessionFactory(); Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); Customer newCustomer = new Customer(); newCustomer.setName("New Customer"); newCustomer.setAddress("Address of New Customer"); newCustomer.setEmailId("NewCustomer@NewCustomer.com"); session.save(newCustomer); tx.commit(); session.close();

First step is hibernate application is to retrieve Hibernate Session; Hibernate Session is the main runtime interface between a Java application and Hibernate. SessionFactory allows applications to create hibernate session by reading hibernate configurations file hibernate.cfg.xml.

After specifying transaction boundaries, application can make use of persistent java objects and use session for persisting to the databases.