- Spring 3 MVC integrado con Hibernate 4 sin Maven

En este tutorial describiré los pasos necesarios para realizar un proyecto Spring integrado con Hibernate sin la herramienta de gestión y construcción MAVEN, lo cual quiere decir que obtendremos nosotros mismos las librerías necesarias para nuestros proyecto así como configuraremos nuestro entorno de desarrollo para que todos los componentes sean tomados correctamente en nuestra aplicación.

Introducción a Spring MVC


Es un framework en JAVA que se usa para realizar proyectos MVC que básicamente es un patrón de arquitectura Modelo - Vista - Controlador cuyos componentes están definidos de la siguiente manera:

Figura 1.1 – P.S Imagen copiada del libro : Spring Recipes

1. Inicialmente nuestra página realiza la petición HTTP también llamado Request al nuestro Dispatcher Servlet.
2. Luego el Dispatcher Servlet buscará el controlador respectivo a la petición preguntándoselo al Handler Mapping.
3. Una vez obtenido el nombre del controlador el Dispatcher Servlet le dará a este la información respectiva del request para que pueda gestionar las acciones necesarias que se hará con los datos y así definir la información que se va a devolver mediante el objeto ModelAndView que contendrá los datos necesarios para mostrarse así como el nombre de la vista donde se mostrará.
4. Una vez que el Dispatcher Servlet recibe el objeto ModelAndView con la información necesaria le preguntará al ViewResolver la pagina asociada al nombre de la vista jsp obtenida en el paso anterior.
5. Ahora que el Dispatcher Servlet ya tiene el nombre del jsp y la información necesaria para mostrarse en dicha página obtiene el jsp a partir del View.
6. Finalmente el Dispatcher Servlet le da la respuesta HTTP también llamada Response a nuestro jsp para que se muestre con la información respectiva.

Introducción a Hibernate

Hibernate es un framework del tipo ORM lo cual quiere decir Object Relational Mapping que en castellano significa Mapeo Objeto Relacional; esto quiere decir que Hibernate nos permite en pocas palabras convertir nuestras tablas de base de datos en objetos JAVA (para este caso J2EE) para así poder modificarlas y usarlas a nuestro antojo (persistencia de datos). Los componentes están definidos de la siguiente manera:

Figura 1.2

1. Session Interface.- Esta es la interface básica para una aplicación en hibernate. Las instancias que se generan de esta interface no son nada costosas y muy ligeras a la hora de crear y destruir en la aplicación
2. SessionFactory Interface.- Esta interface nos devuelve el objeto session para usarla en la aplicación. Normalmente es necesario un objeto de este tipo para toda la aplicación la cual sera compartida en todos los entornos de nuestra aplicación.
3. Configuration Interface.- Esta interface es usada para configurar y arrancar Hibernate en nuestra aplicación. La instancia de este objeto es usada en la aplicación para especificar los parámetros y mapeos respectivos.
4. Transaction Interface.- Esta es una interface opcional que básicamente abstrae el código para cualquier tipo de transacción como puede ser JDBC o JTA.
5. Query y Criteria Interface.- Nos permite desarrollar queries y tomar el control del flujo al ejecutar la query.

Proyecto Spring integrado con Hibernate

Las herramientas con las cuales trabajaremos son:

1. Eclipse Kepler
2. Apache Tomcat 7.0
3. MySQL Server 5.0
4. Librerias Spring 3.1.0 RELEASE
5. Librerias Hibernate

Como indiqué anteriormente no explicaré como se realiza la instalación del Eclipse con su respectivo JDK ni el Tomcat, ni la Base de datos MySQL por lo que se asume que ya tenéis el entorno instalado.

Antes que nada crearemos en MySQL nuestra base de datos así como la tabla necesaria para poder trabajar con ella: (Siempre y cuando no la tengamos ya creada).

CREATE DATABASE BD_TUTORIAL;
USE BD_TUTORIAL;
grant all on BD_TUTORIAL.* to 'admin'@'localhost' identified by 'test';

CREATE TABLE COMPONENTE
(   id        INT PRIMARY KEY AUTO_INCREMENT,
    nombre    VARCHAR(30),
    version   VARCHAR(30),
    tipo      VARCHAR(15),
    extension VARCHAR(30),
    creado    TIMESTAMP DEFAULT NOW()
);
CREATE TABLE usuario
(   id        INT PRIMARY KEY AUTO_INCREMENT,
    nombre    VARCHAR(30),
    clave   VARCHAR(30),
    creado    TIMESTAMP DEFAULT NOW()
);
insert into usuario (nombre, clave) values ('victor', 'elliott');

Primero que todo creamos un proyecto WEB en el eclipse: File -> New -> Dynamic Web Project

y el siguiente nombre al proyecto ProyectoSpringHibernateTutorial y a continuación Finish para crear el proyecto tal como podemos verlo en la imagen:

Figura 1.3

A continuación creamos en ProyectoSpringHibernateTutorial/src los siguientes paquetes:

1. com.victor.elliott.humala.controlador
2. com.victor.elliott.humala.formulario
3. com.victor.elliott.humala.servicios
4. com.victor.elliott.humala.util
5. com.victor.elliott.humala.dao

Luego creamos las siguientes clases en los paquetes respectivos

