- 1 -

Desarrollo de aplicaciones J2EE. Índice 1. Introducción.................................................................................................2 2. Nuevo proyecto de ejemplo. .....................................................................2 3. Estructura del proyecto. Ficheros y directorios. .....................................5 4. Librería c3p0. ..............................................................................................6 5. Configuración de la base de datos. .........................................................7 6. Esquema de la base de datos. .................................................................8 7. Gestión del modelo. ...................................................................................9 8. Controlador mediante Managed Bean................................................. 15 9. Configuración de los redireccionamientos. faces-config.xml........... 17 10. Parte visual. ........................................................................................... 18 Referencias ................................................................................................... 20

- 2 -

1. Introducción. En este manual se va a explicar cómo desarrollar una aplicación J2EE muy básica en NetBeans haciendo uso de dos Framework: Hibernate y JSF (JavaServer Faces). La herramienta Hibernate se usa para las conexiones con la base de datos y el framework JSF para la interacción entre la parte visual y el modelo de nuestra aplicación. Lo que es conocido también como controlador. Como consecuente, estas aplicaciones están basadas en el modelo vista controlador. El modelo está representado por las clases generadas con Hibernate: clases base que representarán las tablas de la base de datos y clases gestoras que se encargarán de manejar dichos datos. La vista la componen todos los ficheros JSP, CSS, HTML, Javascript, … que se encargarán de reproducir el resultado de las acciones realizadas. El controlador está diseñado con el framework JSF e interactúa con la vista mediante etiquetas específicas en los ficheros JSP. Opcionalmente, se pueden diseñar Servlet para dar otros servicios interactuando con el modelo. También son usadas otras tecnologías como HTML, CSS y Javascript para añadir más funcionalidad a la parte visual de la aplicación, pero que en este manual no se explicará. 2. Nuevo proyecto de ejemplo. Se abre el NetBeans y se selecciona la opción de nuevo proyecto. Se tienen cuatro pasos en los que habrá que indicar la ubicación del proyecto, el servidor y los frameworks a usar. Todos los proyectos hacen uso, como mínimo, de los dos framework anteriormente mencionados, Hibernate y JSF, y del servidor Tomcat (recomendado). La explicación del desarrollo de este proyecto también es válida para el servidor Glassfish 2 ya que no necesita ninguna configuración adicional.

- 3 -

2.1. Selección del tipo de proyecto: Java Web, Web Application

2.2. Indicar el nombre del proyecto y su ubicación.

- 4 -

2.3.a. Selección del servidor: Tomcat / Glassfish 2 2.3.b. Selección de la versión J2EE: Java EE 5

2.4. Selección de los frameworks: Hibernate y JSF (dejar todo por defecto).

- 5 -

3. Estructura del proyecto. Ficheros y directorios. Una vez planificado cual será nuestro modelo, nuestro proyecto de ejemplo quedará así:

Existen dos carpetas principales: Web Pages y Source Packages. En Web Pages se encuentran:

- WEB-INF: ficheros de configuración para el servidor y librerías. - css: carpeta con los ficheros de estilos. - img: carpeta con las imágenes que se verán. - includes: ficheros JSP comunes en varios ficheros JSP. - js: ficheros Javascript. - Ficheros JSP, HTML, …

En Source Packages se encuentran:

- Ficheros de configuración de Hibernate: conexión y esquema de base de datos.

- Paquete de Hibernate: ficheros comunes, clases entidad y clases gestoras.

- Paquete web: fichero que tiene las acciones que se realizarán y que se usarán en la parte visual mediante etiquetas JSF.

- 6 -

