Object Persistence with Hibernate

Hibernate, a component of the JBoss middleware system suite
of products allows you to develop persistent classes following object-oriented
paradigm -involving inheritance, association, composition, polymorphism and
collections. Hibernate makes it seem as if your database contains POJO (Plain
Old Java Objects), without having to worry about how to get them out of and
persist them back. Positioned as a layer between your application and your
database, Hibernate takes care of loading and saving the objects. It's a boon
to Java developers whose main purpose is to focus on business logic without
worrying about the underlying database.

Hibernate is intended to relieve the developer from common
data persistence related programming tasks, unlike coding manually with SQL and
the JDBC API. It offloads you from manual JDBC result set handling and object
conversion, and keeps your application portable to all relational databases.
Hibernate takes care of the inevitable mismatch between your object-oriented
code and the relational database requirements. It helps you to express queries
in its own portable SQL extension (HQL), as well as in native SQL, thus,
offering multiple query options, further you can fire polymorphic queries. With
Hibernate, you don't even need tables as it can map entities and particular
properties to SQL expressions.

In this series of two articles, we'll first give an
overview of Hibernate O/R mapping framework and then walk you through the code.

Why use Hibernate?

Object persistence is not new. There are many commercial offerings for the
popular EJB specification but they often end up being complex, and require
special treatment by the implementing code. Hibernate is a lightweight solution
which offers transparent persistence without forcing the developer to implement
any special interfaces or extend from the framework API.  

Hibernate is licensed under the GNU public license. It
supports mappings for collections and dependent objects to the underlying
database tables. There's no extra code generation. Hibernate implements
persistence API and query language defined by EJB 3.0 specifications. Hibernate
ships with two open source connection pools. With Hibernate, you can save a lot
of redundant data-access code, you don't have to write complex SQL queries,
and it just requires a few lines to make a connection to a database, select some
results, and print them out to the screen or some log file. In a nutshell, you
don't need to write that extra code to persist your business logic leading to
automation and writing less code.

Streamlining App development 

For any enterprise application development a lot of time is utilized for
designing and maintaining a persistence layer. If changes are made to the
underlying database schema, it can be expensive to propagate those changes to
the rest of the application, both in terms of time and efforts. This is exactly
where Hibernate steps in to fill this gap, providing an easy-to-use and powerful
object-relational persistence framework. Your business logic is free from any
data access code. Hibernate will help us to store the data in permanent storage
without any hassles about choosing the kind of storage, installation, or
configuration. Hibernate allows us to store any kind of objects. Powered by
runtime reflection to determine the persistent properties of a class, the
overhead is much less than traditional JDBC calls. Hibernate can make multiple
optimizations when interacting with the database, including object caching,
efficient outer join fetching and executing SQL statements only when needed. It
is difficult to achieve this level of sophistication with hard-coded JDBC.
Further on scalability standpoint, unlike EJB, Hibernate does not automatically
do instance-pooling and, there's no sharing of objects between concurrent
threads. Developers utilizing Hibernate can greatly reduce the amount of time
and efforts needed to code, test, and deploy applications.

Hibernate sits below the middle tier in the hierarchy

What you can do

 The Hibernate project is available in a number of different packages
ranging from Hibernate core, annotations, entity manager (to interact with EJB
3.0 EntityManager API) to NHibernate, which helps in persisting plain .NET
objects.  Hibernate doesn't expect you to implement any special
interfaces or extent form any predefined class. All you need to do is create an
XML mapping document directing Hibernate the classes that you want to store in a
database, and how they relate to the tables and columns in the underlying
database.

Then you can ask it to fetch data as objects, or store
objects as data. Hibernate requires metadata that governs the transformation of
data from one representation to the other and vice versa. Most of the time in
Hibernate 2.x, mapping metadata is declared in XML documents. Serialized
persistent objects may be selectively re-associated with Hibernate, and their
state synchronized with the database. Modifications to objects associated with a
transaction are automatically detected and propagated to the database. Hibernate
supports bidirectional association. Further, Hibernate supports Java arrays,
collections framework and user-defined types. As a developer you don't need to
worry about constraint transparency such as foreign key violations; primary keys
may span multiple properties of a class, they all are taken care by the
framework itself. With Hibernate, query results may be accessed using a
scrollable result set. Hibernate supports sub queries, joins, stored procedures,
projection, aggregation and grouping.

Conclusion

Established in 2001, Hibernate has evolved as a mature and robust
technology. It offers the developers clear, concise and powerful tools for
working with relational databases. Hibernate can work with a servlet container (eg
Tomcat), an app server such as JBoss or even in standalone applications. As a
developer, you can look at

Hibernate as a way to persist your business logic outside
the container. Hibernate quickly adapts to your development process, no matter
you are starting with a design from scratch or already working with an existing
database. Moreover, it supports multiple application architectures. Stay tuned
for the next article in this series where we'll get our hands dirty with some
simple Hibernate code.

Kunal Jaggi