Ya no queda nada para tener una aplicación como esta. Con ella podremos administrar nuestros contactos de forma simple y fácil. Además estamos aprendiendo muchísimo(o al menos yo) sobre Spring MVC, Hibernate y Maven. Aunque todavía nos queda mucho por aprender.
Ya hemos visto como crear el proyecto y cómo configurarlo para que con unas pocas clases tener una aplicación CRUD que gestiona nuestra agenda.
Para terminar el proyecto solo nos queda crear las clases e interfaces, para no perdernos vuelvo a poner la imagen del árbol de archivos para que no nos perdamos creando clases.
En primer lugar vamos a crear la clase Contact, que es una simple clase POJO que se usará para hacer a Hibernate interactuar con la BD. Esta clase será una entidad que se vinculará con la tabla Contacts que creamos en un post anterior.
/demoweb-hibernate/src/main/java/com/jesuslc/contact/form/Contact.java
package com.jesuslc.contact.form;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="CONTACTS")
public class Contact {
@Id
@Column(name="ID")
@GeneratedValue
private Integer id;
@Column(name="FIRSTNAME")
private String firstname;
@Column(name="LASTNAME")
private String lastname;
@Column(name="EMAIL")
private String email;
@Column(name="TELEPHONE")
private String telephone;
public String getEmail() {
return email;
}
public String getTelephone() {
return telephone;
}
public void setEmail(String email) {
this.email = email;
}
public void setTelephone(String telephone) {
this.telephone = telephone;
}
public String getFirstname() {
return firstname;
}
public String getLastname() {
return lastname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
}
- @Entity le decimos a Hibernate que esta clase representa un objeto persistente.
- @Table(name=»CONTACTS») le dice que la tabla que tiene que utilizar para mapear los objetos de esta clase es CONTACTS.
- @Id es una notación que indica que la variable Id es la clave primaia de la tabla
- @GeneratedValude indica que el valor se lo dará la BD y no se hará en el código, es decir será un valor autogenerado.
- @Column (name=»nombre») es una notación que se utiliza para asignar la propiedad a la columna de la base de datos.
Llegados a este punto tenemos mapeada la base de datos, nuestra base de datos es pequeña (solo una tabla) pero si tuviésemos más solo tendríamos que realizar unas cuantas clases más.
Así que ahora conviene que recordemos la arquitectura de nuestra aplicación para que a la hora de ir creando nuevas clases no perdamos el norte.
Capa de acceso a datos (DAO)
La capa DAO es la que se encarga de manejar los datos directamente, esta capa consta de una interfaz y de la clase que implementa dicha interfaz.
La interfaz ContactDAO indica las acciones que podemos realizar con los datos, en nuestro caso Contactos. Por tanto nosotros podemos Añadir contactos (AddContact), Borrar contactos (DeleteContact) y listar los contactos que tenemos guardados en la BD (listContact)
Aquí tenemos la Interfaz:
/demoweb-hibernate/src/main/java/com/jesuslc/contact/dao/ContactDAO.java
package com.jesuslc.contact.dao;
import com.jesuslc.contact.form.Contact;
import java.util.List;
public interface ContactDAO {
public void addContact(Contact contact);
public List<Contact> listContact();
public void removeContact(Integer id);
}
La clase ContactAOImpl implementa la interfaz ContactDAO. Debemos tener en cuenta que vamos a utilizar las notaciones de Spring @Repository y @Autowired por eso tenemos que estar atentos en las importaciones.
/demoweb-hibernate/src/main/java/com/jesuslc/contact/dao/ContactDAOImpl.java
package com.jesuslc.contact.dao;
import java.util.List;
import com.jesuslc.contact.form.Contact;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class ContactDAOImpl implements ContactDAO {
@Autowired
private SessionFactory sessionFactory;
public void addContact(Contact contact) {
sessionFactory.getCurrentSession().save(contact);
}
public List<Contact> listContact() {
return sessionFactory.getCurrentSession().createQuery("from Contact")
.list();
}
public void removeContact(Integer id) {
Contact contact = (Contact) sessionFactory.getCurrentSession().load(
Contact.class, id);
if (null != contact) {
sessionFactory.getCurrentSession().delete(contact);
}
}
}
Al utilizar estas anotaciones le indicamos a Spring que esta clase es especial y Spring debe interactuar con ella. Al tener tan separadas cada una de las clases eliminamos el acoplamiento y por ello nos «olvidamos» de la base de datos en las capas superiores.
Capa de Servicio
En nuestro caso la capa de servicios es similar a la capa DAO. En la capa de servicio «se implementan las reglas de negocio» en nuestro caso la aplicación de gestión de contactos es básica y no tiene ninguna regla de negocio.
Aquí tenemos la interfaz:
/demoweb-hibernate/src/main/java/com/jesuslc/contact/service/ContactService.java
package com.jesuslc.contact.service;
import java.util.List;
import com.jesuslc.contact.form.Contact;
public interface ContactService {
public void addContact(Contact contact);
public List<Contact> listContact();
public void removeContact(Integer id);
}
En este caso para indicar a Spring que esta es la copa de servicios hemos utilizado la notación @Service
/demoweb-hibernate/src/main/java/com/jesuslc/contact/service/ContactServiceImpl.java
package com.jesuslc.contact.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.jesuslc.contact.dao.ContactDAO;
import com.jesuslc.contact.form.Contact;
@Service
public class ContactServiceImpl implements ContactService {
@Autowired
private ContactDAO contactDAO;
@Transactional
public void addContact(Contact contact) {
contactDAO.addContact(contact);
}
@Transactional
public List<Contact> listContact() {
return contactDAO.listContact();
}
@Transactional
public void removeContact(Integer id) {
contactDAO.removeContact(id);
}
}
Añadiendo el Controlador al modelo MVC
Ya tenemos casi terminada nuesrta aplicación. Solo tenemos que añadir la clase Controlador a nuestro proyecto.
/demoweb-hibernate/src/main/java/com/jesuslc/contact/controller/ContactController.java
package com.jesuslc.contact.controller;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
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 com.jesuslc.contact.form.Contact;
import com.jesuslc.contact.service.ContactService;
@Controller
public class ContactController {
@Autowired
private ContactService contactService;
@RequestMapping("/index")
public String listContacts(Map<String, Object> map) {
map.put("contact", new Contact());
map.put("contactList", contactService.listContact());
return "contact";
}
@RequestMapping(value = "/add", method = RequestMethod.POST)
public String addContact(@ModelAttribute("contact")
Contact contact, BindingResult result) {
contactService.addContact(contact);
return "redirect:/index";
}
@RequestMapping("/delete/{contactId}")
public String deleteContact(@PathVariable("contactId")
Integer contactId) {
contactService.removeContact(contactId);
return "redirect:/index";
}
}
Nuestro controlador Spring tiene tres métodos para manipular la gestión de contactos.
- listContact: Este método utiliza la interfaz de la capa de servicios (ContactServer) para obtener todos los contactos de nuestra aplicación. Debemos tener en cuenta que hemos mapeado el «/index» es decir, que cuando accedamos a demoweb-hibernate/index será cuando llamemos a este método.
- addContact Este método añade un nuevo contacto a la lista. Con la notación @ModelAttribute obtenemos los datos del contacto. Debemos tener en cuenta que hemos mapeado el «/add». El método utiliza una solicitud POST para añadir un contacto sirviendose de la capa de servicio.
- DeleteContact Este método elimina un contacto. Al igual que add este método redirecciona a /index. Este método necesita el id para poder eliminar el contacto.
Creando la Vista
Por último solo tenemos que crear una página .jsp
/demoweb-hibernate/src/main/webapp/WEB-INF/jsp/contact.jsp
<%@taglib uri="http://www.springframework.org/tags" prefix="spring"%>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<html>
<head>
<title>Spring 3 MVC Series - Contact Manager</title>
<style type="text/css">
body {
font-family: sans-serif;
}
.data, .data td {
border-collapse: collapse;
width: 80%;
border: 1px solid #aaa;
margin: 2px;
padding: 2px;
}
.data th {
font-weight: bold;
background-color: #5C82FF;
color: white;
}
</style>
</head>
<body>
<h2><spring:message code="label.title"/></h2>
<form:form method="post" action="add.html" commandName="contact">
<table>
<tr>
<td><form:label path="firstname"><spring:message code="label.firstname"/></form:label></td>
<td><form:input path="firstname" /></td>
</tr>
<tr>
<td><form:label path="lastname"><spring:message code="label.lastname"/></form:label></td>
<td><form:input path="lastname" /></td>
</tr>
<tr>
<td><form:label path="email"><spring:message code="label.email"/></form:label></td>
<td><form:input path="email" /></td>
</tr>
<tr>
<td><form:label path="telephone"><spring:message code="label.telephone"/></form:label></td>
<td><form:input path="telephone" /></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" value="<spring:message code="label.addcontact"/>"/>
</td>
</tr>
</table>
</form:form>
<h3>Contactos</h3>
<c:if test="${!empty contactList}">
<table class="data">
<tr>
<th><spring:message code="label.firstname"/></th>
<th><spring:message code="label.email"/></th>
<th><spring:message code="label.telephone"/></th>
<th> </th>
</tr>
<c:forEach items="${contactList}" var="contact">
<tr>
<td>${contact.lastname}, ${contact.firstname} </td>
<td>${contact.email}</td>
<td>${contact.telephone}</td>
<td><a href="delete/${contact.id}">Eliminar</a></td>
</tr>
</c:forEach>
</table>
</c:if>
</body>
</html>
sss
A la página le hemos dado un poco de color utilizando css y por fin este es el resultado final.
Para que esto se muestre solo tenemos que pinchar sobre el boton play y poner como Goal deploy
Aquí tenemos un enlace al código https://github.com/jeslopcru/DemowebMSH
Actualización
Aquí la parte 1: https://jesuslc.com/2013/03/19/poco-a-poco-con-maven-spring-hibernate/
Aquí la parte 2: https://jesuslc.com/2013/03/25/poco-a-poco-con-maven-spring-hibernate-parte-2/
Jesús L.C. - Apuntes de un aprendiz 
Replica a Martin Cancelar la respuesta