1. com.victor.elliott.humala.dao  ->  UsuarioDAO.java
2. com.victor.elliott.humala.dao-> UsuarioDAOImpl.java
3. com.victor.elliott.humala.dao  ->  ComponenteDAO.java
4. com.victor.elliott.humala.dao-> ComponenteDAOImpl.java
5. com.victor.elliott.humala.formulario -> UsuarioForm.java
6. com.victor.elliott.humala.formulario -> ComponenteForm.java
7. com.victor.elliott.humala.servicios -> ComponenteService.java
8. com.victor.elliott.humala.servicios -> ComponenteServiceImpl.java
9. com.victor.elliott.humala.servicios -> UsuarioService.java
10. com.victor.elliott.humala.servicios -> UsuarioServiceImpl.java
11. com.victor.elliott.humala.util -> HibernateUtil.java
12. com.victor.elliott.humala.controlador  ->  UsuarioController.java
13. com.victor.elliott.humala.controlador  ->  ComponenteController.java

Una vez creadas las clases creamos las paginas y xml's respectivos.

Creamos primero que todo la carpeta jsp en ProyectoSpringHibernateTutorial/WebContent/WEB-INF

1. index.jsp en ProyectoSpringHibernateTutorial/WebContent
2. login.jsp en ProyectoSpringHibernateTutorial/WebContent/WEB-INF/jsp
3. agregarComponentes.jsp en ProyectoSpringHibernateTutorial/WebContent/WEB-INF/jsp
4. mostrarComponentes.jsp en ProyectoSpringHibernateTutorial/WebContent/WEB-INF/jsp
5. web.xml en ProyectoSpringHibernateTutorial/WebContent/WEB-INF
6. proyectoSpringHibernate-servlet.xml en ProyectoSpringHibernateTutorial/WebContent/WEB-INF
7. hibernate.cfg.xml en /ProyectoSpringHibernateTutorial/src

Una vez creadas nuestras clases, paginas y componentes que usaremos la estructura de proyecto debe de quedar de la siguiente manera:

Figura 1.4

Ahora que ya tenemos casi todos los elementos necesarios para empezar a desarrollar nuestro proyecto haremos la configuración con Spring e Hibernate para empezar a usar los frameworks sin errores y para esto primero bajemos las librerías necesarias que os la podéis descargar desde los siguientes links:

1. Librerias Spring 3.1.0 RELEASE
2. Librerias Hibernate

Una vez descargados los descomprimimos y los añadiremos a nuestro proyecto de la siguiente manera:
Click derecho en ProyectoSpringHibernateTutorial -> Properties -> Java Build Path -> Libraries -> Add Library -> User Library -> Next -> User Libraries -> New  y a continuación escriben Spring y OK que sera el nombre de la librería, inmediatamente sin salir de la ventana presionamos Add External JARs vamos a la carpeta donde descomprimimos las librerías, seleccionamos todos los jars del Spring presionamos Abrir y finalmente OK. Saliendo de esa ventana pondremos Finish y ya tendremos nuestras librerías de Spring agregadas al proyecto, y ahora hacemos los mismo para las librerías Hibernate:  Click derecho en ProyectoSpringHibernateTutorial -> Properties -> Java Build Path -> Libraries -> Add Library -> User Library -> Next -> User Libraries -> New  y a continuación escriben Hibernate y OK que sera el nombre de la librería, inmediatamente sin salir de la ventana presionamos Add External JARs vamos a la carpeta donde descomprimimos las librerías, seleccionamos todos los jars del Hibernate presionamos Abrir y finalmente OK. Saliendo de esa ventana pondremos Finish.

Tener en cuenta que se agregarán estas librerías de esta forma siempre y cuando no se hayan creado anteriormente Spring e Hibernate, caso contrario solo con seleccionarlos de User Libraries.

Una vez agregadas las librerías Hibernate agregamos nuestro conector que este caso es del MySql
ProyectoSpringHibernateTutorial -> Properties -> Java Build Path -> Libraries -> Add Library -> Add External JAR's y agregamos en este caso: mysql-connector-java-5.0.8-bin.jar. Deberá quedar como queda en la figura:

Figura 1.5

Por ultimo tendremos que hacer que las librerías tengan efecto inmediato en todas las clases de nuestro proyecto y que no haya problemas de compilación ni de ejecución:
Click derecho en ProyectoSpringHibernateTutorial -> Deployment Assembly -> Add seleccionamos las librerías Spring, Hibernate y mysql-connector-java-5.0.8-bin.jar y damos Finish y quedará tal como se muestra en la imagen.

Figura 1.6

Ahora si podemos empezar a codificar nuestro proyecto. Primero que todo modificamos  com.victor.elliott.humala.util.HibernateUtil.java tal como sigue:

package com.victor.elliott.humala.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
            return new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            // Make sure you log the exception, as it might be swallowed
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

Esta clase simplemente nos instanciará la SessionFactory que es la encargada de ejecutar las querys necesarias de una base de datos respectiva, si tuviéramos que usar mas de una Base de datos tendríamos que definir otra SessionFactory pero en este caso solo necesitamos una.

ahora modificamos com.victor.elliott.humala.formulario.UsuarioForm.java de la siguiente manera:

package com.victor.elliott.humala.formulario;

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

@Entity
@Table(name="usuario")
public class UsuarioForm {
 @Id
 @Column(name="id")
 @GeneratedValue
 private Integer id;
 
 @Column(name="nombre")
 private String nombre;
 
 @Column(name="clave")
 private String clave;

 public Integer getId() {
  return id;
 }

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

 public String getNombre() {
  return nombre;
 }

 public void setNombre(String nombre) {
  this.nombre = nombre;
 }

 public String getClave() {
  return clave;
 }

