Spring MVC 4 - Hibernate 4 CRUD

This example builds on the last post, Spring MVC 4 - Java Config, where Spring Java configuration files replaced the standard Spring MVC template XML files created by STS in Eclipse. In addition, this code shows an end-to-end example of:

MySQL -> Hibernate -> Spring MVC -> JSP

A link to the code on GitHub is provided at the bottom of this post.  Here is a summary of the steps to complete the end to end use case:

1. Create a table in your database  using the SQL below.  This SQL creates a simple table with three columns.  This table will hold our trade strategies.  The type would contain an option trade type, and the name would contain a specific sub type.  For example, type could be "iron condor", and name could be "hedged high prob".

CREATE TABLE `strategy` (
    `ID` INT(6) UNSIGNED NOT NULL AUTO_INCREMENT,
    `TYPE` VARCHAR(20) NOT NULL,
    `NAME` VARCHAR(20) NOT NULL,
    PRIMARY KEY (`ID`)
)
COLLATE='utf8_general_ci'
ENGINE=InnoDB
AUTO_INCREMENT=8;

2. Create the Spring database configuration file to configure the Spring and Hibernate connectivity to our database where we created the strategy table.

package com.dtr.oas.config;

import java.util.Properties;
import javax.annotation.Resource;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate4.HibernateTransactionManager;
import org.springframework.orm.hibernate4.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@ComponentScan("com.dtr.oas")
@PropertySource("classpath:database.properties")
public class DatabaseConfig {

    private static final String PROPERTY_NAME_DATABASE_DRIVER   = "db.driver";
    private static final String PROPERTY_NAME_DATABASE_PASSWORD = "db.password";
    private static final String PROPERTY_NAME_DATABASE_URL      = "db.url";
    private static final String PROPERTY_NAME_DATABASE_USERNAME = "db.username";
 
    private static final String PROPERTY_NAME_HIBERNATE_DIALECT = "hibernate.dialect";
    private static final String PROPERTY_NAME_HIBERNATE_SHOW_SQL = "hibernate.show_sql";
    private static final String PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN = "entitymanager.packages.to.scan";
    
 @Resource
 private Environment env;
 
 @Bean
 public DataSource dataSource() {
  DriverManagerDataSource dataSource = new DriverManagerDataSource();
  dataSource.setDriverClassName(env.getRequiredProperty(PROPERTY_NAME_DATABASE_DRIVER));
  dataSource.setUrl(env.getRequiredProperty(PROPERTY_NAME_DATABASE_URL));
  dataSource.setUsername(env.getRequiredProperty(PROPERTY_NAME_DATABASE_USERNAME));
  dataSource.setPassword(env.getRequiredProperty(PROPERTY_NAME_DATABASE_PASSWORD));
  return dataSource;
 }
 
 private Properties hibProperties() {
  Properties properties = new Properties();
  properties.put(PROPERTY_NAME_HIBERNATE_DIALECT, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_DIALECT));
  properties.put(PROPERTY_NAME_HIBERNATE_SHOW_SQL, env.getRequiredProperty(PROPERTY_NAME_HIBERNATE_SHOW_SQL));
  return properties; 
 }
 
 @Bean
 public HibernateTransactionManager transactionManager() {
  HibernateTransactionManager transactionManager = new HibernateTransactionManager();
  transactionManager.setSessionFactory(sessionFactory().getObject());
  return transactionManager;
 }
 
 @Bean
 public LocalSessionFactoryBean sessionFactory() {
  LocalSessionFactoryBean sessionFactoryBean = new LocalSessionFactoryBean();
  sessionFactoryBean.setDataSource(dataSource());
  sessionFactoryBean.setPackagesToScan(env.getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN));
  sessionFactoryBean.setHibernateProperties(hibProperties());
  return sessionFactoryBean;
 }
}

3. Create the properties file used by the database configuration java file.  This file will contain the details about our specific database.  This file is located in the resources directory under main (not the one in webapp).

#DB properties:
db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://192.168.0.100:3306/oas
db.username=root
db.password=password

#Hibernate Configuration:
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
hibernate.show_sql=true
entitymanager.packages.to.scan=com.dtr.oas.model

4. Update the Initializer.java to load the new database configuration file.  The only change to this code was the addition of the DatabaseConfig.class entry in the getRootConfigClasses method:

package com.dtr.oas.config;

import org.springframework.core.annotation.Order;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import com.dtr.oas.config.DatabaseConfig;

@Order(1)
public class Initializer extends
  AbstractAnnotationConfigDispatcherServletInitializer {

 @Override
 protected Class<?>[] getRootConfigClasses() {
  return new Class[] { DatabaseConfig.class };
 }

 @Override
 protected Class<?>[] getServletConfigClasses() {
  return new Class<?>[] { WebAppConfig.class };
 }

 @Override
 protected String[] getServletMappings() {
  return new String[] { "/" };
 }

}

