MyEclipse Logo

MyEclipse Hibernate and Spring Tutorial

Table of Contents

download the latest MyEclipse version

help and support

1. Introduction

Welcome to the MyEclipse Hibernate and Spring tutorial. This tutorial is meant to be a quick overview of how using both Hibernate and Spring in the same project works in MyEclipse.

Before starting this tutorial, we encourage you to start with first the individual Introduction to Hibernate and Introduction to Spring tutorials in the Resources section that covers the individual technologies in more detail. The project used in this tutorial will be similar to the one used in the Introduction to Hibernate.

The use of Spring with Hibernate will be shown in this tutorial by creating a layer of abstraction between our persistence code (Hibernate) and our business logic. The business logic in most cases will be the "stuff the web application does", for simplicity sake, in this example it is our main method. By adding this level of abstraction, we can use Spring to control the real persistence engine that is plugged in behind the scenes and used by our business code (main method).

For small applications this may seem inconsequential, but when you start seeing how easy it is to swap out entire portions of your code base using Spring by simply adjusting references in your bean configuration file, it's easy to see how powerful this tool can become. For the most obvious case, it makes testing much easier. You are able to say swap in a persistence implementation that makes all it's calls to an embedded DBMS or maybe logs all it's activity. Then when the application is deployed to production, the persistence implementation is switched back to the code that makes use of the main DBMS and doesn't log anything for performance reasons.

There are a myriad of possibilities when using Spring.


2. Suggested Audience

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 and be familiar with Spring and dependency injection.

If the reader is unclear on how these individual technologies work, a much better place to start will be the individual Hibernate and Spring tutorials found in the Resources section below.

3. System Requirements

This tutorial was created with MyEclipse, the bundled Hibernate 3.x support and Spring 1.x libraries. If you are using a another version of MyEclipse, Hibernate or Spring, these screens and instructions will still be very similar.

However, if you notice portions of this tutorial looking different than the screens you are seeing, please let us know and we will make sure to resolve any inconsistencies.

4. Getting Started

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 go.

To get started with Hibernate and Spring 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 (Note: This is the same project we created in the Hibernate tutorial as mentioned above):

Figure 1. Creating a connection 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 and Spring-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 and Spring capabilities to that project from the MyEclipse menu, like so:

Figure 2. Creating a Hibernate and Spring-enabled project

5. Reverse Engineering

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 addition to that, because our project is a Hibernate-Spring project, MyEclipse will give you the option to generate "Spring DAOs" instead of just plain DAOs during the reverse engineering. This will automatically create Spring beans for the DAOs that have their sessionFactory properties correctly configured to the existing Spring reference to the Hibernate SessionFactory.

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 use the 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:

Figure 3. Reverse-engineering our user table into Hibernate (Java) objects

6. Writing and Running Hibernate-Spring Code

Now that we have our project setup we are ready to start writing some code. There are going to be two pieces of code we write:

  1. Business Logic: Our main method that represents the code we actually write for our applications.
  2. Persistence Layer: This is the abstracted portion of our application that our business logic relies on for database functions. If all our business logic ever uses is the persistence layer, that allows us to hide some of the details of how it all works behind this layer. We are
    going to use Spring to populate our persistence layer with the necessary DAO reference it needs to actually perform the database operations, but the benefit here is that our business logic doesn't need to know anything about that.

Let's first start with the persistence layer since that is what sits between all the code we just generated and the code we will write in the business logic layer. The code for our PersistenceLayer class will look like this:

package com.myeclipse.hibernatespring;

public class PersistenceLayer {
    private UserDAO userDAO;

