El Framework Web MVC (modelo-vista-controlador) de Spring est diseado alrededor de un Servlet (DispatcherServlet) encargado de enviar las peticiones a los

diferentes manejadores (handlers) de la aplicacin, a partir de la configuracin del mapeo de manejadores, la resolucin de las vistas, locale, etc. Es decir, al configurar este serlvet en el fichero web.xml de tu aplicacin web, todas las peticiones pasarn por l y se encargar de redirigir a los diferentes manejadores. Los manejadores por defecto se basan en las anotaciones @Controller y @RequestMapping como veremos a continuacin. A partir de la versin 3.0 de Spring es posible crear aplicaciones Web RESTfull a travs de la anotacin @PathVariable. En esto ltimo se va a centrar este artculo, en la implementacin de los controladores a travs de anotaciones y en la configuracin de los mismos para crear aplicaciones REST.

Dispatcher Servlet
Cmo comentamos al principio, el framework MVC de Spring est diseado alrededor de un servlet que reenva las peticiones a los diferentes controladores. Este servlet est plenamente integrado con el contenedor IoC (Inversion of Control) lo que permite usar todas las caractersticas del framework Spring.

Se trata de un servlet (hereda de la clase base HttpServlet) y como tal se declara en el fichero de configuracin web.xml de tu aplicacin web:
<web-app> <servlet> <servlet-name>buscar</servlet-name> <servletclass>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>buscar</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping> </web-app>

En el ejemplo anterior, tal como se puede ver en el mapeo del servlet, todas las peticiones que acaben en .do sern manejados por el DispatcherServlet buscar. En el framework Web MVC cada DispatcherServlet tiene asociado su propio WebApplicactionContext, el cul hereda todos los beans definidos en el WebApplicationContext raz que pueden ser sobreescritos. Una vez inicializado el DispatcherServlet, el framework busca un fichero llamado [servlet-name]-servlet.xml en el directorio WEB-INF de tu aplicacin web y crea los beans all definidos (si hay beans con el mismo nombre que los del contexto raz los sobreescribe). En el ejemplo anterior debemos tener un fichero llamado buscar-servlet.xml. El DispatcherServlet de Spring usa beans especiales para procesar las peticiones y mostrar las vistas apropiadas. Estos beans son parte del Framework y pueden ser configurados en el contexto WebApplicationContext como haras con otros beans. Sin embargo, para la mayora de los beans se proporcionan parmetros por defecto y no necesitan configuracin.

Implementando Controladores
Los controladores proveen acceso al comportamiento de la aplicacin, interpretan los inputs del usuario y los transforman en un modelo que es representado al usuario por una vista (modelovista-controlador). Spring implementa un controller de una manera abstracta, lo que permite crear una gran variedad de controladores. A partir de la versin 2.5, y la mantiene tambin en la versin 3.0, Spring introdujo el modelo de programacin basado en anotaciones, que usa anotaciones como @RequestMapping, @RequestParam, @ModelAttribute, etc. Los controladores implementados a travs de este estilo no necesitan heredar de ninguna clase base o implementar ninguna interfaz especfica:
@Controller public class HelloWorldController { @RequestMapping("/helloWorld") public ModelAndView helloWorld() { ModelAndView mav = new ModelAndView(); mav.setViewName("helloWorld"); mav.addObject("message", "Hello World!");

return mav; } }

Definiendo un controlador con @Controller

La anotacin @Controller indica que una clase tendr el rol Controlador. No se requiere heredar de ninguna clase base o del API de Servlet, como ocurra en la versin 2.0. El Dispatcher busca las clases marcadas con dicha anotacin para mapear los mtodos y detectar todas las anotaciones @RequestMapping (ver ms abajo). Para activar la autodeteccin de los controllers que contienen la anotacin, debes aadir a tu configuracin el componente que los escanea:
<?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-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context3.0.xsd"> <context:component-scan base-package="com.paquete.ejemplo.controllers"/> // ... </beans>

Mapeando peticiones con @RequestMapping

Se usa la anotacin @RequestMapping para mapear URLs como por ejemplo /mostrareventos con una clase, o bien un mtodo dentro de la clase. Si es a nivel de clase, se suele mapear una URL concreta con mtodos adicionales que acotan el mapeo a travs de mtodos HTTP especficos (POST, GET, etc.) o bien mediante parmetros en la peticin.
@Controller @RequestMapping("/mostrareventos") public class AppointmentsController { private final AppointmentBook appointmentBook; @Autowired public AppointmentsController(AppointmentBook appointmentBook) {

this.appointmentBook = appointmentBook; } @RequestMapping(method = RequestMethod.GET) public Map<String, Appointment> get() { return appointmentBook.getAppointmentsForToday(); } @RequestMapping(value="/{dia}", method = RequestMethod.GET) public Map<String, Appointment> getForDay( @PathVariable @DateTimeFormat(iso=ISO.DATE) Date dia, Model model) { return appointmentBook.getAppointmentsForDay(dia); } @RequestMapping(value="/new", method = RequestMethod.GET) public AppointmentForm getNewForm() { return new AppointmentForm(); } @RequestMapping(method = RequestMethod.POST) public String add(@Valid AppointmentForm evento, BindingResult result) { if (result.hasErrors()) { return "mostrareventos/new"; } appointmentBook.addAppointment(evento); return "redirect:/mostrareventos"; } }