 public void setClave(String clave) {
  this.clave = clave;
 }
 
 public String toString(){
  
  return "Usuario: "+this.nombre;
 }
}

Ahora describimos rápidamente el formulario:

1. Los import son las clases necesarias para mapear nuestra tabla USUARIO con la clase UsuarioForm. Tener en cuenta que esto lo hacemos para ahorrarnos el tener que crear un xml nuevo que se llame: usuario.hbm.xml y mapearlo en ese xml. Esto se llama Hibernate con anotaciones los cuales nos facilitará la configuración del mapeo para tenerlo ya en nuestra clase respectiva y poder controlarla en el entorno del objeto.
2. @Entity nos indica que nuestra clase es una entidad que se encargará de mapear con una tabla de la base de datos.
3. @Table(name="usuario") nos indica que la clase representará nuestra tabla USUARIO
4. @Id, @Column(name="id"), @GeneratedValue nos da las caracteristicas del atributo id.
5. Finalmente @Column(name="xxxxx") nos indica como estarán representadas los atributos con las respectivas columnas en la Tabla.

Con el mismo criterio modificamos: com.victor.elliott.humala.formulario.ComponenteForm.java

package com.victor.elliott.humala.formulario;

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

@Entity
@Table(name="componente")
public class ComponenteForm {
 
 @Id
 @Column(name="id")
 @GeneratedValue
 private Integer id;
 
 @Column(name="nombre")
 private String nombre;
 
 @Column(name="version")
 private String version;
 
 @Column(name="tipo")
 private String tipo;
 
 @Column(name="extension")
 private String extension;
 
 public Integer getId() {
  return id;
 }
 public void setId(Integer id) {
  this.id = id;
 }
 public String getNombre() {
  return nombre;
 }
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
 public String getVersion() {
  return version;
 }
 public void setVersion(String version) {
  this.version = version;
 }
 public String getTipo() {
  return tipo;
 }
 public void setTipo(String tipo) {
  this.tipo = tipo;
 }
 public String getExtension() {
  return extension;
 }
 public void setExtension(String extension) {
  this.extension = extension;
 }
 
 public String toString(){
  
  return "Componente: "+this.id+", "+this.nombre+", "+this.version+", "+this.extension;
 }
}

El siguiente paso es modificar com.victor.elliott.humala.dao.ComponenteDAO.java tal como sigue:

package com.victor.elliott.humala.dao;

import java.util.List;
import com.victor.elliott.humala.formulario.ComponenteForm;

public interface ComponenteDAO {
  public void agregarComponente(ComponenteForm componente);
  public List<ComponenteForm> mostrarComponentes();
  public void eliminarComponente(Integer id);
  public void actualizarComponente(ComponenteForm componente);
  public ComponenteForm mostrarComponente(int id);
}

Esta clase es una interface que nos indica las acciones que realizaremos en nuestra tabla COMPONENTE a partir de su entidad mapeada respectiva que este caso es ComponenteForm. En consiguiente implementamos la interface modificando la siguiente clase:
com.victor.elliott.humala.dao.ComponenteDAOImpl.java tal como sigue:

package com.victor.elliott.humala.dao;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.victor.elliott.humala.formulario.ComponenteForm;
import com.victor.elliott.humala.util.HibernateUtil;