4. Librería c3p0. Para aplicaciones web de larga vida con conexiones a base de datos existe el gran inconveniente de que MySQL finaliza por defecto todas las conexiones después de las 8 horas de inactividad. Problema: Hibernate no es capaz de volver a conectar sin configurar algún tipo de pool de conexiones. Si queremos desarrollar una aplicación J2EE diseñada con Hibernate y usando conexiones sobre MySQL se tiene que incluir alguna funcionalidad que permita solventar este problema. Esta solución la proporciona la librería c3p0. c3p0 es una librería de fácil uso que aumenta la funcionalidad de los drivers JDBC para las conexiones de las aplicaciones con base de datos. No necesita ninguna instalación, simplemente se agrega la librería a la aplicación y se modifica el archivo de configuración de Hibernate para su uso. 4.1. Se descarga la librería desde aquí: http://sourceforge.net/projects/c3p0/ 4.2. Se incluye los ficheros JAR de la librería en el proyecto. Botón Add JAR/Folder.

4.3. Añadir también estos ficheros en la carpeta lib dentro de WEB-INF.

- 7 -

5. Configuración de la base de datos. Toda la configuración de la base de datos se incluye en el archivo: hibernate.cfg.xml No hace falta crear ninguna tabla, automáticamente las crea Hibernate. Dentro de la etiqueta session-factory se indican las propiedades que se usarán indicando: <property name=”nombre de la propiedad”>VALOR</property> Destacar que en este fichero se incluye la configuración de la librería c3p0 para prevenir las caídas de conexiones MySQL. Antes de finalizar la etiqueta session-factory se añaden los archivos con el esquema de la base de datos indicando: <mapping resource=”archivo.hbm.xml” />

<?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> <!-- Base de datos --> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/proyecto</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">********</property> <property name="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</property> <property name="hibernate.cache.region_prefix">hibernate.test</property> <property name="hibernate.connection.pool_size">1</property> <!-- Enable Hibernate's automatic session context management--> <property name="hibernate.current_session_context_class">thread</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="hibernate.format_sql">true</property> <property name="hibernate.jdbc.batch_versioned_data">true</property> <property name="hibernate.jdbc.use_streams_for_binary">true</property> <property name="hibernate.max_fetch_depth">1</property> <property name="hibernate.proxool.pool_alias">pool1</property> <property name="hibernate.query.substitutions">yes 'Y', no 'N'</property> <!-- Disable the second-level cache --> <!-- <property name="hibernate.cache.provider_class">org.hibernate.cache.NoCacheProvider</property> --> <!-- Echo all executed SQL to stdout --> <property name="hibernate.show_sql">false</property> <!-- Update the database schema on startup --> <property name="hibernate.hbm2ddl.auto">update</property> <!-- configuration pool via c3p0--> <property name="c3p0.acquire_increment">1</property> <property name="c3p0.idle_test_period">100</property> <!-- seconds --> <property name="c3p0.max_size">100</property> <property name="c3p0.max_statements">0</property> <property name="c3p0.min_size">10</property> <property name="c3p0.timeout">100</property> <!-- seconds --> <!-- DEPRECATED very expensive property name="c3p0.validate>--> <mapping resource="ddbb.hbm.xml"/> </session-factory> </hibernate-configuration>

- 8 -

6. Esquema de la base de datos. En el paquete database.entity se crean todas las clases del modelo de nuestra aplicación. En las clases del modelo se indican los atributos y los métodos GETTER y SETTER de cada uno de ellos. Opcionalmente, se pueden añadir otros. Se recomienda el uso de objetos para todos los atributos en lugar de tipos primitivos como int. También se recomienda el uso de valor numérico para los valores booleans por problemas de conversión. Register.java

