This is a tutorial to build a very simple pizzashop Spring MVC, Hibernate and MySQL application. The main page shows all pizza rows stored on a database table:

Technology in Java world moves very fast. Using straight Hibernate might no longer be preferable since Java EE 5 introduces JPA (Java Persistence API) but it’s still good to learn anyway. Spring MVC and Hibernate is one of the most popular Java libraries used out there.

Tools / Environment Required
If you’re just starting fresh and don’t have most of the tools below just install JDK, STS (Springsource Tools Suite) and MySQL server, everything else is bundled within them.

• Spring 3.2
• Maven 3.0.4 (A build, packaging and dependency management tool in case you’re wondering. Maven is very handy so you don’t have to pull hairs managing jars)
• Hibernate 4.2
• JDK 1.6
• MySQL Server 5.6 (hint: use XAMPP to have a running MySQL in no time)

Project Setup and Boilerplate

1. First, create new Maven project on STS. Skip archetype selection. Pick maven group id, artifact id and select packaging to war.

2. By default Maven will use JDK 1.5, re-configure it to use 1.6. Add following maven-compiler-plugin section to pom.xml under element. Ensure the change takes effect by updating maven project settings (right click on project -> Maven -> Update project…).

   
     
       
         org.apache.maven.plugins
         maven-compiler-plugin
         3.1
         
           1.6
           1.6
         
       
     
   
   

3. Add Spring, Hibernate, Java EE and MySQL maven dependencies to pom.xml. Place following under element.

   
     3.2.3.RELEASE
     4.2.2.Final
   
   
   
     
     
       org.springframework
       spring-context
       ${spring.version}
     
     
       org.springframework
       spring-webmvc
       ${spring.version}
     
     
       org.springframework
       spring-orm
       ${spring.version}
     
     
     
     
       org.hibernate
       hibernate-core
       ${hibernate.version}
     
     
     
     
       javax.servlet
       servlet-api
       2.5
       provided
     
     
       jstl
       jstl
       1.2
     
     
     
     
       commons-dbcp
       commons-dbcp
       1.4
     
     
       mysql
       mysql-connector-java
       5.1.25
     
     
   
   

4. Create a web.xml descriptor file with Spring MVC servlet setup on it, place it on src/main/webapp/WEB-INF

   
   
   
     
       appServlet
       org.springframework.web.servlet.DispatcherServlet
       
         contextConfigLocation
         /WEB-INF/servlet-context.xml
       
       1
     
      
     
       appServlet
       /
     
     
   
   

5. Create src/main/webapp/WEB-INF/servlet-context.xml Spring bean config file for dispatcher servlet. We configure few important stuffs in here:
   • JDBC MySQL Datasource. Notice Apache Commons DBCP Connection Pool is used.
   • to resolve “home” view name returned by controller handlers into “/WEB-INF/home.jsp”

   
   
   
     
     
   
     
     
       
       
     
     
     
     
     
     
     
       
       
       
       
       
     
     
     
     
       
       
         
           com.gerrytan.pizzashop
         
       
       
         
           hibernate.dialect=org.hibernate.dialect.MySQLDialect
         
       
     
     
     
     
       
     
     
     
     
   
   
   

The Business Functionality

1. Now all the boilerplate code done, we can start coding the business functionality. For this simple app we will have a pizza database table with just id, name and price column. Create the Pizza entity class representing the table

   package com.gerrytan.pizzashop;
   // imports ..
   
   
   (name = "pizza")
   public class Pizza {
     @Id  private long id;
     private String name;
     private double price;
     /* getters & setters */
   }
   

2. Create a DAO class to obtain Pizza entity persisted on database. Note that we won’t create service layer classes for the sake of simplicity (on real-life complex business application adding service layer is a good practice).

   package com.gerrytan.pizzashop;
   // imports..
   
   
   s({"unchecked", "rawtypes"})
   public class PizzaDAO {
      private SessionFactory sessionFactory;
     
     /**
      *  annotation below will trigger Spring Hibernate transaction manager to automatically create
      * a hibernate session. See src/main/webapp/WEB-INF/servlet-context.xml
      */
     
     public List findAll() {
       Session session = sessionFactory.getCurrentSession();
       List pizzas = session.createQuery("from Pizza").list();
       return pizzas;
     }
   }
   

3. Create a Spring MVC controller to handle request from the main page. Note that PizzaDAO reference is injected, and after collection of Pizza entity objects are obtained it’s passed to the view using Model object.

   package com.gerrytan.pizzashop;
   // imports..
   
   
   ("/")
   public class PizzaController {
     
      private PizzaDAO pizzaDAO;
     
     /**
      * This handler method is invoked when
      * http://localhost:8080/pizzashop is requested.
      * The method returns view name "index"
      * which will be resolved into /WEB-INF/index.jsp.
      *  See src/main/webapp/WEB-INF/servlet-context.xml
      */
     (method = RequestMethod.GET)
     public String list(Model model) {
       List pizzas = pizzaDAO.findAll();
       model.addAttribute("pizzas", pizzas);
       return "index";
     }
   }
   

4. Add a JSP view to list all the pizza entities passed by the controller
   src/main/webapp/WEB-INF/index.jsp

   <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
   <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
   
   
   
   
   
   
   
           
   List of All Pizzas
           

   • ${p.id} - ${p.name} - ${p.price}

5. And finally prepare MySQL pizzashop database schema:

   CREATE SCHEMA `pizzashop`;

   And pizza table:

   CREATE  TABLE `pizzashop`.`pizza` (
     `id` BIGINT NOT NULL AUTO_INCREMENT ,
     `name` VARCHAR(45) NULL ,
     `price` DOUBLE NULL ,
     PRIMARY KEY (`id`) );
   

   And insert some data into it

   INSERT INTO `pizzashop`.`pizza` (`id`, `name`, `price`) VALUES ('I', 'Italian', '7.5');
   INSERT INTO `pizzashop`.`pizza` (`id`, `name`, `price`) VALUES ('2', 'Thin Crust', '6');
   INSERT INTO `pizzashop`.`pizza` (`id`, `name`, `price`) VALUES ('3', 'Pepperoni', '6.2');
   

   It is assumed you have MySQL server running on your local machine (localhost) on the default port 3306. The name of the schema is pizzashop and table pizza. Have a look at Spring beans configuration section above to reconfigure this.

Running The Code

1. The easiest way to run your code is using in-memory Maven Tomcat plugin. It will launch on-the-fly Tomcat server with your code deployed. Make sure your project is selected on the project exploded and setup a maven run configuration on STS. Go to Run -> Run Configurations.. and create a new maven build entry like this:
   
2. Click Run and navigate your browser to http://localhost:8080/pizzashop

Download The Source Code

Source code for this demonstration can be obtained using git:

git clone https://bitbucket.org/gerrytan/pizzashop.git -b basic

Congratz!

Well done on making it this far. Hopefully that was a quick and nice introduction to Spring MVC + Hibernate + MySQL and you can see how the tedious database to java class mapping is now simplified. You might have lots of questions in your mind by now — feel free to ask in the comment section below. Following are few official references and community article links you can browse around:

• Hibernate 4.2.2
• Java EE 5 Tutorial & Java EE 6 Tutorial
• Maven in 5 Minutes
• Lazy initialization – a Hibernate problem, article by Sebastian Hennebrueder.

See Also

• Hibernate One To Many Entity Relationship
• Creating a Minimal Spring MVC, JPA / Hibernate and MySQL Project
• Spring Declarative Transaction Management With JDK Proxy vs AspectJ