5. We now create the standard model, DAO, and service layers.  The model/entity class is first:

package com.dtr.oas.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="strategy")
public class Strategy {
 
 @Id
 @GeneratedValue
 private Integer id;
 private String type;
 private String name;

 public Integer getId() {
  return id;
 }

 public void setId(Integer id) {
  this.id = id;
 }

 public String getType() {
  return type;
 }

 public void setType(String type) {
  this.type = type;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }
}

6. The DAO layer has an interface and an implementation:

package com.dtr.oas.dao;

import java.util.List;
import com.dtr.oas.model.Strategy;

public interface StrategyDAO {

    public void addStrategy(Strategy strategy);
    public Strategy getStrategy(int id);
    public void updateStrategy(Strategy strategy);
    public void deleteStrategy(int id);
    public List<Strategy> getStrategies();
    
}

package com.dtr.oas.dao;

import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.dtr.oas.model.Strategy;

@Repository
public class StrategyDAOImpl implements StrategyDAO {

 @Autowired
 private SessionFactory sessionFactory;

 private Session getCurrentSession() {
  return sessionFactory.getCurrentSession();
 }

 public void addStrategy(Strategy strategy) {
  getCurrentSession().save(strategy);
 }

 public void updateStrategy(Strategy strategy) {
  Strategy strategyToUpdate = getStrategy(strategy.getId());
  strategyToUpdate.setName(strategy.getName());
  strategyToUpdate.setType(strategy.getType());
  getCurrentSession().update(strategyToUpdate);
 }

 public Strategy getStrategy(int id) {
  Strategy strategy = (Strategy) getCurrentSession().get(Strategy.class, id);
  return strategy;
 }

 public void deleteStrategy(int id) {
  Strategy strategy = getStrategy(id);
  if (strategy != null)
   getCurrentSession().delete(strategy);
 }

 @SuppressWarnings("unchecked")
 public List<Strategy> getStrategies() {
  return getCurrentSession().createQuery("from Strategy").list();
 }

}

7. The service layer contains an interface and an implementation:

package com.dtr.oas.service;

import java.util.List;
import com.dtr.oas.model.Strategy;

public interface StrategyService {

    public void addStrategy(Strategy strategy);
    public Strategy getStrategy(int id);
    public void updateStrategy(Strategy strategy);
    public void deleteStrategy(int id);
    public List<Strategy> getStrategies();

}

package com.dtr.oas.service;

import java.util.List;
import com.dtr.oas.dao.StrategyDAO;
import com.dtr.oas.model.Strategy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class StrategyServiceImpl implements StrategyService {

 @Autowired
 private StrategyDAO strategyDAO;

 @Override
 public void addStrategy(Strategy strategy) {
  strategyDAO.addStrategy(strategy);
 }

 @Override
 public void updateStrategy(Strategy strategy) {
  strategyDAO.updateStrategy(strategy);
 }

 @Override
 public Strategy getStrategy(int id) {
  return strategyDAO.getStrategy(id);
 }

 @Override
 public void deleteStrategy(int id) {
  strategyDAO.deleteStrategy(id);
 }

 @Override
 public List<Strategy> getStrategies() {
  return strategyDAO.getStrategies();
 }

}

8. The controller layer is next. We need to replace the default controller generated by STS and also create a controller for the strategy service.

package com.dtr.oas.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class LinkController {

 @RequestMapping(value="/")
 public ModelAndView mainPage() {
  return new ModelAndView("home");
 }

 @RequestMapping(value="/index")
 public ModelAndView indexPage() {
  return new ModelAndView("home");
 }

}

package com.dtr.oas.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import com.dtr.oas.model.Strategy;
import com.dtr.oas.service.StrategyService;

@Controller
@RequestMapping(value="/strategy")
public class StrategyController {

 @Autowired
 private StrategyService strategyService;
 
 @RequestMapping(value="/add", method=RequestMethod.GET)
 public ModelAndView addStrategyPage() {
  ModelAndView modelAndView = new ModelAndView("strategy-add");
  modelAndView.addObject("strategy", new Strategy());
  return modelAndView;
 }
 
 @RequestMapping(value="/add", method=RequestMethod.POST)
 public ModelAndView addingStrategy(@ModelAttribute Strategy strategy) {
  ModelAndView modelAndView = new ModelAndView("home");
  strategyService.addStrategy(strategy);
  String message = "Strategy was successfully added.";
  modelAndView.addObject("message", message);
  return modelAndView;
 }
 
