Como en tantos otros casos, vamos a iniciar esta serie de artículos acerca de Spring creando nuestro primer proyecto, apoyado por NetBeans, cuya instalación describimos días atrás.
Spring es quizás uno de los Frameworks de Java mas ambicioso y vale la pena conocerlo; por medio de estos artículos, espero ayudaros en ese objetivo.
Creación del proyecto
Iniciamos Netbeans, y en Archivo->Nuevo Proyecto
seleccionamos «Java Web»->Web Application y pulsamos «Next», en la siguiente pantalla, le indicamos el nombre del proyecto, que será «Spring_uno»
y pulsamos «Next». En la siguiente pantalla, solo deberemos prestar atención a que esté desmarcado «Enable Context And Dependency Injection»
y pulsamos «Next», para llegar a la selección de Framework
- Indicamos que vamos a utilizar «Spring Web MVC»
- Tras la selección anterior, nos aparece esta ventana, en donde indicaremos que vamos a utilizar la versión 3.2.7, porque después desaparece el soporte para «SimpleFormController», que es lo que utilizaremos en este ejercicio,
- Dejamos desmarcado esta casilla
- Pulsamos para finalizar la creación, y que Netbeans genere la estructura del proyecto.
Si hubiéramos pasado por la pestaña de configuración veríamos:
en donde nos indica un mnemonico (una etiqueta) de la clase que se encargará de procesar todos los ficheros con extensión «.htm»
Como siempre Netbeans nos genera la estructura necesaria con los ficheros de ejemplo para que podamos lanzar la aplicación y ver que funciona;
Ademas, como vemos en (1) nos ha incorporado las clases necesarias de Spring, en (2), el JDK, y en (3) aparece el servidor de aplicaciones sobre el que vamos a realizar las pruebas.
Bajo WEB-INF podemos ver los ficheros de configuración
y la carpeta «jsp» que es donde vamos a dejar todas las paginas jsp que realicemos. Como en el caso de Strust, la carpeta no es explorable desde web, para conseguir un poco mas de seguridad.
Lanzando la aplicación
Si iniciamos la ejecución del proyecto veremos aparecer en nuestro navegador la consabida pantalla:
que nos permitirá comprobar que nuestra instalación funciona perfectamente y que podemos empezar a trabajar con este Framework.
Entendiendo nuestro proyecto
Para entender como ha funcionado, debéis revisar el fichero web.xml que creo Netbeans.
Como veréis, definió como fichero de bienvenida el «redirect.jsp»
y en ese fichero, solo una redirección a «index.jsp», que ya esta en el directorio protegido «jsp». Quiero destacaros que la redirección se ha hecho a «index.htm», y ademas sin indicar carpeta, por lo que alguien tendrá que resolver esa petición sobre /WEB-INF/jsp/undex.jsp.
Ademas, teniendo en cuenta que WEB-INF no puede ser accedido desde un navegador, esa resolución se tendrá que hacer a nivel de servidor.
De eso se encargará nuestro Framework.
Ahora quiero recordar que durante la creación del proyecto, vimos esta pantalla:
y comente que «dispatcher» era una etiqueta, y es aquí, en «web.xml» que se resuelve, indicando que esa etiqueta esta mapeada a la clase correspondiente de Spring
Para el funcionamiento, DispatcherServlet se apoyara en el fichero dispatcher-servlet.xml; si abrís el fichero, veréis:Cuando alguien; ya sea un usuario, o como en este caso, un «redirect», menciona una pagina «*.htm», el contenedor de servlets, siguiendo las instrucciones de «web.xml», entrega la llamada a DispatcherServlet, y este, lo primero que hace es comprobar si la pagina llamada coincide con alguna de las indicadas en el nodo (1) y en este caso es así, «index.htm» es una clave, luego intentará buscar que es «indexController».
Para encontrar «indexController», solo tenemos que mirar el nodo (3), en donde indicamos que sera resuelto con la clase «ParameterizableViewController» que lo único que hace es retornar la vista que le indicamos como parámetro:
En este caso, una vista que se llama «index».
Para que el Framework pueda resolver los nombres de vistas que le pasamos, es necesario que veáis el nodo (2) «viewResolver» que se encargara de obtener el fichero especificado; y lo hace añadiendo al nombre indicado (index) el prefijo y sufijo indicado
Con los nuevos parámetros, ya sabe que el fichero a buscar es:
Definiendo objetivos
Nuestro propósito es realizar un proyecto que presente una pagina que solicite el nombre, y que conteste con una pagina de bienvenida; para ello, vamos a estructurar nuestra aplicación siguiendo el modelo MVC:
Realmente, en este ejemplo, el programar de forma independiente un servicio, quizás sea demasiado exagerado, pero es necesario para los fines docentes que perseguimos; así que empezamos
Implementando el servicio
Podemos crear una nueva clase java:
Como nombre, le podemos indicar «HolaServicio», y nos aseguraremos de indicar el paquete en donde se guardará (service)
El contenido de esta clase es muy simple, solo ha de contener:
package service; public class HolaServicio { public static String diHola(String nombre) { return "Hola " + nombre + "!"; } }
Un método estático que recibe el nombre, y devuelve una cadena de texto con el saludo.
Implementando el Controlador y el Modelo
Aunque en la versión 4 de Spring se ha retirado el soporte para «SimpleFormController», he considerado conveniente utilizarlo en este tutorial para mantener un nivel simple y fácil de implementar, dejando otras soluciones para mas adelante.
Ahora nos basta con crear una nueva pagina:
A la que le damos como nombre «HolaController», y la colocamos en el paquete de controladores:
Y en el código generado:
Descomentamos las lineas marcadas y las modificamos para que queden asi:
En «CommandClass» indicamos el nombre de la clase que recibirá los datos del formulario, en este ejemplo es el objeto Modelo, que será cargado con los datos del formulario.El error que vemos aparecer en esta linea, se corregirá cuando creemos la clase del modelo y la importemos
En «CommandName» establece el nombre del comando en el modelo; en este caso, es el formulario que aportara los datos
En «SuccessView» indicaremos el nombre de la vista que se presentara si el formulario no tiene errores.
En «FormView» indicaremos el formulario que tiene que presentar para la captura de la información.
le damos como nombre «Nombre», y la dejamos en el paquete «controller»
le definimos un campo «value» y creamos los «getters y setters»
Ahora si revisamos nuestro controlador, veremos que ha desaparecido el error, y de paso, borramos el método «doSubmitAction» y descomentamos el método «onSubmit» en donde escribiremos nuestro código
Volvemos a hacer una concesión a la simplicidad, y nos aprovechamos del acceso que tiene este método a los objetos request y response
Lo que escribimos en el mismo es
Nombre param=(Nombre)command;
Recogemos el modelo, que Spring ya nos lo habrá llenado con los datos del formulario, haciendo un «cast» para que se ajuste a nuestra clase.
ModelAndView mv = new ModelAndView(getSuccessView());
Creamos una instancia de la vista indicada en «setSuccessView» en el constructor de esta clase (linea 26)
mv.addObject("holaMensaje",holaServicio.diHola(param.getValue()));
Le traspasamos a la vista el mensaje que nos devuelva «holaServicio»
En estos momentos,» holaServicio» os esta indicando error porque no ha sido definido, la solucion esta en añadir al principio de la clase
private HolaServicio holaServicio;
y su «setter» correspondiente
public void setHolaServicio(HolaServicio holaServicio) { this.holaServicio = holaServicio; }
e importar todas las clases mencionadas,(Atención a lo que importáis, ya que hay mas de una opción) lo que creará una lista como está
import org.springframework.validation.BindException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.springframework.web.servlet.ModelAndView; import org.springframework.web.servlet.mvc.SimpleFormController; import service.HolaServicio;
Nuestro siguiente paso, es registrar el servicio en «applicationContext.xml»
y en «dispatcher-servlet» definimos nuestro controlador, indicándole que necesita el servicio que acabamos de definir
Definiendo las vistas
Las vistas se encargan de preparar lo que nuestro usuario va a ver, y para su desarrollo, podemos utilizar paginas jsp.
Dado que en la vista no debería contener lógica, nuestros ficheros serán muy sencillos. Si nos colocamos sobre /WEB-INF/jsp, pulsamos el botón derecho de ratón y seleccionamos nueva pagina JSP.
vamos a indicarle como nombre «holaView»; precisamente lo que indicamos en el constructor del controlador, os acordáis?
setSuccessView("holaView");
y modificamos el código que nos ha generado, para que presente el mensaje que habíamos creado.
Nuestra única variable es
${holaMensaje}
que nos sirve para indicar donde queremos que aparezca la variable que habíamos cargado en el controlador en:
mv.addObject("holaMensaje",holaServicio.diHola(param.getValue()));
Ahora ya vamos a crear una nueva pagina jsp, también en /WEB-INF/jsp/, tal y como hicimos hace un momento; le damos por nombre «nombreView», precisamente el nombre que indicamos en el controlador en
setFormView("nombreView");
y será la pagina que servirá para pedir el nombre.
Primero añadimos una librería de tag de spring escribiendo en las primeras lineas (por ejemplo, debajo de «page»)
<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
Podemos indicar el titulo que consideremos mas adecuado, y a continuación del titulo H1 que aparece en el «body», le podemos añadir el formulario que necesitamos:
- spring:nestedPath: Establece la ruta para encontrar el Bean; en este caso es precisamente el dato que indicamos en el controlador:
setCommandName(«nombre»);
cuando posteriormente utilicemos «bind», conseguiremos una ruta tipo «nombre.bind» que nos llevara al atributo en donde debera dejar la informacion - spring:bind: enlaza el siguiente «input» con la propiedad correspondiente, en este caso lo enlazará con «nombre.value»
Probando el trabajo
Con esto terminamos; ya solo queda indicarle al proyecto el punto de entrada, para eso, nos colocamos sobre el proyecto, botón derecho de ratón, y seleccionamos Propiedades
En el apartado de «Run» indicamos
y podemos lanzar nuestro proyecto; que funcionara gracias a que en Dispatcher-servlet, tiene esta linea
que se encarga de intentar encontrar una clase formada por la palabra introducida (de hola.htm->hola) y el sufijo «controller»; en este caso lo encuentra, (ese es el motivo que no castellanizara holaController), y le pasa el control a él.
Con ello obtenéis
Y cuando entréis un nombre y pulséis el botón:
Y aunque parezca muy poco, acabais de utilizar Spring; ahora ya os podeis ir complicando la vida con proyectos mas complejos
20 comentarios
Muchas gracias Miguel. Ahora mismo estoy cursando Dam y la verdad es que tu articulo es todo un lujo. Hay que ver el tiempo que le dedicas, muchas gracias nuevamente
Gracias a ti, Sergio, por leer y comentar.
Hola Miguel no me funciona el proyecto, seguro que me he perdido en alguna linea. Me puedes enviar el proyecto entero para comparar linea a linea con lo que he hecho?
Mi email: [email protected]
Un saludo y gracias!
Hola Martin.
Disculpa, pero el articulo es muy antiguo y no he podido encontrar el codigo fuente correspondiente, y en estos momentos voy muy mal de tiempo para repicarlo, pero te invito a que leas una version posterior en http://recursosformacion.com/wordpress/2015/06/spring-desarrollo-con-eclipse-y-sts/
Un saludo
Hola Miguel no me funciona el proyecto, seguro que me he perdido en alguna linea. Me puedes enviar el proyecto entero para comparar linea a linea con lo que he hecho?
Mi email: [email protected]
Un saludo y gracias!