En el ejemplo anterior la anotacin @RequestMapping se usa primero a nivel de clase. De esa manera indica que todos los mtodos de este controlador manejarn las peticiones con el path relativo /mostrareventos. El mtdo get() refina dicha URL y se ejecuta nicamente cuando se trata de un mtodo GET. El mtodo add(), por el contrario, se ejecuta cuando se realiza un POST de un formulario del sitio web. Los mtodos getForDay() y getNewForm() se ejecutarn cuando se trate de una peticin GET y adems la URL contenga /mostrareventos/daEvento o /mostrareventos/new, respectivamente.

URI Templates
Para acceder a partes de la URL en los mtodos manejadores usamos los patrones de URI o URI Templates, dando valores dentro del path de @RequestMapping. Luego podemos usar la anotacin @PathVariable para indicar que un parmetro del mtodo se va a enlazar con un valor que viene en una variable de la URI. Veamos un ejemplo:
@RequestMapping(value="/alumnos/{alumnoId}", method=RequestMethod.GET) public String findAlumno(@PathVariable String alumnoId, Model model) { Alumno alumno = alumnoService.findAlumno(alumnoId); model.addAttribute("alumno", alumno);

return "displayAlumno"; }

La URI Template /alumnos/{alumnoId} especifica la variable con el nombre alumnoId. Cuando un controlador maneja esta peticin, el valor de alumnoId se establece con el valor que viene en la URL. Por ejemplo, cuando llega una peticin con esta URL /alumnos/francisco el valor francisco se asociar al parmetro alumnoId de tipo String del mtodo manejador. Puedes usar varias anotaciones @PathVariable para enlazar mltiples variables URI Templates:
@RequestMapping(value="/alumno/{alumnoId}/asignatura/{asignaturaId}", method=RequestMethod.GET) public String findAsignatura(@PathVariable String alumnoId, @PathVariable String asignaturaId, Model model) { Alumno alu = alumnoService.findAlumno(alumnoId); Asignatura asig = alumno.getSignatura(signaturaId); model.addAttribute("Asignatura", asignatura); return "displayAsignatura"; }

El mtodo findAsignatura se ejecutara al invocar, por ejemplo la URL /alumno/245/asignatura/32. Podemos indicar una parte a nivel de clase y otra a nivel de mtodo como en el siguiente ejemplo:
@Controller @RequestMapping("/alumno/{alumnoId}") public class RelativePathUriTemplateController { @RequestMapping("/asignatura/{asignaturaId}") public void findPet(@PathVariable String alumnoId, @PathVariable String asignaturaId, Model model) { // implementacin omitida } }

Conclusiones
Tal y cmo nos propusimos al inicio de este artculo pretendamos realizar una introduccin a la programacin de aplicaciones REST con Spring 3.0. Cmo cualquier aplicacin Spring MVC, hemos configurado el DispatcherServlet, hemos aprendido a declarar controladores mediante la anotacin @Controller. Tambin hemos mapeado peticiones con la anotacin @RequestMapping y por ltimo hemos asociado valores de variables de la URL a parmetros de los mtodos manejadores de los controladores mediante URI Templates y la anotacin @PathVariable. Con todo esto podemos comenzar a construir una aplicacin REST en la que cada recurso sea accesible mediante una URL amigable del tipo:
http://mi-dominio/gestionalumnos/ http://mi-dominio/gestionalumnos/alumno/new

http://mi-dominio/gestionalumnos/alumno/234 http://mi-dominio/gestionalumnos/alumno/234/asignatura/32 http://mi-dominio/gestionalumnos/asignatura/new http://mi-dominio/gestionalumnos/asignatura/32 etc...

Este artculo est basado en la documentacin de referencia de Spring. Para ampliar estos y otros temas puedes consultar la Referencia del framework Spring MVC. Esta entrada fue publicada en desarrollo y etiquetada anotaciones, desarrollo, DispatcherServlet, J2EE, REST, RESTfull, spring, Spring MVC por josan. Guardar el enlace permanente.