    public UserDAO getUserDAO() {
        return userDAO;

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    public void addUser(User user) {;
    public User findUserById(Integer id) {
        return userDAO.findById(id);
    public void updateUser(User user) {
    public void deleteUser(User user) {
Figure 4. Implementation of our PersistenceLayer class

The code is fairly straight forward, but let's recap. The purpose of this class is to get a UserDAO instance injected into it by Spring and then it uses that reference under the covers to actually implement the save/find/update and delete operations without the calling code's knowledge. This allows us to easily and quickly modify the persistence code in the application without changing the application code at all. More specifically, if we ever wanted to change how PersistenceLayer was implemented, say to manage exceptions better, transactions or anything else, we could simply edit this class and be done, there would be no need to refactor the entire application as long as all the method signatures stayed the same.

The other important thing to note is that since this layer of abstraction is loosely coupled with the persistence code from the application code, it's easy for us to use Spring to inject say a testing UserDAO implementation that simulates DB operations but doesn't actually perform them. There are all sorts of advantages to this design.

Now that we have PersistenceLayer implemented, let's take a look at the business logic (or our main method implementation):

package com.myeclipse.hibernatespring;

public class BusinessLogic {
    public static void main(String[] args) {
        /* 1. Create a new user */
        Integer id = new Integer(1);
        User user = new User();

        /* 2. Load the Spring bean configuration and create a bean factory */
        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource(

        /* 3. Create instance of PersistenceLayer */
        PersistenceLayer persistenceLayer = (PersistenceLayer) beanFactory

        /* 4. Save the new user to the database */

        /* 5. Confirm that our user was saved */
        User userLoadedFromDB = persistenceLayer.findUserById(id);
        System.out.println("User Loaded from DB [username="
                + userLoadedFromDB.getUsername() + ", password="
                + userLoadedFromDB.getPassword() + ", firstName="
                + userLoadedFromDB.getFirstName() + ", lastName="
                + userLoadedFromDB.getLastName() + "]");

        /* 6. Update the user */

        /* 7. Confirm that the update worked */
        User userLoadedFromDBAgain = persistenceLayer
        System.out.println("User Loaded from DB Again [firstName="
                + userLoadedFromDBAgain.getFirstName() + "]");

        /* 8. Delete the user */
Figure 5. Implementation of our business logic (main) class

Let's take a quick look at what this code is doing:

  1. Create a new user to insert into the database. This is just a POJO, nothing interesting. We are using the User POJO that MyEclipse generated for us when we reverse-engineered the user table from the database.
  2. Create a bean factory. What this does is read in the Spring bean configuration file and then provide you an instance to a "factory" that can be used to get instances of beans based on the specification from that file. This is the Spring "entry point" as it were.
  3. Create an instance of PersistenceLayer so we can perform DB operations. Notice how we have to use the bean factory to get the instance in order to have the UserDAO reference populated correctly.
  4. Save the new user to the DB using the PersistenceLayer instance we created. Notice how the BusinessLogic class has no knowledge of the UserDAO class or any underlying details because all the calls are going through the PersistenceLayer
  5. Now we actually reload the user from the database using the ID that was assigned to it when it was saved and check to make sure all the values are right.
  6. Now let's update the user name to see if updating records will work.
  7. We reload the user from the database again to make sure that the updated change we made stuck.
  8. Delete the user from the DB.

Some of you might be asking yourself: " How does the PersistenceLayer get a reference to UserDAO in order to actually execute those persistence operations? I don't see that code anywhere." and the answer to that is: We need to create a new Spring bean (PersistenceLayer) that will get the correct UserDAO instance injected into it at runtime so the code will run correctly. Doing that looks something like this:

Figure 6. Creating the persistenceLayer Spring bean that our business logic will use

Now our application should be ready to run, let's recap the major portions of what we have done:

  • Reverse-engineered our database using MyEclipse and Hibernate
  • Wrote a layer of abstraction between our persistence technology (Hibernate) and our business logic (main method) that will be managed by Spring.
  • Write our business logic (main method) to make use of the abstracted persistence layer to add/find/update and delete a user from the database.
  • Created a new Spring bean configuration entry for our abstracted persistence layer so it gets the correct reference to the DAO generated by MyEclipse automatically in order to communicate with the DB.

Now we can actually run our BusinessLogic class and see our application in action:

Figure 7. Running our example business logic code

Very nice, it worked correctly just as we had hoped! We can see we were able to store, update and delete our user from the database with just a few lines of code. Imagine how easy writing the rest of this application will be since all we need to do is use our PersistenceLayer.

7. Working with Hibernate Annotations and Spring

MyEclipse provides Hibernate Annotations support for both standalone Hibernate projects and for Spring Hibernate projects. The following section presents a brief overview of our support for Hibernate Annotations and Spring.

Creating a Hibernate Spring project with Annotations Support

Follow the steps in Figure 2 above to create a Hibernate and Spring enabled project. The following changes are necessary to enable annotation support.

  • When adding Hibernate capabilities, to your project, be sure to use Hibernate 3.x and select Enable Hibernate Annotations Support.
    Figure 8. Adding Hibernate capabilities with Annotations support
  • When adding Spring capabilities on page 3, select Enable Hibernate Annotations support. This will create an AnnotationSessionFactoryBean instead of a LocalSessionFactoryBean, the former is required when working with annotations.
    Figure 9. Adding Spring capabilities with Annotations support
    Figure 10. AnnotationSessionFactoryBean generated by the Spring capabilities wizard

Reverse Engineering

  • The Hibernate project properties page in a project setup using the above process will list both LocalSessionFactoryBean beans as well as AnnotationSessionFactoryBean beans in the SessionFactory Bean Id combo when you select a Spring beans configuration file.

    For annotations support during reverse engineering, you must either select a Hibernate configuration file as your Active configuration file or a Spring beans configuration file and an AnnotationSessionFactoryBean for the SessionFactory.

    Figure 11. Hibernate project property page
  • The session factory beans Ids presented for Spring DAOs will depend on whether you've chosen to generate annotated POJOs or Hibernate mapping files. If you chose to generate annotated POJOs, then only AnnotationSessionFactoryBeans are presented in the SessionFactory Id combo, else both LocalSessionFactoryBean beans and AnnotationSessionFactoryBean beans are listed.
    Figure 12. Hibernate Annotations reverse engineering

Other aspects of our Hibernate Annotations and Spring support are no different from what has already been covered in the earlier sections of this tutorial.

8. Conclusion

As was shown in the Introduction to Hibernate and Introduction to Spring tutorials (see Resources) working with these technologies in MyEclipse is very straight forward and easy. What we tried to show in this tutorial was not only why using these technologies together is a good idea, but how MyEclipse will even help you develop using the technologies in the same project.

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.

9. FAQ

None at this time

10. Resources

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:



11. Feedback

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 our Documentation Forum.  Please be sure to let us know which piece of MyEclipse material you are commenting on so we can quickly pinpoint any issues that arise.