package database.entity; import java.sql.Timestamp; public class Register { private Integer id; private String name; private Timestamp currentTime; private Double price; private Integer enabled; public Register(){ name = ""; currentTime = new Timestamp(System.currentTimeMillis()); price = new Double(0); enabled = 0; } public Timestamp getCurrentTime() { return currentTime; } public void setCurrentTime(Timestamp currentTime) { this.currentTime = currentTime; } public Integer getEnabled() { return enabled; } public void setEnabled(Integer enabled) { this.enabled = enabled; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; }

- 9 -

Como se comentó anteriormente el esquema de la base de datos va en el fichero ddbb.hbm.xml indicado en hibernate.cfg.xml. En este fichero se indican todas las clases del modelo junto con sus atributos y relaciones con otras clases del modelo. 7. Gestión del modelo. Todas las clases que gestionan al modelo de la aplicación se sitúan en el paquete database.manager. Las clases gestoras suelen tener los mismos métodos por lo que se diseña una clase abstracta que recogerá esa funcionalidad común. Para la conexión con el session-factory se diseña una clase estándar y para funcionalidades adicionales se diseñará una tercera clase. Estas clases se incluyen en el paquete database.common. La clase estándar se puede generar mediante NetBeans.

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="database.entity.Register" table="register"> <id column="register_id" name="id"> <generator class="identity"/> </id> <property name="name" /> <property name="currentTime" column="time_current" /> <property name="price"/> <property name="enabled" /> </class> </hibernate-mapping>

public Double getPrice() { return price; } public void setPrice(Double price) { this.price = price; } }

- 10 -

7.1.a. Se indica un nuevo archivo en el paquete database.common. 7.1.b. Se selecciona Hibernate, HibernateUtil.java

Por defecto, toma el archivo hibernate.cfg.xml. HibernateUtil.java

