Embed Size (px)
DESCRIPTION
Guia y tutorial java
Citation preview
Guias y tutoriales de Java JEE en españolLas guías y tutoriales están desarrollados de manera muy práctica. Se dará una breve descripción del framework a usar, instalación y configuración de los componentes y herramientas para desarrollar las aplicaciones. Al final lo importante es que el lector aprenda y posteriormente sea capaz de desarrollar aplicaciones utilizando los frameworks ya sea en un entorno laboral o para asignaciones universitarias o de instituto.lunes, 2 de diciembre de 2013
- Spring 3 MVC sin mavenEn este tutorial describiré los pasos necesarios para realizar un proyecto Spring 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 tomadas correctamente en nuestra aplicación.
Introducción a Spring MVCEs 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 llamadoRequest 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 llamadaResponse a nuestro jsp para que se muestre con la información respectiva.
Proyecto en Spring MVCLas herramientas con las cuales trabajaremos son:
1. Eclipse Kepler 2. Apache Tomcat 7.0 3. Librerías Spring 3.1.0.RELEASE
Como indiqué anteriormente no explicaré como se realiza la instalación del Eclipse con su respectivo JDK ni el Tomcat por lo que se asume que ya tenéis el entorno instalado.
Primero que todo creamos un proyecto WEB en el eclipse: File -> New -> Dynamic Web Projecty el siguiente nombre al proyecto ProyectoSpringTutorial y a continuación Finish para crear el proyecto tal como podemos verlo en la imagen:
Figura 1.2
A continuación creamos en ProyectoSpringTutorial/src los siguientes paquetes:
1. com.victor.elliott.humala.controlador2. com.victor.elliott.humala.formulario3. com.victor.elliott.humala.servicios
Luego creamos las siguientes clases en los paquetes respectivos
1. com.victor.elliott.humala.controlador -> UsuarioController.java2. com.victor.elliott.humala.controlador -> ComponenteController.java3. com.victor.elliott.humala.formulario -> UsuarioForm.java4. com.victor.elliott.humala.formulario -> ComponenteForm.java5. com.victor.elliott.humala.servicios -> ComponenteService.java6. com.victor.elliott.humala.servicios -> ComponenteServiceImpl
Una vez creadas las clases creamos las paginas y xml's respectivos.1. Creamos primero que todo la carpeta jsp en ProyectoSpringTutorial/WebContent/WEB-INF2. Creamos index.jsp en ProyectoSpringTutorial/WebContent3. Creamos login.jsp en ProyectoSpringTutorial/WebContent/WEB-INF/jsp4. Creamos agregarComponentes.jsp en ProyectoSpringTutorial/WebContent/WEB-INF/jsp5. Creamos mostrarComponentes.jsp en ProyectoSpringTutorial/WebContent/WEB-INF/jsp6. Creamos web.xml en ProyectoSpringTutorial/WebContent/WEB-INF7. Creamos proyectoSpring-servlet.xml en ProyectoSpringTutorial/WebContent/WEB-INF
Una vez creadas nuestras clases, paginas y componentes que usaremos la estructura de proyecto debe de quedar de la siguiente manera:
Figura 1.3
Ahora que ya tenemos casi todos los elementos necesarios para empezar a desarrollar nuestro proyecto haremos la configuración con Spring para empezar a usar el framework sin errores y para esto primero bajemos las librerías necesarias que os la podéis descargar desde el siguiente link:
1. Librerias Spring 3.1.0.RELEASE Una vez descargado lo descomprimimos y lo añadiremos a nuestro proyecto de la siguiente manera:
Click derecho en ProyectoSpringTutorial -> 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 presionamos Abrir y finalmente OK. Saliendo de esa ventana pondremos Finish y ya tendremos nuestras librerías de Spring agregadas al proyecto tal como se muestra:
Figura 1.4
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 ProyectoSpringTutorial -> Deployment Assembly -> Add seleccionamos la librería Spring y OK y quedará tal como se muestra en la imagen.
Figura 1.5
Ahora si podemos empezar a codificar nuestro proyecto. Primero que todo modificamos com.victor.elliott.humala.controlador.UsuarioController de la siguiente manera:
?
1234567891011121314
package com.victor.elliott.humala.controlador; import com.victor.elliott.humala.formulario.UsuarioForm; 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; @Controllerpublic class UsuarioController { //Con esto indicamos que nuestro Usuario y clave seran Usuario y Clave respectivamente private static UsuarioForm usuarioForm = new UsuarioForm("Victor","Elliott"); @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");
15161718192021222324252627282930313233343536373
return new ModelAndView("login" , "usuarioForm", new UsuarioForm()); } @RequestMapping(value = "/verificarLogin.html", method = RequestMethod.POST) public ModelAndView verificarUsuario(@ModelAttribute("usuarioForm") UsuarioForm usuarioForm) { 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"); 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(usuarioForm.getNombre().equals(UsuarioController.usuarioForm.getNombre())&&usuarioForm.getClave().equals(UsuarioController.usuarioForm.getClave())){ 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("usuarioForm", usuarioForm); 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"); } } }
83940414243444546Ahora describo rápidamente el controlador:
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 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.8. Realizamos las validaciones respectivas donde la verificación principal es el else if 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); caso contrario si
la validación no resulto vuelvo a la pagina login.jsp con su mensaje respectivo.
Ahora modificamos com.victor.elliott.humala.formulario.UsuarioForm que básicamente contendrá los atributos nombre clave sus getter y setter respectivos y dos constructores.?
123456789101112131415161718192021222324252627
package com.victor.elliott.humala.formulario; public class UsuarioForm { private String nombre; private String clave; public UsuarioForm(){ this.nombre = ""; this.clave = ""; } public UsuarioForm(String nombre, String clave){ this.nombre = nombre; this.clave = clave; } 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; }}
Ahora modificamos ProyectoSpringTutorial\WebContent\index.jsp con el siguiente código:
?
1234
<%@ 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.jspAhora modificamos ProyectoSpringTutorial\WebContent\WEB-INF\jsp\login.jsp con el siguiente código:
?
12345678910111213141516171819202122232425262728293031323334
<%@ 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 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> <c: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>
Aquí básicamente definimos primero que todo el mensaje que se mostrará en caso de algún error del login aunque inicialmente ese mensaje estará vacío, caso contrario mostrará el mensaje respectivo. Luego definimos el @RequestMapping verificarLogin.html al cual invocará nuestro jsp cuando se realice el submit mediante el login a través del atributo action. Luego definimos el form donde nuestro objeto sera usuarioForm de method post ya que enviaremos información al servlet y la acción a realizar con el submit action="${verificarLogin} que definimos en var="verificarLogin" value="verificarLogin.html". 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.
Modificamos la página: ProyectoSpringTutorial\WebContent\WEB-INF\jsp\agregarComponentes.jsp con el siguiente código:
?
123456789101112
<%@ 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<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Agregar Componentes</title></head><body> <h4>${mensaje} : ${usuarioForm.nombre}</h4></body></html>
Donde simplemente mostramos el mensaje de confirmación correspondiente y el nombre del usuario que se logueó.
Ahora modificaremos los xml correspondientes a nuestro proyecto:ProyectoSpringTutorial\WebContent\WEB-INF\web.xml
?
1234567891011121314151617
<?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>ProyectoSpringTutorial</display-name> <servlet> <servlet-name>proyectoSpring</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>proyectoSpring</servlet-name> <url-pattern>*.html</url-pattern> </servlet-mapping></web-app>
Donde hay que percatarse que el nombre del servlet proyectoSpring tendrá que ser definido posteriormente como proyectoSpring-servlet.xml (agregandolo su sufijo -servlet.xml) para que esté correctamente
configurado.Ahora modificamos ProyectoSpringTutorial\WebContent\WEB-INF\proyectoSpring-servlet.xml de la siguiente manera:
?
12345678910111213141516171819
<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.6
Figura 1.7
Ahora continuo con la segunda parte del tutorial.
Una vez que ya tenemos el login realizado, nos disponemos a crear una lista de componentes que cargaremos una a una para luego poder verlas todas juntas.
Modificamos ProyectoSpringTutorial\src\com\victor\elliott\humala\servicios\ComponenteService.java de la siguiente forma:
?
1 package com.victor.elliott.humala.servicios;
2345678910
import com.victor.elliott.humala.formulario.ComponenteForm;import java.util.List; public interface ComponenteService { public void addComponente(ComponenteForm componente); public List<componenteform> getComponente();}</componenteform>
Aqui simplemente estamos creando un Servicio de tipo Interface donde solo declaramos dos métodos addComponente para agregar el componente y getComponente para recuperar todos los componentes.Ahora creamos su implementación respectiva modificando:ProyectoSpringTutorial\src\com\victor\elliott\humala\servicios\ComponenteServiceImpl.javade la siguiente forma:
?
12345678910111213141516171819
package com.victor.elliott.humala.servicios; import java.util.ArrayList;import java.util.List;import org.springframework.stereotype.Service;import com.victor.elliott.humala.formulario.ComponenteForm; @Servicepublic class ComponenteServiceImpl implements ComponenteService { private static List<ComponenteForm> listaComponentes=new ArrayList<ComponenteForm>(); public void addComponente(ComponenteForm componente) { listaComponentes.add(componente); } public List<ComponenteForm> getComponente() { return listaComponentes; }}
De esta forma implementamos los métodos de la interface primero declarando un atributo estático List<ComponenteForm> listaComponentes que me guardará todos los datos que ingrese en mi lista y no se perderá y luego con los metodos addComponente agrego un componente a la lista y con getComponente recupero toda la lista estática.En consiguiente modificamos la clase:ProyectoSpringTutorial\src\com\victor\elliott\humala\formulario\ComponenteForm.java tal como sigue::
?
12345678910111213141516171819202122232425262728293031323334
package com.victor.elliott.humala.formulario; public class ComponenteForm { private String nombre; private String version; private String tipo; private String extension; 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; } }
Clase que contiene todos los datos que deseo guardar de un componente. Finalmente modifico los controladores:
/ProyectoSpringTutorial/src/com/victor/elliott/humala/controlador/UsuarioController.java
?
123
package com.victor.elliott.humala.controlador; import com.victor.elliott.humala.formulario.UsuarioForm;
45678910111213141516171819202122232425262728293
import com.victor.elliott.humala.formulario.ComponenteForm;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; @Controllerpublic class UsuarioController { //Con esto indicamos que nuestro Usuario y clave seran Usuario y Clave respectivamente private static UsuarioForm usuarioForm = new UsuarioForm("Victor","Elliott"); //private static ComponenteForm componenteForm = new ComponenteForm(); @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) { 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"); 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(usuarioForm.getNombre().equals(UsuarioController.usuarioForm.getNombre())&&usuarioForm.getClave().equals(UsuarioController.usuarioForm.getClave())){ 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("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"); } } }
0313233343536373839404142434445464748Donde a diferencia del inicial agrego componenteForm al jsp haciendo modelo.addObject("componenteForm", new ComponenteForm()); para que me cargue el formulario vacío.
Luego modificamos:\ProyectoSpringTutorial\src\com\victor\elliott\humala\controlador\ComponenteController.java de la siguiente forma:
?
12345678910111213141516171819202122232425262728293031323334353637
package com.victor.elliott.humala.controlador; 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; import com.victor.elliott.humala.formulario.ComponenteForm;import com.victor.elliott.humala.formulario.UsuarioForm;import com.victor.elliott.humala.servicios.ComponenteService;import com.victor.elliott.humala.servicios.ComponenteServiceImpl; @Controllerpublic 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.addComponente(componente); System.out.println("Componente guardado"); return new ModelAndView("mostrarComponentes" , "listaComponentes", componenteService.getComponente()); } @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("usuarioForm", new UsuarioForm("Victor","Elliott")); modelo.addObject("componenteForm", new ComponenteForm()); return modelo; } }
la cual crea dos metodos POST y GET, tal como lo explicamos con el UsuarioController guardarComponente que es de tipo POST obtendra el formulario de un componente ComponenteForm enviado por agregarComponente.jsp y agregará el componente a la lista estática a traves del Service y nos mostrará la lista total de componentes agregados a través de mostrarComponentes.jsp. Por otro lado el método volverComponente que es de tipo GET será invocado por mostrarComponentes.jsp para poder volver a agregarComponentes.jsp, todos ellos a traves del RequestMapping respectivo. Finalmente modificamos los jsp:
ProyectoSpringTutorial\WebContent\WEB-INF\jsp\agregarComponentes.jsp
?
123456789101112131415161718192021222324252627282930313233343536373839404142
<%@ 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 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>Agregar Componentes</title></head><body> <h4>${mensaje} : ${usuarioForm.nombre}</h4></body> <h4>Agregar Componente</h4><c:url var="agregarComponentes" value="agregarComponentes.html"/><form:form id="agregar" modelAttribute="componenteForm" method="post" action="${agregarComponentes}"> <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="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> <input type="submit" value="Agregar" /> </td></tr> </table></form:form> </html>
Donde básicamente 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. Finalmente modificamos el jsp:/ProyectoSpringTutorial/WebContent/WEB-INF/jsp/mostrarComponentes.jsp
?
12345678910111213141516171819202122232425262728293031323334353637
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ 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=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></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></tr></c:forEach></table></c:if><br><a href="volverComponente.html" >Agrega un nuevo componente</a></center></body></html>
Que rellena una tabla con todos los componentes que hemos agregado a partir de la lista listaComponentes que se lo hemos pasado en el método guardarComponente del ComponenteController. Por último hacemos una referencia a volverComponente.html que accederá a ComponenteController a traves de un método GET para poder volver a agregar mas componentes. Si has compilado todo bien y no hay problemas de ejecución te deberían salir la siguiente página después del Login y después de haber agregado varios componentes:
Figura 1.8
Figura 1.9