 @RequestMapping(value="/list")
 public ModelAndView listOfStrategies() {
  ModelAndView modelAndView = new ModelAndView("strategy-list");
  List<strategy> strategies = strategyService.getStrategies();
  modelAndView.addObject("strategies", strategies);
  return modelAndView;
 }
 
 @RequestMapping(value="/edit/{id}", method=RequestMethod.GET)
 public ModelAndView editStrategyPage(@PathVariable Integer id) {
  ModelAndView modelAndView = new ModelAndView("strategy-edit");
  Strategy strategy = strategyService.getStrategy(id);
  modelAndView.addObject("strategy",strategy);
  return modelAndView;
 }
 
 @RequestMapping(value="/edit/{id}", method=RequestMethod.POST)
 public ModelAndView edditingStrategy(@ModelAttribute Strategy strategy, @PathVariable Integer id) {
  ModelAndView modelAndView = new ModelAndView("home");
  strategyService.updateStrategy(strategy);
  String message = "Strategy was successfully edited.";
  modelAndView.addObject("message", message);
  return modelAndView;
 }
 
 @RequestMapping(value="/delete/{id}", method=RequestMethod.GET)
 public ModelAndView deleteStrategy(@PathVariable Integer id) {
  ModelAndView modelAndView = new ModelAndView("home");
  strategyService.deleteStrategy(id);
  String message = "Strategy was successfully deleted.";
  modelAndView.addObject("message", message);
  return modelAndView;
 }
}

9. The last step is to create the JSPs. We will replace the home.jsp with a new one, and and the CRUD JSPs:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"  pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Home page</title>
</head>
<body>
<h1>Home page</h1>
<p>
${message}<br/>
<a href="${pageContext.request.contextPath}/strategy/add.html">Add New Strategy</a><br/>
<a href="${pageContext.request.contextPath}/strategy/list.html">Strategy list</a><br/>
</p>
</body>
</html>

<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"  pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>List of Strategies</title>
</head>
<body>
<h1>List of strategies</h1>
<p>Here you can see the list of the strategies, edit them, remove or update.</p>
<table class="table table-striped" border="1px" cellpadding="0" cellspacing="0" >
<thead>
<tr>
<th width="10%">id</th><th width="15%">name</th><th width="10%">type</th><th width="10%">actions</th>
</tr>
</thead>
<tbody>
<c:forEach var="strategy" items="${strategies}">
<tr>
 <td>${strategy.id}</td>
 <td>${strategy.name}</td>
 <td>${strategy.type}</td>
 <td>
 <a href="${pageContext.request.contextPath}/strategy/edit/${strategy.id}.html">Edit</a><br/>
 <a href="${pageContext.request.contextPath}/strategy/delete/${strategy.id}.html">Delete</a><br/>
 </td>
</tr>
</c:forEach>
</tbody>
</table>

<p><a href="${pageContext.request.contextPath}/index.html">Home page</a></p>

</body>
</html>

<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Add strategy page</title>
</head>
<body>
<h1>Add strategy page</h1>
<p>Here you can add a new strategy.</p>
<form:form method="POST" commandName="strategy" action="${pageContext.request.contextPath}/strategy/add.html">
<table>
<tbody>
 <tr>
  <td>Name:</td>
  <td><form:input path="name" /></td>
 </tr>
 <tr>
  <td>Type:</td>
  <td><form:input path="type" /></td>
 </tr>
 <tr>
  <td><input type="submit" value="Add" /></td>
  <td></td>
 </tr>
</tbody>
</table>
</form:form>

<p><a href="${pageContext.request.contextPath}/index.html">Home page</a></p>
</body>
</html>

<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Edit strategy page</title>
</head>
<body>
<h1>Edit strategy page</h1>
<p>Here you can edit the existing strategy.</p>
<p>${message}</p>
<form:form method="POST" commandName="strategy" action="${pageContext.request.contextPath}/strategy/edit/${strategy.id}.html">
<table>
<tbody>
 <tr>
  <td>Name:</td>
  <td><form:input path="name" /></td>
 </tr>
 <tr>
  <td>Type:</td>
  <td><form:input path="type" /></td>
 </tr>
 <tr>
  <td><input type="submit" value="Edit" /></td>
  <td></td>
 </tr>
</tbody>
</table>
</form:form>

<p><a href="${pageContext.request.contextPath}/index.html">Home page</a></p>
</body>
</html>

10. After all of these steps, you should have a directory structure like the one below:

11. Right-click on the project -> Run As -> Run On Server and follow the steps in the wizard.  When you run this project on the server, you should see a page similar to the one below.

Code at GitHub: https://github.com/dtr-trading/spring-ex02

Lastly, if you are looking for another example of this process, see the post:
http://fruzenshtein.com/spring-mvc-hibernate-maven-crud/.