Welcome to the MyEclipse Introduction to Hibernate tutorial. In
this tutorial we are going to cover some of the basic features of
using the Hibernate framework, such as OR-mapping from within
At it's core, Hibernate is an OR-mapping technology that is used
to map database structures to Java objects at runtime. Using a
persistence framework like Hibernate allows developers to focus
on writing business logic instead of writing an accurate and
performant persistence layer (which includes, DAOs, SQL queries,
JDBC code, connection management, etc.).
However, to begin using Hibernate, you normally must generate the
proper persistence mappings for Hibernate to manage, set up the
database connection information and code the DAOs that read or
write your mapped entities. Fortunately, MyEclipse developers
don't need to do any of that because MyEclipse will generate all
of this code for you. And that bit of code automation frees you
up for the most important task of all: writing your application
This tutorial is intended for developers who are somewhat
familiar with either MyEclipse or Eclipse so you are expected to
recognize navigation within the IDE and understand some of the
more common concepts like "Views". Additionally,
developers should be familiar with persistence in Java (JDBC,
EJB, iBatis, JPA, etc.) to be able to understand the role
Hibernate plays more quickly. While this tutorial will also
introduce some of the basics of Hibernate, it is not intended to
replace the detailed Hibernate Reference Guide found on the
Hibernate site and in the
below. There is a lot of functionality in Hibernate that allows
it to scale to support enterprise-class applications, and those
details can be learned from reading through the reference or a
good Hibernate book.
If either MyEclipse or Hibernate makes you feel uncomfortable,
this introductory tutorial should provide you with the basics of
both. If you wish to learn more about either MyEclipse or
Hibernate please have a look at either our product
Documentation for more
material or our
This tutorial was created with MyEclipse and the bundled
Hibernate 3 libraries. However, if you notice portions
of this tutorial looking different than the screens you are
let us know and we will make sure to
resolve any inconsistencies.
In the early years of Java database and web programming,
developers accessed their databases using the different classes
provided by the
java.sql package; you may even remember doing this
yourself. Such usage consisted basically of getting a
Driver from the
DriverManager, creating a
Connection, using the
Connection, handling exceptions properly, closing the
connection and so on. A common problem at this stage was
forgetting to clean up database connections and getting
connection exceptions in your applications after they had been
running for a while.
A few years later "connection pools" became a big topic
since they allowed the developer to stop worrying about creating
and managing (cleaning up) DB connections and instead focusing on
their SQL and
ResultSet parsing code. Suddenly, we had mostly solved
the problem of connection exceptions to the database in
long-running applications. However, it was still common to see
hundreds of lines of boiler-plate code used to populate queries
with values and parse the
ResultSets returned from SQL queries.
A few more years went by and someone had an idea to automatically
ResultSet results directly to Java objects, which mostly
solved the problem of all the redundant boiler-plate parsing
code. At that point in time Java database development had taken a
several big steps forward and was getting much simpler. Then
Hibernate came into the picture.
With Hibernate came the idea that not only would it continuing
doing all these automated things for you, but it would also
manage the state of your objects in memory and
it would worry about when and how object values would be
"read from" or "written to" the database. Now
all the sudden developers were dealing completely with objects
(or mapped objects) and letting Hibernate handle everything else.
Developers were no longer writing JDBC and SQL code at all.
Instead they were using code that automatically did all that work
At the time Hibernate came on the scene, the other persistence
technology out there was EJB 2.x. Hibernate's timing, ease of use
and power all contributed to one of the fastest uptakes of a
technology that the Java space that had been seen in quite
In this tutorial we are going to take a look at how using
MyEclipse with Hibernate can make your life even easier than
using Hibernate alone. In fact, MyEclipse removes the need to
write any of the Hibernate mappings or configuration files by
completely generating the persistence side of your Java
application in just a few seconds.
We will start off with a simple database that we will
reverse-engineer into a Hibernate-enabled project. Then, we will
write some simple Java code to utilize the Hibernate code that
MyEclipse generated automatically in order to store, retrieve and
update information in our database.
The project we create during this tutorial, as well as the
create-table SQL script for the database table we used, can be
found in our
Resources section below for those of you
that want to peak ahead. For the rest, we would highly encourage
you to follow along with the tutorial, creating the project as we
To get started with Hibernate in MyEclipse the first thing we
need is a connection to the database that we want to build our
application to use. In this particular case, it is an instance of
MySQL 5 with a sample
user table we've already created. We are also using the
MySQL Connector/J JDBC driver to connect to our install of MySQL.
So let's get started by creating a new connection, in MyEclipse,
to our database:
Now that we have a working connection to our database, the second
thing we need before we get started is a Hibernate-enabled
project (Java, Web, Web Service, etc). We can create such a
project by creating any of the supported types of base projects,
like a Java or Web project, then adding
Hibernate capabilities to that project from the
MyEclipse menu, like so:
Now that we have a database connection and a project properly
configured, the next thing for us to do is tell MyEclipse to
reverse-engineer our database table into Hibernate (Java) objects
and put them into our project.
In the example below we use the simplest form of
reverse-engineering, letting the wizard take all the default
values. However, for maximum control you could optionally
Next button and step through the wizard to select
details like primary key generation strategy, object names, types
and more. Let's reverse-engineer our table now:
Now that our table has been reverse-engineered into our project,
there are all sorts of Hibernate tools we can use in MyEclipse to
work with those objects (even without writing code!). The first
tool we will look at is the HQL Editor.
The HQL Editor, and other HQL views in the Hibernate perspective,
assist in the development, evaluation or testing of HQL queries.
HQL is a SQL-like language called "Hibernate Query
Language". It can sometimes look like simplified SQL and
uses object names and references instead of table and column
names. A great place to learn about HQL is the Hibernate
Reference Document in our
With the HQL Editor you can actually write HQL on the fly into
the editor, then run it. The editor, utilizing the objects that
MyEclipse has reverse-engineered from the database, will actually
translate the query to SQL (shown in the bottom right) and then
run it. The result is returned in Java objects and is shown
in the bottom left corner. Let's have a look at how this works
It is important to be familiar with the tools that MyEclipse
provides, but since we've just taken a look at some of the nicer
tools included, it's time to start writing our own code!
As mentioned before, one of the nicest parts of using MyEclipse
to work with Hibernate is the fact that it generates all the
boiler-plate Hibernate mapping and even DAO code for you. This
means that after you are done reverse-engineering a database you
are ready to start writing your application to read, write and
update objects in your database.
In this tutorial we will write a series of simple methods that do
3 things in the following order:
Create a new
User and add him to the database
User from the database, using his primary key, and
print out its information
User's values, update that record in the database and
print the changed values to verify
The three methods (
addUser, listUser, changeUser) are all called from the
main method in our new class. To better understand how
this Hibernate code is written, let's create that class, put
those methods in the class (using copy & paste) and then
review them line-by-line:
After looking at that code we can see how straight forward
everything is. We use the DAO classes that MyEclipse generated
for us to get, update and save our objects to the database and
MyEclipse/Hibernate take care of all the other details for us. It
couldn't get much easier than this.
Now to the fun part, let's run the code and see if it actually
does the right thing:
Very nice, it worked correctly just as we had hoped! We used the
HQL Editor to query our database and make sure that our user was
saved to it. Additionally, we could have just as easily switched
to the Database Perspective and queried the database from there
to see that the user record was in the table.
While the application in this tutorial may seem simple, the
techniques and information provided is critical to understanding
both Hibernate and MyEclipse. The fundamentals presented in this
tutorial apply to pretty much any Hibernate-enabled application
you would want to develop: the core idea of object mapping to the
database. After getting these basics working, you are free to
enhance, extend or change your application in any way you need to
and be assured that MyEclipse will continue to help you develop
and extend it.
We hope you have found this tutorial helpful. If you had comments
about this tutorial or suggestions/questions for us, please
let us know. We always value our user's
feedback especially on educational materials such as these.
How does Hibernate compare to EJB
3 / JPA?
Can Hibernate scale to very large applications?
Hibernate 3.2 is actually JPA-compatible, implementing all the
new annotations that make JPA so automatic and painless to use.
So instead of using a commercial implementation of JPA, you can
use Hibernate and still keep all the standard JPA annotations
in your classes without any changes.
Do I need all the Hibernate libraries in my
application? There are a lot of them!
Yes. Actually the roots of Hibernate come from the two founders
own experiences working as consultants on large enterprise
applications. Hibernate is their vision of how persistence
should function in an application. Also a few years ago, Gavin
King, put out a challenge to the community to find hand-tweaked
JDBC SQL that executed a magnitude faster than the generated
SQL from Hibernate to make a point that the framework is very
focused on being functional, flexible and performant.
What is the "Session" in Hibernate?
Why do I need to bother with it?
Not necessarily. Hibernate is a very complex framework and
makes use of a lot of other 3rd party frameworks. Depending on
what you are doing with Hibernate it's possible that you don't
need a lot of the JARs that are in your build path. There is a
README that ships with Hibernate in the /lib directory
explaining which each library does if you really want to trim
back your deployment footprint.
Hibernate does a lot of "magic" under the covers.
Part of that magic is to monitor mapped object's state and see
if they have changed (e.g. a setter has been called) an then
persist the changed values to the database in a timely fashion.
In a small system you could imagine Hibernate managing all the
objects at a time, but in bigger enterprise systems where there
may be millions of mapped objects loaded at a time, a computer
simply wouldn't have enough memory or CPU cycles to process so
many entities. This is where the "session" comes into
play. A Hibernate session represents a container of all the
objects processed since that session has been opened. Most
folks find that making a session the length of a transaction
works for them, although for performance-critical applications
that might be too short of a span of time for the session to
exist when weighed against the cost of creating one. Another
Hibernate session design is to use a ServletFilter to open a
Hibernate session when a new HTTP session is created and then
close the Hibernate session when the HTTP session is destroyed.
For most small to mid-sized web applications running on a
server with a decent sized heap this is a great balance between
performance and memory requirements. Although you should always
be aware of what objects you are loading and saving to a
database, because if the session is left open, it's possible
those objects could be hanging around in memory.
Below are links to resources that we hope will help answer most
of the questions you could have while working your way through
this tutorial pertaining to Hibernate:
Hibernate Documentation (
We would like to hear from you! If you liked this tutorial, has
some suggestions or even some corrections for us please let us
know. We track all user feedback about our learning material in
Please be sure to let us know which piece of MyEclipse material
you are commenting on so we can quickly pinpoint any issues that