Controladores con anotaciones en Spring MVC Framework

De ChuWiki
Saltar a: navegación, buscar

En la versión 3 de Spring Web Framework se da prioridad a las anotaciones a la hora de hacer controladores sobre la herencia del controlador de la interfaz Controller y las clases Controladoras que ya venían preparadas en la API de Spring Framework, como SimpleFormController. Veamos aquí algunos conceptos/ejemplos básicos sobre cómo crear controladores con anotaciones.


Configuración de web.xml y springapp-servlet.xml

Como en cualquier aplicación con Spring Web Framework, debemos configurar nuestro web.xml para que tenga el Servlet propio de Spring Web Framework (org.springframework.web.servlet.DispatcherServlet). Una configuración típica puede ser

<web-app>
  ...
  <servlet>
    <servlet-name>springapp</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>springapp</servlet-name>
    <url-pattern>*.htm</url-pattern>
  </servlet-mapping>
  ...
</web-app>

El nombre de nuestro servlet es springapp, puede ser el nombre que nosotros queramos. La clase Servlet es propia de Spring org.springframework.web.servlet.DispatcherServlet y es la que se encargará de recibir las peticiones de los navegadores web y redirigirlas a los controladores que hagamos en nuestro código. El apartado <servlet-mapping> indica qué peticiones del navegador se deben redirigir a qué servlet, en concreto, cualquier petición de un fichero .htm se redirigirá al servlet springapp (o el nombre que hayamos decidido ponerle). Como hemos comentado, el servlet redirigirá estas peticiones a nuestros controladores.

El servlet org.springframework.web.servlet.DispatcherServlet también se encarga de cargar todos los beans de Spring Framework que le indiquemos. Para ello, carga un fichero springapp-servlet.xml situado en el directorio WEB-INF, junto a web.xml y carga los beans que se indiquen en ese fichero. El nombre del fichero debe ser el nombre del servlet (springapp en nuestro ejemplo) seguido de -servlet.xml.

Si queremos usar controladores con anotaciones, en este fichero springapp-servlet.xml debemos indicar dónde están las clases que hace de controlador y que llevan las anotaciones correspondientes. El contenido del fichero springapp-servlet.xml puede ser como el siguiente

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p" 
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-2.5.xsd">

    <context:component-scan base-package="com.chuidiang.ejemplo_spring"/>
    
</beans>

Hay que fijarse que en la parte de xsi:schemaLocation de <beans> hemos añadido dos líneas para context y spring-context-2.5.xsd (aparte de las dos "estándar" de beans y spring-beans). Esto nos permite usar el tag <context:component-scan> en donde se indica el paquete java a partir del cual buscar clases con anotación de controladores.


El controlador

Tal cual lo tenemos configurado, cuando hagamos desde el navegador una petición de un fichero .htm, el Servlet org.springframework.web.servlet.DispatcherServlet tratará de redirigir la llamada a uno de nuestros controladores. Para hacer dicho controlador, tenemos que hacer una clase java con la anotación @Controller, ya que hemos elegido hacerlo con anotaciones en clases dentro del paquete com.chuidiang.ejemplo_spring, como indica el fichero springapp-servlet.xml

La clase Controlador comenzará más o menos de esta forma

package com.chuidiang.ejemplo_spring;

import org.springframework.stereotype.Controller;

@Controller
public class Controlador {
...

El siguiente paso es decidir exactamente a qué método de nuestro controlador queremos que se llame en función del página htm pedida. Para ello nos basta con poner un método cualquiera en la clase con la anotacion @RequestMapping. Bueno, en realidad el método no puede ser de cualquier forma, tiene que ser un método que admita ninguno, uno o más de determinados parámetros y que devuelva uno de los tipos que luego entenderá el Framework de Spring. El siguiente enlace RequestMapping muestra un listado de todos los posibles tipos de parámetros que puede admitir el método y los posibles tipos de resultados. No vamos a ver aquí todas las combinaciones posibles, simplemente unos cuantos ejemplos más o menos habituales.

Uno de los más habituales es que admita como parámetro un ModelMap y devuelva un String.

