Crear Struts2 Hibernate en Eclipse
Esta es una aplicación de Contact Manager de demostración que crearemos utilizando el marco de
Struts2 y Hibernate. En este artículo veremos cómo podemos utilizar Hibernate para realizar
operaciones Insert / Delete en el framework Struts2.
NUESTRO OBJETIVO
El objetivo será demostrar el uso de Struts2 con el marco de Hibernate y crear una aplicación de
demostración "Contact Manager". El requisito básico de la aplicación de Contact Manager será:
HIBERNATE:
es una herramienta de mapeo objeto-relacional (ORM) para la plataforma Java (y disponible
también para .Net con el nombre de NHibernate) que facilita el mapeo de atributos entre una base
de datos relacional tradicional y el modelo de objetos de una aplicación, mediante archivos
declarativos (XML) o anotaciones en los beans de las entidades que permiten establecer estas
relaciones
Agregar nuevo contacto en la lista de contactos.
Mostrar todos los contactos de la lista de contactos.
Eliminar un contacto de la lista de contactos.
Una vez que vamos a construir la aplicación se verá así:
EMPEZANDO
Para nuestro ejemplo de Contact Manager, utilizaremos la base de datos MySQL. Crear una tabla
de contactos en cualquier base de datos MySQL. Este es un ejemplo muy preliminar y por lo tanto
tenemos columnas mínimas para representar un contacto. Siéntase libre de ampliar este ejemplo y
crear una aplicación más compleja.
CREATE TABLE CONTACTS
(
id INT PRIMARY KEY AUTO_INCREMENT,
firstname VARCHAR(30),
lastname VARCHAR(30),
cell_no VARCHAR(15),
email_id VARCHAR(30),
website VARCHAR(150),
birthdate DATE,
created TIMESTAMP DEFAULT NOW()
);
CREANDO PROYECTO EN ECLIPSE
Abra Eclipse e ir Archivo -> Nuevo -> Proyecto y seleccione Proyecto Web Dinámico en la pantalla
del Asistente de Nuevo Proyecto. Bueno esta parte ya lo saben pero bueno también está ahí.
Después de seleccionar Dynamic Web Project, pulse Siguiente.
Escriba el nombre del proyecto. Por ejemplo ContactManager. Una vez hecho esto, seleccione el
entorno de ejecución de destino (por ejemplo, Apache Tomcat v6.0). Esto es para ejecutar el
proyecto dentro del entorno de Eclipse. Después de esto, pulse Finalizar.
Necesitaremos una carpeta de origen llamada recursos. Haga clic derecho en Proyecto en el
explorador de proyectos y seleccione Nueva -> Carpeta de origen y cree una carpeta con recursos
de nombre.
También crearemos paquetes Java para nuestra aplicación. Como usaremos Struts2, seguiremos la
arquitectura MVC. Cree 4 paquetes en las fuentes.
Hemos creado 4 nuevos paquetes. El net.viralpatel.contact.controller llevará a cabo la clase Java
que actuará como controlador y buscará los datos de la base de datos y los pasará a la
vista. El paquete net.viralpatel.contact.model contendrá la clase de modelo persistente de
Hibernate. El net.viralpatel.contact.view contendrá la clase de acción struts2. Y finalmente
el net.viralpatel.contact.util tendrá algún archivo de utilidad relacionada con hibernación que se
verá en breve. Bueno Uds. Le podrían poner otro nombre.
ARCHIVOS JAR REQUERIDOS
Ahora copie todos los archivos JAR necesarios en la carpeta WebContent -> WEB-INF -> lib. Cree
esta carpeta si no existe. Aquí también saben hacerlo o sea que no hay problema.
Crear JSP para el Administrador de contactos
Solo necesitaremos un archivo JSP para este tutorial. El JSP incluirá un formulario para agregar
nuevo contacto, así como la lista de los contactos al final. Cree un archivo JSP index.jsp en
la carpeta WebContent y copie el siguiente contenido en él.
WebContent / index.jsp
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<title>Contact Manager - Struts2 Hibernate Example</title>
</head>
<body>
<h1>Contact Manager</h1>
<s:actionerror/>
<s:form action="add" method="post">
<s:textfield name="contact.firstName" label="Firstname"/>
<s:textfield name="contact.lastName" label="Lastname"/>
<s:textfield name="contact.emailId" label="Email"/>
<s:textfield name="contact.cellNo" label="Cell No."/>
<s:textfield name="contact.website" label="Homepage"/>
<s:textfield name="contact.birthDate" label="Birthdate"/>
<s:submit value="Add Contact" align="center"/>
</s:form>
<h2>Contacts</h2>
<table>
<tr>
<th>Name</th>
<th>Email</th>
<th>Cell No.</th>
<th>Birthdate</th>
<th>Homepage</th>
<th>Delete</th>
</tr>
<s:iterator value="contactList" var="contact">
<tr>
<td><s:property value="lastName"/>, <s:property value="firstName"/> </td>
<td><s:property value="emailId"/></td>
<td><s:property value="cellNo"/></td>
<td><s:property value="birthDate"/></td>
<td><a href="<s:property value="website"/>">link</a></td>
<td><a href="delete?id=<s:property value="id"/>">delete</a></td>
</tr>
</s:iterator>
</table>
</body>
</html>
Adición del soporte de Hibernate
Para agregar soporte de hibernación, agregaremos el código fuente siguiente en la aplicación de
Contact Manager.
Hibernate.cfg.xml - Este es el archivo de configuración de Hibernate. Este archivo contendrá
configuraciones como información de conexión a la base de datos, información de clase de
persistencia, etc. Cree hibernate.cfg.xml en la carpeta de recursos y copie el contenido siguiente en
él.
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="connection.url">
jdbc:mysql://localhost:3306/ContactManager
</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="connection.pool_size">1</property>
<property name="dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name="current_session_context_class">thread</property>
<property name="cache.provider_class">
org.hibernate.cache.NoCacheProvider
</property>
<property name="show_sql">true</property>
<property name="hbm2ddl.auto">update</property>
<mapping class="net.viralpatel.contact.model.Contact" />
</session-factory>
</hibernate-configuration>
HibernateUtil.java - Este es el archivo Util que usamos para crear una conexión con hibernate. Cree
HibernateUtil.java en el paquete net.viralpatel.contact.util y copie el siguiente contenido en él.
package net.viralpatel.contact.util;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
public class HibernateUtil {
private static final SessionFactory sessionFactory = buildSessionFactory();
private static SessionFactory buildSessionFactory() {
try {
// Create the SessionFactory from hibernate.cfg.xml
return new AnnotationConfiguration().configure()
.buildSessionFactory();
} catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}
Contact.java - Esta es la clase de entidad de persistencia que se asignará a la tabla Contactos en
MySQL. Crear Contact.java bajo paquete net.viralpatel.contact.model y copiar el siguiente
contenido en él.
package net.viralpatel.contact.model;
import java.io.Serializable;
import java.sql.Date;
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 implements Serializable{
private static final long serialVersionUID = -8767337896773261247L;
private Long id;
private String firstName;
private String lastName;
private String emailId;
private String cellNo;
private Date birthDate;
private String website;
private Date created;
@Id
@GeneratedValue
@Column(name="id")
public Long getId() {
return id;
}
@Column(name="firstname")
public String getFirstName() {
return firstName;
}
@Column(name="lastname")
public String getLastName() {
return lastName;
}
@Column(name="email_id")
public String getEmailId() {
return emailId;
}
@Column(name="cell_no")
public String getCellNo() {
return cellNo;
}
@Column(name="birthdate")
public Date getBirthDate() {
return birthDate;
}
@Column(name="website")
public String getWebsite() {
return website;
}
@Column(name="created")
public Date getCreated() {
return created;
}
public void setId(Long id) {
this.id = id;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public void setEmailId(String emailId) {
this.emailId = emailId;
}
public void setCellNo(String cellNo) {
this.cellNo = cellNo;
}
public void setBirthDate(Date birthDate) {
this.birthDate = birthDate;
}
public void setCreated(Date created) {
this.created = created;
}
public void setWebsite(String website) {
this.website = website;
}
}
private static final long serialVersionUID = -8767337896773261247L;
Eso es porque la clase Applet implementa el interfaz Serializable. Las clases que implementan este
interfaz son susceptibles de ser serializadas (es decir, las instancias de estas clases pueden guardarse
y leerse en/de disco -o cualquier otro dispositivo de entrada/salida-).
Simplificando mucho la lógica de serialización, lo que sucede es que los atributos del objeto se
convierten en cadenas de bytes y se guardan en el disco. Para leer un objeto, se leen las cadenas de
bytes y se reconstruye el objeto a partir de ellos.
Imagina que tienes una aplicación que serializa en disco una serie de objetos al cerrarse y los lee en
la siguiente ejecución para mantener los valores que tenían antes. En un momento dado, modificas
una de las clases añadiendo un atributo nuevo. Al ejecutar esta versión de la aplicación por primera
vez, intentará leer de disco los objetos que fueron serializados... pero falta un campo en los objetos
de la clase que has modificado (cuando se serializaron el campo no existia) y tu aplicación
"teóricamente" va a leer datos corruptos puesto que "teóricamente" no puede saber que la clase
ha cambiado (veremos que si puede saberlo).
El campo serialVersionUID es el número de versión de la clase. Cuando el objeto es serializado lo
primero que hace es escribir el serialVersionUID. Si al leer el objeto se dectecta que el valor del
serialVersionUID guardado no coincide con el actual se lanza una exception InvalidClassException,
de modo que el programador puede tratar la excepción de manera adecuada (por ejemplo, creando
un objeto por defecto para susbtituir al que no puede leerse).
Para que este mecanismo funcione bien, el programador debe proveer el campo private static final
long serialVersionUID en todas las clases que implementen Serializable y en todas las subclases de
ellas (este es tu caso). El valor es indiferente, pero debes actualizarlo cada vez que modificas tu clase
añadiendo o quitando atributos (lo más sencillo en incrementarlo en 1). Si el programador no indica
este campo la JVM añade uno por su cuenta, sin embargo no es demasiado conveniente permitir
esto (al cambiar ligeramente el programa o cambiar la JMV podría cambiar el valor y darte una
desagradable sorpresa)
Realmente esto no es necesario si no vas a serializar los objetos... pero como nunca se sabe, no es
mala idea que proveas este valor y lo mantengas.
Tenga en cuenta cómo hemos mapeado la clase de contacto con la tabla de contactos mediante
anotaciones Java de API de persistencia.
Adición del controlador para acceder a los datos
Vamos a añadir una clase de controlador en la aplicación de Contact Manager que se utilizará para
obtener / guardar datos de hibernación. Este controlador será invocado desde la clase de acción de
Struts. Cree un archivo ContactManager.java en el paquete net.viralpatel.contact.controller y
copie el siguiente contenido en él.
package net.viralpatel.contact.controller;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.classic.Session;
import net.viralpatel.contact.model.Contact;
import net.viralpatel.contact.util.HibernateUtil;
public class ContactManager extends HibernateUtil {
public Contact add(Contact contact) {
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
session.save(contact);
session.getTransaction().commit();
return contact;
}
public Contact delete(Long id) {
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Contact contact = (Contact) session.load(Contact.class, id);
if(null != contact) {
session.delete(contact);
}
session.getTransaction().commit();
return contact;
}
public List<Contact> list() {
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
List<Contact> contacts = null;
try {
contacts = (List<Contact>)session.createQuery("from Contact").list();
} catch (HibernateException e) {
e.printStackTrace();
session.getTransaction().rollback();
}
session.getTransaction().commit();
return contacts;
}
}
Tenga en cuenta que la forma en que hemos creado diferentes métodos en la clase controlador para
agregar / eliminar / lista de los contactos. También la clase ContactManager está extendiendo la
clase HibernateUtil permitiéndole así acceder al objeto sessionFactory .
Adición del soporte de Struts2
Añadamos soporte de Struts2 a nuestra aplicación web. Para ello, agregará la siguiente entrada en
el descriptor de despliegue (WEB-INF / web.xml).
Agregue el filtro Struts2 en web.xml
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
Creación de struts.xml
Necesitaremos crear un archivo struts.xml que contenga la asignación de acciones para nuestro
ejemplo. Cree un archivo struts.xml en la carpeta de recursos y agregue el siguiente contenido al
mismo.
Struts.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name="struts.enable.DynamicMethodInvocation"
value="false" />
<constant name="struts.devMode" value="false" />
<package name="default" extends="struts-default" namespace="/">
<action name="add"
class="net.viralpatel.contact.view.ContactAction" method="add">
<result name="success" type="chain">index</result>
<result name="input" type="chain">index</result>
</action>
<action name="delete"
class="net.viralpatel.contact.view.ContactAction" method="delete">
<result name="success" type="chain">index</result>
</action>
<action name="index"
class="net.viralpatel.contact.view.ContactAction">
<result name="success">index.jsp</result>
</action>
</package>
</struts>
Crear clase de acción
Hasta ahora casi hemos completado nuestra aplicación de Contact Manager en Struts2 e
Hibernate. La única tarea que queda es añadir la clase Struts Action. Cree una
clase ContactAction.java en el paquete net.viralpatel.contact.view y copie el siguiente contenido
en él.
package net.viralpatel.contact.view;
import java.util.List;
import net.viralpatel.contact.controller.ContactManager;
import net.viralpatel.contact.model.Contact;
import com.opensymphony.xwork2.ActionSupport;
public class ContactAction extends ActionSupport {
private static final long serialVersionUID = 9149826260758390091L;
private Contact contact;
private List<Contact> contactList;
private Long id;
private ContactManager contactManager;
public ContactAction() {
contactManager = new ContactManager();
}
public String execute() {
this.contactList = contactManager.list();
System.out.println("execute called");
return SUCCESS;
}
public String add() {
System.out.println(getContact());
try {
contactManager.add(getContact());
} catch (Exception e) {
e.printStackTrace();
}
this.contactList = contactManager.list();
return SUCCESS;
}
public String delete() {
contactManager.delete(getId());
return SUCCESS;
}
public Contact getContact() {
return contact;
}
public List<Contact> getContactList() {
return contactList;
}
public void setContact(Contact contact) {
this.contact = contact;
}
public void setContactList(List<Contact> contactsList) {
this.contactList = contactsList;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
}
ContactActionClase contiene diferentes métodos que se llama por Struts2. El método execute () es
el método por defecto que se llama cuando llamamos / indexamos la acción desde el
navegador. Obtiene la lista de contactos y la visualiza en index.jsp. Del mismo modo, cuando se
agrega un nuevo contacto, se llama al método add (). Si marca la entrada de asignación de acciones
en struts.xmlpara el add()método, el <resultado> se asigna con /indexacción y el tipo es cadena. Esto
se debe a que queremos mostrar la lista de contacto una vez que añadimos una nueva. Por lo tanto,
hemos hecho Acción de encadenamiento y llamado /indexacción tras /addacción.
La aplicación de Contact Manager
Eso es. La aplicación está lista, sólo compila y ejecuta el proyecto en Ejecutar Eclipse -> Ejecutar
como -> Ejecutar en el servidor. Establezca la dirección URL en:
http: // localhost: <puerto> / <nombre del proyecto> / índice
Rellene el formulario de contacto y pulse enter y el nuevo contacto se mantendrá en la base de
datos y se mostrará en la tabla de abajo. Del mismo modo, haga clic en el enlace eliminar junto a un
registro. Se eliminará el registro de la base de datos.
Espero haberlo ayudado