package database.common; import org.hibernate.cfg.AnnotationConfiguration; import org.hibernate.SessionFactory; public class HibernateUtil { private static final SessionFactory sessionFactory; static { try { // Create the SessionFactory from standard (hibernate.cfg.xml) // config file. sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory(); } catch (Throwable ex) { // Log the exception. System.err.println("Initial SessionFactory creation failed." + ex); throw new ExceptionInInitializerError(ex); } } public static SessionFactory getSessionFactory() { return sessionFactory; } }

- 11 -

7.2. Creamos una clase con funcionalidades adicionales. Util.java 7.3. Se añaden dos métodos más a la clase Register.java para gestionar los valores booleans que previamente se recomendó usar valores numéricos por problemas de conversión. 7.4. Se diseña la clase gestora con las funcionalidades comunes: crear, actualizar, borrar, listar, ... HibernateManager.java

package database.common; public class Util { public static int boolean2int(boolean value){ if(value){ return 1; } else { return 0; } } }

public Boolean isEnabled(){ return enabled > 0 ? true : false; } public void setEnabled(Boolean value){ this.enabled = Util.boolean2int(value); }

package database.common; import java.util.ArrayList; import java.util.List; import org.hibernate.Session; import org.hibernate.criterion.Projections; import org.hibernate.criterion.Restrictions; public abstract class HibernateManager { protected Object myClass = new Object(); // tipo de objeto protected String TABLE = ""; // nombre de la tabla

- 12 -

/** * Obtener un elemento a partir de su identificador * Se supone que en todas las entidades existe el atributo id que las identifica * @param id * @return */ public Object getElementById(Long id){ Object obj = new Object(); // obtener la sesion actual Session session = getSession(); try { // comenzar la transaccion session.beginTransaction(); // cargar objeto por clave obj = session.createCriteria(myClass.getClass()).add(Restrictions.eq("id", id)).uniqueResult(); // confirmar transaccion session.getTransaction().commit(); } catch (Exception e) { System.out.println("Error en getElementById: " + e); // deshacer transaccion this.rollback(); } return obj; } /** * Guardar un objeto en la base de datos * @param o */ public boolean create(Object o) { // obtener la sesion actual Session session = getSession(); try { // comenzar la transaccion session.beginTransaction(); // almacenarlo session.save(o); // confirmar transaccion session.getTransaction().commit(); } catch (Exception e) { System.out.println("Error en create: " + e); // deshacer transaccion this.rollback(); return false; } return true; } /** * Actualizar un objeto en la base de datos * @param o */ public boolean update(Object o){ // obtener la sesion actual Session session = getSession(); try { // comenzar la transaccion session.beginTransaction(); // actualizarlo session.saveOrUpdate(o); // confirmar transaccion session.getTransaction().commit(); } catch (Exception e) { System.out.println("Error en update: " + e); // deshacer transaccion this.rollback(); return false; } return true; }

- 13 -

/** * Borrar un objeto de la base de datos * @param o */ public boolean delete(Object o) { if(o == null){ return false; } // obtener la sesion actual Session session = getSession(); try { // comenzar la transaccion session.beginTransaction(); // borrarlo session.delete(o); // confirmar transaccion session.getTransaction().commit(); } catch (Exception e) { System.out.println("Error en delete: " + e); // deshacer transaccion this.rollback(); return false; } return true; } /** * Obtener la lista de registros para una entidad * @return */ public List getList(){ // obtener la sesion actual Session session = getSession(); List result = new ArrayList(); try { // comenzar la transaccion session.beginTransaction(); // obtener la lista de eventos result = session.createCriteria(myClass.getClass()).list(); // confirmar transaccion session.getTransaction().commit(); } catch (Exception e) { System.out.println("Error en getList: " + e); // deshacer transaccion this.rollback(); } return result; } /** * Obtener una lista de registros de una entidad limitada * @param ini Indice inicial * @param batch Cantidad de registros a obtener * @return */ public List getSubList(int ini, int batch){ // obtener la sesion actual Session session = getSession(); List result = new ArrayList(); try { // comenzar la transaccion session.beginTransaction(); // obtener la lista de eventos List aux = session.createCriteria(myClass.getClass()).list(); for(int i = ini; i < aux.size() && i < ini + batch; i++){ result.add(aux.get(i)); } // confirmar transaccion session.getTransaction().commit(); } catch (Exception e) { System.out.println("Error en getSubList: " + e); // deshacer transaccion this.rollback(); } return result; }

- 14 -

/** * Cantidad de registros de una entidad * @return */ public int getListCount() { Number count = 0; // obtener la sesion actual Session session = getSession(); try { // comenzar la transaccion session.beginTransaction(); // obtener la cantidad count = (Number) session.createCriteria(myClass.getClass()).setProjection(Projections.rowCount()).uniqueResult(); // confirmar transaccion session.getTransaction().commit(); } catch (Exception e) { System.out.println("Error en getListCount: " + e); // deshacer transaccion this.rollback(); } return count.intValue(); } /** * Comprobar si esta repetido un objeto a partir de un valor de un atributo * @param attr * @param value * @return */ public boolean checkRepeated(String attr, String value){ Object obj = new Object(); // obtener la sesion actual Session session = getSession(); try { // comenzar la transaccion session.beginTransaction(); // cargar objeto por clave obj = session.createCriteria(myClass.getClass()).add(Restrictions.eq(attr, value)).uniqueResult(); // confirmar transaccion session.getTransaction().commit(); } catch (Exception e) { System.out.println("Error en checkRepeated: " + e); // deshacer transaccion this.rollback(); } return obj != null ? true : false; } /** * Obtener la sesion de hibernate para el acceso a la base de datos * @return */ protected Session getSession(){ Session session = null; try { session = HibernateUtil.getSessionFactory().getCurrentSession(); if(!session.isOpen()){ session = HibernateUtil.getSessionFactory().openSession(); } } catch(Exception e){ session = HibernateUtil.getSessionFactory().openSession(); } return session; } /** * Obtener el nombre de la tabla al que hace referencia * @return */ public String getTableName(){ return TABLE; }

- 15 -

7.5. Para cada clase del modelo se diseña otra en el paquete database.manager que heredará de HibernateManager y que se encargará de gestionar dicha clase del modelo indicando solamente el nombre de la tabla y la clase del modelo. RegisterManager.java 8. Controlador mediante Managed Bean. En el Managed Bean se encontraran al menos una instancia para cada clase del modelo y su gestor como atributos. La instancia de una clase del modelo se usa para hacer referencia en la vista a dicho tipo de objeto y tratarlo como tal accediendo a sus métodos. Las clases gestoras se mantendrán sólo en la parte del controlador. También se añadirá un objeto del tipo DataModel para hacer los listados en la vista. Por tanto, los objetos que se referencien en la parte de la vista tendrán sus métodos GETTER y SETTER. Estos son: los objetos de clases del modelo, los objetos de listado (DataModel) y todos aquéllos que se incorporen como auxiliares. Las acciones que se indicarán en la parte de la vista serán métodos en el Managed Bean que devuelven un String para redireccionar a la página deseada indicada en faces-config.xml.

/** * Hacer rollback y que no se termine la aplicacion tras un fallo */ public void rollback(){ Session session = getSession(); try { // deshacer transaccion session.getTransaction().rollback(); } catch (Exception e) { System.out.println("Error en rollback: " + e); } } }

package database.manager; import database.common.HibernateManager; import database.entity.Register; public class RegisterManager extends HibernateManager { public RegisterManager(){ TABLE = "register"; myClass = new Register(); } }

- 16 -

WebManagedBean.java

package web; import database.entity.Register; import database.manager.RegisterManager; import java.util.ArrayList; import java.util.List; import javax.faces.model.DataModel; import javax.faces.model.ListDataModel; import javax.faces.model.SelectItem; public class WebManagedBean { // objetos del modelo para usar en la vista private Register register = new Register(); // gestion del modelo private RegisterManager registerManager = new RegisterManager(); // acceso a los datos de register private DataModel data = null; private Integer value = new Integer(0); public WebManagedBean() { } public Integer getValue() { return value; } public void setValue(Integer value) { this.value = value; } public Register getRegister() { return register; } public void setRegister(Register register) { this.register = register; } public DataModel getData() { if(data == null){ refreshListRegister(); } return data; } public void setData(DataModel data) { this.data = data; } public String newRegister(){ if(!registerManager.checkRepeated("name", register.getName())){ register.setEnabled(value); registerManager.create(register); } return gotoIndex(); } public String updateRegister(){ registerManager.update(register); return "update"; } public String deleteRegister(){ register = (Register) data.getRowData(); registerManager.delete(register); return gotoIndex(); }

- 17 -

9. Configuración de los redireccionamientos. faces-config.xml En el archivo faces-config.xml situado en la carpeta WEB-INF se configuran los redireccionamientos de los resultados de los métodos de las clases Managed Bean, además del uso de dichas clases en la vista.

public String gotoIndex(){ refreshListRegister(); // limpiar informacion register = new Register(); value = new Integer(0); return "index"; } public String gotoUpdate(){ register = (Register) data.getRowData(); value = register.getEnabled(); return "update"; } private void refreshListRegister(){ List<Register> list = registerManager.getList(); data = new ListDataModel(list); // lista actualizada } public List getAvailableOptions(){ List selectItems = new ArrayList(); selectItems.add(new SelectItem(new Integer(1), "Activar")); selectItems.add(new SelectItem(new Integer(0), "Desactivar")); return selectItems; } }

<?xml version='1.0' encoding='UTF-8'?> <faces-config version="1.2" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd"> <managed-bean> <managed-bean-name>WebManagedBean</managed-bean-name> <managed-bean-class>web.WebManagedBean</managed-bean-class> <managed-bean-scope>session</managed-bean-scope> </managed-bean> <!-- Reglas para ManagedBean --> <navigation-rule> <from-view-id>*</from-view-id> <navigation-case> <from-outcome>index</from-outcome> <to-view-id>/index.jsp</to-view-id> <redirect/> </navigation-case> </navigation-rule> <navigation-rule> <from-view-id>*</from-view-id> <navigation-case> <from-outcome>update</from-outcome> <to-view-id>/update.jsp</to-view-id> <redirect/> </navigation-case> </navigation-rule> </faces-config>

- 18 -

10. Parte visual. En la parte visual, para hacer uso de las etiquetas del framework JSF se añade previamente a su uso las siguientes líneas, indicando las librerías: El contenido de todas las etiquetas JSF va entre la etiqueta <f:view>…</f:view> Para hacer uso de un método SETTER del Managed Bean se invoca al método quitando el prefijo set: Análogamente, para los métodos GETTER quitando el prefijo get: Para recorrer los listados se usa la etiqueta <h:dataTable> y se indica una variable que contendrá cada registro: La inclusión de otros ficheros se hace mediante la etiqueta <jsp:include>: header.jsp footer.jsp

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%> <%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

<h:inputText value="#{WebManagedBean.register.name}" />

<h:outputText value="#{WebManagedBean.register.name}"/>

<h:dataTable value='#{WebManagedBean.data}' var='dataTableItem'> <h:outputText value="#{dataTableItem.name}"/>

</h:dataTable>

<jsp:include page="includes/header.jsp" />

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"> <title>Proyecto</title> </head> <body>

</body> </html>

- 19 -

index.jsp

<jsp:include page="includes/header.jsp" /> <%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%> <%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%> <f:view> <h:form> <h2>Nuevo registro</h2> <table> <tr> <td>Nombre:</td> <td><h:inputText value="#{WebManagedBean.register.name}" /></td> </tr> <tr> <td>Precio:</td> <td><h:inputText value="#{WebManagedBean.register.price}" /></td> </tr> <tr> <td>Activar:</td> <td> <h:selectOneMenu value="#{WebManagedBean.value}"> <f:selectItems value="#{WebManagedBean.availableOptions}"/> </h:selectOneMenu> </td> </tr> <tr> <td></td> <td> <h:commandButton action="#{WebManagedBean.newRegister}" value="Crear"/> </td> </tr> </table> <h2>Listado</h2> <h:dataTable value='#{WebManagedBean.data}' var='dataTableItem'> <h:column> <f:facet name="header"> <h:outputText value="Nombre"/> </f:facet> <h:outputText value="#{dataTableItem.name}"/> </h:column> <h:column> <f:facet name="header"> <h:outputText value="Fecha"/> </f:facet> <h:outputText value="#{dataTableItem.currentTime}"> <f:convertDateTime pattern="dd/MM/yyyy HH:mm aaa" /> </h:outputText> </h:column> <h:column> <f:facet name="header"> <h:outputText value="Precio"/> </f:facet> <h:outputText value="#{dataTableItem.price}"/> </h:column> <h:column> <f:facet name="header"> <h:outputText value="Activo"/> </f:facet> <h:outputText rendered="#{dataTableItem.enabled == 0}" value="Deshabilitado"/> <h:outputText rendered="#{dataTableItem.enabled == 1}" value="Habilitado"/> </h:column> <h:column> <f:facet name="header"> <h:outputText value="Actualizar"/> </f:facet> <h:commandButton action="#{WebManagedBean.gotoUpdate}" value="A"/> </h:column>

- 20 -

Update.jsp Referencias Librería c3p0: http://blog.ticteck.es/2010/07/aplicaciones-j2ee-libreria-c3p0.html Descarga de este ejemplo: http://www.tutelocreesnen.es/programandocosas/descargas/j2ee/Proyecto.zip

<h:column> <f:facet name="header"> <h:outputText value="Borrar"/> </f:facet> <h:commandButton action="#{WebManagedBean.deleteRegister}" value="X"/> </h:column> </h:dataTable> </h:form> </f:view> <jsp:include page="includes/footer.jsp" />

<jsp:include page="includes/header.jsp" /> <f:view> <h:form> <table> <tr> <td>Nombre:</td> <td><h:outputText value="#{WebManagedBean.register.name}" /></td> </tr> <tr> <td>Precio:</td> <td><h:inputText value="#{WebManagedBean.register.price}" /></td> </tr> <tr> <td>Activar:</td> <td> <h:selectOneMenu value="#{WebManagedBean.value}"> <f:selectItems value="#{WebManagedBean.availableOptions}"/> </h:selectOneMenu> </td> </tr> <tr> <td></td> <td> <h:commandButton action="#{WebManagedBean.updateRegister}" value="Actualizar"/> </td> </tr> </table> <h:commandButton action="#{WebManagedBean.gotoIndex}" value="Volver"/> </h:form> </f:view> <jsp:include page="includes/footer.jsp" />