public class ComponenteDAOImpl implements ComponenteDAO{
 public void agregarComponente(ComponenteForm componente) {
  
        Transaction trns = null;
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.save(componente);
        
        try {
            trns = session.beginTransaction();
            session.save(componente);
            session.getTransaction().commit();
        } catch (RuntimeException e) {
            if (trns != null) {
                trns.rollback();
            }
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
    }
 public List<ComponenteForm> mostrarComponentes() {
        List<ComponenteForm> componentes = new ArrayList<ComponenteForm>();
        Transaction trns = null;
        Session session = HibernateUtil.getSessionFactory().openSession();
        try {
            trns = session.beginTransaction();
            componentes = session.createQuery("from ComponenteForm").list();
        } catch (RuntimeException e) {
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
        
        return componentes;  
 }
 public void eliminarComponente(Integer id) {
        Transaction trns = null;
        Session session = HibernateUtil.getSessionFactory().openSession();
        try {
            trns = session.beginTransaction();
            ComponenteForm componente = (ComponenteForm) session.load(ComponenteForm.class, new Integer(id));
            session.delete(componente);
            session.getTransaction().commit();
        } catch (RuntimeException e) {
            if (trns != null) {
                trns.rollback();
            }
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
 }
 
    public void actualizarComponente(ComponenteForm componente) {
        Transaction trns = null;
        Session session = HibernateUtil.getSessionFactory().openSession();
        try {
            trns = session.beginTransaction();
            session.update(componente);
            session.getTransaction().commit();
        } catch (RuntimeException e) {
            if (trns != null) {
                trns.rollback();
            }
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
    } 
    
    public ComponenteForm mostrarComponente(int id) {
     ComponenteForm componente = null;
        Transaction trns = null;
        Session session = HibernateUtil.getSessionFactory().openSession();
        try {
            trns = session.beginTransaction();
            String queryString = "from ComponenteForm where id = :id";
            Query query = session.createQuery(queryString);
            query.setInteger("id", id);
            componente = (ComponenteForm) query.uniqueResult();
        } catch (RuntimeException e) {
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
        return componente;
    }    
}

1. En esta implementación básicamente desarrollamos el CRUD de la tabla COMPONENTE .
2. Si os percatáis lo mas importante aquí es tener claro que es necesario abrir y cerrar la sesión (el uso exclusivo de la tabla) antes de cualquier acción:  openSession() y session.close() respectivamente.
3. Posteriormente las acciones de agregar, actualizar, eliminar están definidas en los métodos del objeto session de la siguiente forma respectivamente: session.save(componente);  session.update(componente); session.delete(componente);
4. Hay que percatarnos de que en las querys que realicemos no tenemos que realizarlas contra las tablas de Base de datos si no contra la entidad que la representa en este caso la tabla COMPONENTE esta representada por la entidad ComponenteForm por ello las querys están dadas de la siguiente forma: "from ComponenteForm" o "from ComponenteForm where id = :id", los atributos también serán usados con el mismo criterio es decir las querys se realizarán con los atributos de la entidad que representan las filas de la tabla.
5. Finalmente para obtener un fila o todas en nuestro caso también se usa un método del objeto session que es session.createQuery(queryString), donde queryString viene a ser la cadena con los datos de la restricción para nuestra búsqueda ya sea de uno o mas elementos. Cuando vamos a obtener un solo elemento es necesario especificar query.uniqueResult().

Con el mismo criterio modificamos com.victor.elliott.humala.dao.UsuarioDAO.java

package com.victor.elliott.humala.dao;

import com.victor.elliott.humala.formulario.UsuarioForm;

public interface UsuarioDAO {
 public boolean buscarUsuario(UsuarioForm usuario);
}

Y modificamos su implementación:
/ProyectoSpringHibernateTutorial/src/com/victor/elliott/humala/dao/UsuarioDAOImpl.java

package com.victor.elliott.humala.dao;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.victor.elliott.humala.formulario.UsuarioForm;
//import com.victor.elliott.humala.util.HibernateUtil;
import com.victor.elliott.humala.util.HibernateUtil;

public class UsuarioDAOImpl implements UsuarioDAO{     
 
    public boolean buscarUsuario(UsuarioForm usuario) {
    
     boolean existe=false;
        Transaction trns = null;
        Session session = HibernateUtil.getSessionFactory().openSession();
        try {
            trns = session.beginTransaction();
            String queryString = "from UsuarioForm where nombre = :nombre and clave = :clave";
            Query query = session.createQuery(queryString);
            query.setString("nombre", usuario.getNombre());
            query.setString("clave", usuario.getClave());
            existe = !(((UsuarioForm) query.uniqueResult())==(null));
            //Aqui verificamos si la query me trae algun resultado, si no es asi el usuario no existe.
        } catch (RuntimeException e) {
         existe = false;
            e.printStackTrace();
        } finally {
            session.flush();
            session.close();
        }
        return existe;
    }
}

Aquí no tenemos un CRUD por que solo necesitamos validar que el usuario exista para poderlo dejar entrar a nuestro sistema por eso lo valido con la query "from UsuarioForm where nombre = :nombre and clave = :clave", recordar la consulta se realiza sobre la entidad UsuarioForm y no sobre la tabla USUARIO.

Ahora desarrollamos los servicios modificándolos de la siguiente manera:
/ProyectoSpringHibernateTutorial/src/com/victor/elliott/humala/servicios/UsuarioService.java

package com.victor.elliott.humala.servicios;

import com.victor.elliott.humala.formulario.UsuarioForm;

public interface UsuarioService {
 public boolean buscarUsuario(UsuarioForm usuario);
}

Y su respectiva implementación:
/ProyectoSpringHibernateTutorial/src/com/victor/elliott/humala/servicios/UsuarioServiceImpl.java

package com.victor.elliott.humala.servicios;

import com.victor.elliott.humala.dao.UsuarioDAO;
import com.victor.elliott.humala.dao.UsuarioDAOImpl;
import com.victor.elliott.humala.formulario.UsuarioForm;

public class UsuarioServiceImpl implements UsuarioService{

 private UsuarioDAO usuarioDAO=new UsuarioDAOImpl();
 
 public boolean buscarUsuario(UsuarioForm usuario) {
  // TODO Auto-generated method stub
  return usuarioDAO.buscarUsuario(usuario);
 }
}

Cuya única función sera la de ser instanciada e invocada sus métodos por el controlador respectivo en este caso UsuarioController y a su vez invocar los metodos del DAO (UsuarioDAO) que necesitemos. En resumen esta será nuestra capa de servicios para controlar al usuario.

Del mismo modo modificamos los servicios del componente:
/ProyectoSpringHibernateTutorial/src/com/victor/elliott/humala/servicios/ComponenteService.java

package com.victor.elliott.humala.servicios;

import java.util.List;
import com.victor.elliott.humala.formulario.ComponenteForm;

public interface ComponenteService {
  public void agregarComponente(ComponenteForm componente);
  public List<ComponenteForm> mostrarComponentes();
  public void eliminarComponente(Integer id);
  public void actualizarComponente(ComponenteForm componente);
  public ComponenteForm mostrarComponente(int id);
}

Y su implementador:
/ProyectoSpringHibernateTutorial/src/com/victor/elliott/humala/servicios/ComponenteServiceImpl.java

package com.victor.elliott.humala.servicios;

import java.util.List;

import com.victor.elliott.humala.dao.ComponenteDAO;
import com.victor.elliott.humala.dao.ComponenteDAOImpl;
import com.victor.elliott.humala.formulario.ComponenteForm;



public class ComponenteServiceImpl implements ComponenteService{
 
 private ComponenteDAO componenteDAO = new ComponenteDAOImpl();

 public void agregarComponente(ComponenteForm componente) {
  // TODO Auto-generated method stub
  componenteDAO.agregarComponente(componente);
 }

 public List<ComponenteForm> mostrarComponentes() {
  // TODO Auto-generated method stub
  return componenteDAO.mostrarComponentes();
 }

 public void eliminarComponente(Integer id) {
  // TODO Auto-generated method stub
  componenteDAO.eliminarComponente(id);
 }

 public void actualizarComponente(ComponenteForm componente) {
  // TODO Auto-generated method stub
  componenteDAO.actualizarComponente(componente);
 }

 public ComponenteForm mostrarComponente(int id) {
  // TODO Auto-generated method stub
  return componenteDAO.mostrarComponente(id);
 }

}

Una vez que tenemos los DAO's y los Servicios desarrollemos los controladores. Modificamos el controlador del usuario:
/ProyectoSpringHibernateTutorial/src/com/victor/elliott/humala/controlador/UsuarioController.java

package com.victor.elliott.humala.controlador;

import com.victor.elliott.humala.formulario.UsuarioForm;
import com.victor.elliott.humala.formulario.ComponenteForm;
import com.victor.elliott.humala.servicios.UsuarioService;
import com.victor.elliott.humala.servicios.UsuarioServiceImpl;

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.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;


@Controller
public class UsuarioController {
 private UsuarioService usuarioService = new UsuarioServiceImpl();
 static UsuarioForm usuarioForm = new UsuarioForm();
 
 
    @RequestMapping(value = "/inicializarLogin.html", method = RequestMethod.GET)
    public ModelAndView inicializarUsuario() {
        
     System.out.println("Si hemos llegado aqui quiere decir que la pagina index.jsp ha invocado a este controlador por el request /inicializarLogin.html y requiere el inicializarUsuario View");
     return new ModelAndView("login" , "usuarioForm", new UsuarioForm());
    }
    
    @RequestMapping(value = "/verificarLogin.html", method = RequestMethod.POST)
    public ModelAndView verificarUsuario(@ModelAttribute("usuarioForm") UsuarioForm usuarioForm) {
        boolean existe = false;
     System.out.println("Si hemos llegado aqui quiere decir que la pagina login.jsp ha invocado a este controlador por el request /verificarLogin.html y requiere el verificarUsuario View");
     existe = usuarioService.buscarUsuario(usuarioForm);
     
     if("".equals(usuarioForm.getNombre())&&"".equals(usuarioForm.getClave())){
      System.out.println("Cargaremos por primera vez la pagina de login con el mensaje vacio");
      return new ModelAndView("login" , "mensaje", "Debe de llenar los campos de Usuario y Clave");
     }
     else if(existe){
      System.out.println("Se coloco al usuario y clave correctamente y va a la pagina de agregarComponentes");
      UsuarioController.usuarioForm.setNombre(usuarioForm.getNombre());
      UsuarioController.usuarioForm.setClave(usuarioForm.getClave());
      ModelAndView modelo= new ModelAndView("agregarComponentes" , "mensaje", "Usuario Correcto");
      modelo.addObject("mensajeComponente","Agregar Componente");
      modelo.addObject("usuarioForm", usuarioForm);
      modelo.addObject("componenteForm", new ComponenteForm());
      return modelo;
     }
     else{
      System.out.println("Se coloco al usuario y clave incorrectamente y regresamos a la pagina de login con el mensaje de Usuario Incorrecto");
      return new ModelAndView("login" , "mensaje", "Usuario Incorrecto");
     }
    }
}

Ahora describo rápidamente el controlador del Usuario:

1. Todos los import son importantes puesto que son las librerías de Spring que necesitamos para desarrollarlo. 
2. @Controller es esencial para indicar que la clase UsuarioController es un controlador.
3. Definimos el atributo UsuarioForm usuarioForm de tipo estático para que guarde el usuario y clave a validar en el login.
4. Definimos el @RequestMapping para indicar que será el método que se ejecutará cuando se invoque desde una pagina con el nombre de inicializarLogin.html. Para este caso la pagina que lo invoca es el index.jsp.
5. Inmediatamente se define el method = RequestMethod.GET ya que para este caso no estaremos pasando ninguna información.
6. Una vez definido el tipo de método definimos el método en si donde solo devolveremos el objeto UsuarioForm usuarioForm vacío para que lo tome en cuenta el login.jsp definiendolo de la siguiente manera: return new ModelAndView("login" , "usuarioForm", new UsuarioForm())
7. Luego definimos otro @RequestMapping que será invocado desde verificarLogin.html donde el method sera del tipo method = RequestMethod.POST ya que en este caso si necesitaremos información de la pagina que la invoca login.jsp, esta información serán los datos del usuario que hemos ingresado.
8. Luego utilizaremos nuestra capa de servicio del usuario: UsuarioService para verificar que el usuario tiene los datos correctos y existe con el nombre y clave ingresado. Recordar que se sigue el siguiente flujo: UsuarioService.buscarUsuario -> UsuarioDAO.buscarUsuario -> tabla USUARIO , que es el flujo que hemos definido para usar Hibernate.
9. Una vez tengamos validado el usuario se realiza la verificación principal que es el "else if(existe)" ya que si el usuario y clave coinciden creamos un objeto del tipo ModelAndView que me llevará a la página agregarComponentes.jsp con el mensaje correcto y de paso envío la información del usuario que se logueó mediante modelo.addObject("usuarioForm", usuarioForm) y un mensaje para indicar que agregaremos un componente "modelo.addObject("mensajeComponente","Agregar Componente");", caso contrario si la validación no resultó vuelvo a la pagina login.jsp con su mensaje respectivo.

Ahora modificamos el controlador del Componente:

/ProyectoSpringHibernateTutorial/src/com/victor/elliott/humala/controlador/ComponenteController.java

package com.victor.elliott.humala.controlador;

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.victor.elliott.humala.formulario.ComponenteForm;
import com.victor.elliott.humala.servicios.ComponenteService;
import com.victor.elliott.humala.servicios.ComponenteServiceImpl;

@Controller
public class ComponenteController {

 private ComponenteService componenteService= new ComponenteServiceImpl();
 
 @RequestMapping(value="/agregarComponentes.html", method = RequestMethod.POST)
 public ModelAndView guardarComponente(@ModelAttribute("componenteForm") ComponenteForm componente) {
  System.out.println("Ingreso a componente guardado");
  componenteService.agregarComponente(componente);
  System.out.println("Componente guardado");
  return new ModelAndView("mostrarComponentes" , "listaComponentes", componenteService.mostrarComponentes());
 }
 
 @RequestMapping(value="/actualizarComponentes.html", method = RequestMethod.POST)
 public ModelAndView actualizarComponente(@ModelAttribute("componenteForm") ComponenteForm componente) {
  System.out.println("Ingreso a componente actualizado");
  componenteService.actualizarComponente(componente);
  System.out.println("Componente actualizado");
  return new ModelAndView("mostrarComponentes" , "listaComponentes", componenteService.mostrarComponentes());
 }
 
 @RequestMapping(value="/eliminarComponentes.html/{componenteId}", method = RequestMethod.GET)
 public ModelAndView eliminarComponente(@PathVariable("componenteId") Integer componenteId) {
  System.out.println("Ingreso a componente eliminado");
  componenteService.eliminarComponente(componenteId);
  System.out.println("Componente actualizado");
  return new ModelAndView("mostrarComponentes" , "listaComponentes", componenteService.mostrarComponentes());
 }
 
 @RequestMapping(value="/modificarComponentes.html/{componenteId}", method = RequestMethod.GET)
 public ModelAndView modificarComponente(@PathVariable("componenteId") Integer componenteId) {
  System.out.println("Vamos a modificar componente");
  ComponenteForm componente=componenteService.mostrarComponente(componenteId);
  ModelAndView modelo= new ModelAndView("agregarComponentes" , "mensaje", "Usuario Correcto");
  modelo.addObject("mensajeComponente","Modificar Componente");
  modelo.addObject("usuarioForm", UsuarioController.usuarioForm);
  modelo.addObject("componenteForm", componente);
  return modelo;
 }
 
 @RequestMapping(value="/volverComponente.html", method = RequestMethod.GET)
 public ModelAndView volverComponente() {
  System.out.println("Volvemos a agregar componente");
  System.out.println("Se coloco al usuario y clave correctamente y va a la pagina de agregarComponentes");
  ModelAndView modelo= new ModelAndView("agregarComponentes" , "mensaje", "Usuario Correcto");
  modelo.addObject("mensajeComponente","Agregar Componente");
  modelo.addObject("usuarioForm", UsuarioController.usuarioForm);
  modelo.addObject("componenteForm", new ComponenteForm());
  return modelo;
 }
 
 @RequestMapping(value="/mostrarComponentes.html", method = RequestMethod.GET)
 public ModelAndView mostrarComponentes() {
  System.out.println("Se muestran todos los componentes");
  return new ModelAndView("mostrarComponentes" , "listaComponentes", componenteService.mostrarComponentes());
 }
}

Describo el controlador del componente:

1. El método guardarComponente que es de tipo POST puesto que recibe el formulario con la información del registro que deseamos guardar en la tabla COMPONENTE, invoca al ComponenteService para realizar la tarea de guardado respectiva componenteService.agregarComponente(componente). Una vez guardada la data se le pasará a la vista una lista de todos los registros que tenemos en la tabla COMPONENTE: componenteService.mostrarComponentes().
2. El método actualizarComponente que es de tipo POST puesto que recibe el formulario con la información del registro que deseamos actualizar en la tabla COMPONENTE, invoca al ComponenteService para realizar la tarea de actualización respectiva componenteService.actualizarComponente(componente). Una vez actualizada la data se le pasará a la vista una lista de todos los registros que tenemos en la tabla COMPONENTE: componenteService.mostrarComponentes().
3. El método eliminarComponente que es de tipo GET puesto que no recibe ningún formulario, sinembargo necesitamos el id del componente que deseamos eliminar por lo que recibimos una variable del tipo @PathVariable("componenteId") que será pasado adjunto en nuestro RequestMapping, con este valor se invoca al ComponenteService para realizar la tarea de eliminación respectiva componenteService.eliminarComponente(componenteId). Una vez eliminado el componente se le pasará a la vista una lista de todos los registros que tenemos en la tabla COMPONENTE: componenteService.mostrarComponentes().
4. El método modificarComponente que es de tipo GET puesto que no recibe ningún formulario, sin embargo  tal como en el caso anterior necesitamos el id del componente que deseamos actualizar por lo que recibimos una variable del tipo @PathVariable("componenteId") que será pasado adjunto en nuestro RequestMapping, con este valor se invoca al ComponenteService para obtener los datos del componente a actualizar componenteService.mostrarComponente(componenteId). Una vez conseguido los datos del componente a modificar se le pasará a la vista este ComponenteForm para que se pueda mostrar en un formulario modelo.addObject("componenteForm", componente).
5. El método volverComponente que es de tipo GET puesto que no recibe ningún formulario, no se comunica con un servicio por que su objetivo es volver a la vista de ingresar un componente con todos los datos del formulario vacio modelo.addObject("componenteForm", new ComponenteForm()).
6. El método mostrarComponentes que es de tipo GET puesto que no recibe ningún formulario simplemente le pasa a la vista la lista de todos componentes que tengo en mi tabla sin realizar ninguna otra acción componenteService.mostrarComponentes().

Ahora modifiquemos las paginas:
/ProyectoSpringHibernateTutorial/WebContent/index.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<jsp:forward page="inicializarLogin.html"></jsp:forward>

Que basicamente redirecciona index.jsp a login.jsp
Ahora modificamos:
 /ProyectoSpringHibernateTutorial/WebContent/WEB-INF/jsp/login.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>    
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>  
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Proyecto Spring Tutorial by Victor Elliott Humala</title>
</head>
<body>
<c:if test="${mensaje !='Usuario Correcto'}">
  <h4>${mensaje}</h4>
</c:if>

<spring:url var="verificarLogin" value="/verificarLogin.html"/> 

<form:form id="login" modelAttribute="usuarioForm" method="post" action="${verificarLogin}">
 <table width="400px" height="150px">
  <tr>
  <td><form:label path="nombre">Nombre</form:label></td>
  <td><form:input  path="nombre"/></td>
  </tr>
  <tr>
  <td><form:label path="clave">Clave</form:label></td>
  <td><form:input  path="clave"/></td>
  </tr>
  <tr><td></td><td>
  <input type="submit" value="Login" />
  </td></tr>
 </table>
</form:form>

</body>
</html>

1. Aquí definimos primero que todo el mensaje que se mostrará en caso de algún error del login aunque inicialmente ese mensaje estará vacio, caso contrario mostrará el mensaje respectivo. 
2. Luego definimos el @RequestMapping verificarLogin.html al cual invocará nuestro jsp cuando se realice el submit mediante el login atraves del atributo action. 
3. Luego definimos el form donde nuestro objeto sera usuarioForm de method post ya que enviaremos información al servlet y la accion a realizar con el submit action="${verificarLogin} que definimos en var="verificarLogin" value="/verificarLogin.html". 
4. Finalmente insertamos los input necesarios que son el nombre y la clave, ojo que estos son atributos de la clase UsuarioForm tal como lo definimos anteriormente. 
5. Hay que ponerle un énfasis especial a la forma como definimos nuestro URL: <spring:url var="verificarLogin" value="/verificarLogin.html"/> estamos usándolo de esta forma y no <c:url var="verificarLogin" value="verificarLogin.html"/> por que de esta última forma corremos el peligro de engañar al servlet con otro contextpath que si lo reemplazáis en este tutorial os daréis cuenta que dará algunos errores al definir las URL. Al usar spring:url ya estamos dándole el contextpath correcto a nuestras llamadas ya sean por GET o POST.

Modificamos ProyectoSpringHibernateTutorial\WebContent\WEB-INF\jsp\agregarComponentes.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="form"%> 
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>    
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Componentes</title>
</head>
<body>
 <h4>${mensaje} : ${usuarioForm.nombre}</h4>
 <spring:url var="salir" value="/inicializarLogin.html"/>
 <a href="${lista}" >Salir</a>
</body>

<h4>${mensajeComponente}</h4>
<c:choose>  
    <c:when test="${mensajeComponente !='Agregar Componente'}">  
        <!--<c:url var="accionComponente" value="actualizarComponentes.html"/>-->
        <spring:url var="accionComponente" value="/actualizarComponentes.html"/>
    </c:when>  
    <c:otherwise>  
        <!--<c:url var="accionComponente" value="agregarComponentes.html"/>-->
        <spring:url var="accionComponente" value="/agregarComponentes.html"/> 
    </c:otherwise>  
</c:choose>

<form:form id="agregar" modelAttribute="componenteForm" method="post" action="${accionComponente}">
 <table width="400px" height="150px">
  <tr>
  <form:hidden path="id" />
  <td><form:label path="nombre">Nombre</form:label></td>
  <td><form:input  path="nombre"/></td>
  </tr>
  <tr>
  <td><form:label path="version">Versión</form:label></td>
  <td><form:input  path="version"/></td>
  </tr> 
  <tr>
  <td><form:label path="tipo">Tipo</form:label></td>
  <td><form:input  path="tipo"/></td>
  </tr>
  <tr>
  <td><form:label path="extension">Extensión</form:label></td>
  <td><form:input  path="extension"/></td>
  </tr>
  
  <tr><td></td><td>
  <c:choose>  
      <c:when test="${mensajeComponente !='Agregar Componente'}">  
          <input type="submit" value="Modificar" /> 
      </c:when>  
      <c:otherwise>  
          <input type="submit" value="Agregar" />
      </c:otherwise>  
  </c:choose>
  </td></tr>
 </table>
</form:form>
<spring:url var="lista" value="/mostrarComponentes.html"/>
<a href="${lista}" >Ver Lista de componentes</a>
</html>

Aqui realizamos lo siguiente:

1. Verificamos de que acción venimos si es para agregar un componente o para modificarlo y asi mostrar el mensaje y acciones respectivas. Estas acciones están definidos en el controlador.
2. Requerimos los datos de un componente a través del formulario componenteForm y en el submit nos dirigimos a @RequestMapping agregarComponentes.html ya declarado en el ComponenteController como método POST.

Modificamos el jsp:
/ProyectoSpringHibernateTutorial/WebContent/WEB-INF/jsp/mostrarComponentes.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    <%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%> 
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Lista de Componentes</title>
</head>
<body>
<center>
<br><br><br><br><br><br>
<div style="color: teal;font-size: 30px">Lista de Componentes</div>
<br><br>
<c:if test="${!empty listaComponentes}">
<table border="1" bgcolor="black" width="600px">
<tr style="background-color: teal;color: white;text-align: center;" height="40px">
<td>Nombre</td>
<td>Version</td>
<td>Tipo</td>
<td>Extensión</td>
<td> </td>
<td> </td>
</tr>
<c:forEach items="${listaComponentes}" var="componente">
<tr style="background-color:white;color: black;text-align: center;" height="30px" >
<td><c:out value="${componente.nombre}"/></td>
<td><c:out value="${componente.version}"/></td>
<td><c:out value="${componente.tipo}"/></td>
<td><c:out value="${componente.extension}"/></td>
<spring:url var="modificar" value="/modificarComponentes.html/${componente.id}"/>
<spring:url var="eliminar" value="/eliminarComponentes.html/${componente.id}"/>
 <td><a href="${modificar}" class="parent">Modificar</a></td>
  <td><a href="${eliminar}" class="parent">Eliminar</a></td>
</tr>
</c:forEach>
</table>
</c:if>
<br>
<spring:url var="volver" value="/volverComponente.html"/>
<a href="${volver}" >Agrega un nuevo componente</a>
</center>
</body>
</html>

1. Aqui nos recorremos la lista de los componentes que hay en la base de datos y que nos ha pasado el controlador listaComponentes siempre y cuando listaComponentes no sea nula {!empty listaComponentes}.
2. Luego por cada registro que obtengamos y pintemos le añadiremos dos links para que se puedan modificar o eliminar respectivamente {modificar}, {eliminar}.
3. Especial atención en como pasaremos la información del id del objeto que que estamos seleccionando: value="/modificarComponentes.html/${componente.id}" , como veis estamos adjuntando el id en el RequestMapping que tomará el controlador posteriormente.
4. Finalmente generamos un link para volver a agregar otro componente: volverComponente.html

Ahora solo nos queda modificar nuestros ficheros de configuración de Hibernate y Spring:
/ProyectoSpringHibernateTutorial/src/hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
 "-//Hibernate/Hibernate Configuration DTD//EN"
 "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
 <session-factory>
        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost/BD_TUTORIAL</property>
        <property name="connection.username">admin</property>
        <property name="connection.password">test</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property> 
        
        <mapping class="com.victor.elliott.humala.formulario.UsuarioForm" />  
        <mapping class="com.victor.elliott.humala.formulario.ComponenteForm" /> 
   
 </session-factory>

</hibernate-configuration>

En esta configuración lo que estamos definiendo principalmente es:

1. El driver (conector) que usaremos: com.mysql.jdbc.Driver
2. La base de datos: jdbc:mysql://localhost/BD_TUTORIAL
3. El usuario y contraseña que dimos permisos al inicio del tutorial:(admin, test)
4. El dialecto que usaremos que en este caso es del MySQL: org.hibernate.dialect.MySQLDialect
5. Las clases entidades que representarán las tablas de la base de datos que definimos al inicio de la configuración: UsuarioForm y ComponenteForm.

Modificamos:

/ProyectoSpringHibernateTutorial/WebContent/WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
    <display-name>ProyectoSpringHibernateTutorial</display-name>
    <welcome-file-list>
   <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
    <servlet>
        <servlet-name>proyectoSpringHibernate</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>proyectoSpringHibernate</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

1. Donde hay que percatarse que el nombre del servlet proyectoSpringHibernate tendrá que ser definido posteriormente como proyectoSpringHibernate-servlet.xml (agregandolo su sufijo -servlet.xml) para que esté correctamente configurado.
2. Aqui hay que tener en cuenta que el url-pattern lo hemos puesto como / , por que si lo ponemos como *.html o como *.jsp no funcionará para este proyecto puesto que al pasar datos al controlador del modo: /modificarComponentes.html/${componente.id} nos damos cuenta que esta url no termina en html ni en jsp por lo que saldría un error de url es por ello que al definir este pattern / ya aceptamos cualquier tipo de url.

Ahora modificamos
/ProyectoSpringHibernateTutorial/WebContent/WEB-INF/proyectoSpringHibernate-servlet.xml

<?xml  version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
         
    <context:annotation-config />
    <context:component-scan base-package="com.victor.elliott.humala.controlador" />   
 
    <bean id="jspViewResolver"
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass"
            value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

Donde definimos el paquete donde se buscarán los controladores: base-package="com.victor.elliott.humala.controlador , el tipo de Resolver InternalResourceViewResolver y ponemos el prefijo y sufijo de nuestras paginas a desplegar.

Ahora ya estamos listos para ejecutar nuestro proyecto en el servidor Tomcat, antes de ello verificar que no haya ningún error de compilación y una vez ejecutado en el servidor ningún error de ejecución. Si todo esta bien podrán visualizar las siguientes páginas:

Figura 1.7

Figura 1.8

Figura 1.9

El código del proyecto os lo podéis bajar del siguiente link

ProyectoSpringHibernateTutorial