	@RequestMapping("uno.htm")
	public String uno(ModelMap modelo) {
		modelo.addAttribute("uno", "1");
		return "index.jsp";
	}

La anotación @RequestMapping debe llevar entre comillas la página que debe teclear el usuario para que se llame a este método. Si nuestra aplicación está en un fichero aplicacion.war y lo hemos desplegado en apache tomcat (u otro servidor de servlets), la siguiente url

http://nuestroservidor:8080/aplicacion/uno.htm

provocará la llamada a nuestro método uno() del controlador. Hay que fijarse que en el fichero web.xml habíamos puesto que se enviaran al servlet org.springframework.web.servlet.DispatcherServlet las peticiones de páginas .htm. Será el servlet el que al ver que se pide uno.htm se encargue de llamar al método uno() del controlador.

El método uno() del controlador devuelve en este caso un String (uno de los tipos admitidos para los métodos que anotación RequestMapping. En este String debemos indicar cual es la página jsp que se debe mostrar. Así, el servlet, después de llamar al controlador, llamará a la página jsp que devolvamos en el método, en nuestro caso index.jsp ( http://nuestroservidor:8080/aplicacion/index.jsp )


Pasar datos a la vista

La gracia de usar un controlador consiste en el parámetro ModelMap. En ese parámetro, que en el fondo es como un HashMap, podemos meter objetos java identificados por una clave y que estarán accesibles desde la página jsp. De esta forma, podemos visualizar unos datos u otros en la página jsp. En el ejemplo, hemos metido dentro de ModelMap un objeto String de valor "1" identificado por la clave "uno". Este valor estará accesible desde index.jsp y podemos acceder a él así

<%@ page session="false"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
...
<h2>uno =  <c:out value="${uno}" /></h2>
Por supuesto, en un ejemplo más complejo el controlador podría cargar datos de una base de datos, meter una lista (List<Dato>) dentro del ModelMap y nuestro index.jsp podría mostrar una con todos esos datos. Y por supuesto, no tenemos por qué meter solo un objeto java, podemos meter todos los que queramos, cada uno con su clave propia.

Datos compartidos por todos los métodos

Es posible que nuestro controlador tenga varios métodos, atendiendo de esta forma a varias URLs, y es posible también que en todas ellas nos interese pasar un mismo dato a la vista, siempre el mismo. Puesto que sería un poco "rollo" tener que rellenar el ModelMap en todos los métodos siempre igual, podemos hacer un método especial con la anotación @ModelAttribute, de esta forma

@ModelAttribute("dato")
public UnBean unMetodoCualquiera() {
   UnBean bean = new UnBean();
   bean.setTexto("inicial"); // suponiendo que unBean tenga método setTexto(String)...
   return bean;
}

es decir, un método con la anotación @ModelAttribute con el nombre que queremos que quede etiquetado el dato en cuestión ("dato" en este caso). El método no recibe parámetros y devuelve el dato que queremos pasar a la vista, de cualquier clase que queramos. Sólo tenemos que rellenar el dato y hacer un return de él.

Spring llamará a todos los métodos con anotación @ModelAttribute antes de hacer la llamada definitiva al método @RequestMapping que toque en función de la URL. De esta forma, cualquier llamada a este controlador pasará a la vista el "dato" con "UnBean" relleno dentro.

Datos de sesión

La "pega" del método anterior es que siempre nos devolverá el dato inicializado según lo inicialicemos en el método. A veces nos interesa tener datos de sesión, que se mantengan mientras navegamos de una página a otra del controlador y que podamos cambiar sólo si nos interesa. Para conseguir esto, en la clase ponemos la anotación @SessionAttributes(), indicando qué datos queremos que se mantengan en sesión

@Controller
@SessionAttributes({"datoSesion1","datoSesion2"})
public class Controlador {
   ...

En este ejemplo, los datos "datoSesion1" y "datoSesion2" serán de sesión y mantendrán sus valores mientras navegamos por las páginas del controlador. En principio estos datos no están definidos, pero podemos definirlos en cualquier método

@RequestMapping("uno.htm")
public String uno(ModelMap modelo) {
   modelo.addAttribute("uno", "1");
   modelo.addAttribute("datoSesion1","uno");
   return "index.jsp";
}

Y ahí permanecerá ese dato, disponible en el modelo que se pasa a todos los métodos del controlador, hasta que otro método del controlador lo borre o lo modifique.

Ojo, no hay que definir datos de sesión en los métodos con anotación @ModelAttribute, puesto que a estos métodos se los llama siempre que hay una petición a nuestro controlador y el dato de sesión acabará con un valor fijo, el que le de ese método. Tampoco tiene sentido hacerlo que el dato sea de sesión si lo vamos a definir en un método anotado con @ModelAttribute, porque siempre se llama a este método y va a definirlo y estar disponible para todos los demás métodos, sea o no de sesión.

En el momento que nos interese, desde un método del controlador podemos limpiar los datos de sesión. Para ello, el método debe recibir un atributo SessionStatus y debemos llamar a su método setComplete()

@RequestMapping("dos.htm")
public String dos(SessionStatus status, ModelMap modelo) {
   status.setComplete();
   return "index.jsp";
}

Es importante notar que este método no borra el dato de ModelMap en el momento, cuando se llama a este método dos(), la página index.jsp de retorno seguirá teniendo el dato disponible en ModelMap. Es cuando salimos de esa página a la siguiente cuando el dato deja de estar disponible ... hasta que alguien vuelva a definirlo. Podemos borrarlo si nos interesa con modelo.remove()


@RequestMapping("dos.htm")
public String dos(SessionStatus status, ModelMap modelo) {
   status.setComplete();
   modelo.remove("datoSesion1");
   return "index.jsp";
}

Paso de parámetros request al controlador

Los métodos del controlador pueden recibir parámetros de una petición del navegador, bien sea por método POST o por método GET. La forma de hacerlo sería poner en nuestro controlador un método de esta forma

@RequestMapping(value = "tres.htm")
public String tres(@RequestParam("texto") String texto,  ModelMap modelo) {
   ...      

de esta forma, recibiremos un parámetro de nombre texto si hacemos una llamada a nuestro método con esta url

http://nuestroservidor:8080/aplicacion/tres.htm?texto=hola

que sería en forma GET o bien, si enviamos desde un formulario con POST

<form method="post" action="tres.htm">
   <input type="text" name="texto"/>
   <input type="submit" value="OK"/>
</form>

Si queremos que el método sólo atienda GET o POST, podemos indicarlo en la anotación del método del controlador

@RequestMapping(value = "tres.htm", method = RequestMethod.POST)
public String tres(@RequestParam("texto") String texto,  ModelMap modelo) {
    ...