Introduccin a Aplicaciones REST con Spring 3.

0 Web MVC
Framework
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>
<servlet-class>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 (modelo-vista-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-context-3.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...