de

RESTful Web Services con Spring

En la presente entrada, RESTful Web Services con Spring, realizaré la descripción de la implementación de servicios REST con Spring con el módulo Spring MVC. Realizaré la definición de unos servicios básicos y un ejemplo de cliente de uno de los servicios.

Para el lector interesado, las publicaciones de webservices que he realizado con otras tecnologías son las siguientes:

Creación del proyecto

La creación del proyecto lo realizaremos con Maven. A partir del arquetipo básico de Java, añadiremos al fichero pom las dependencias de Spring, el mapeador de JSON e insertaremos el servidor embebido Jetty. Además, realizaremos la creación de las carpetas webapp y el fichero web.xml.

El snippet con las dependencias más importantes es el siguiente:

[...]
<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 <version>${spring.version}</version>
</dependency>
<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 <version>${spring.version}</version>
</dependency>
<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>${spring.version}</version>
</dependency>
<dependency>
 <groupId>org.codehaus.jackson</groupId>
 <artifactId>jackson-mapper-asl</artifactId>
 <version>${jackson-mapper-asl.version}</version>
</dependency>
[...]
<plugin>
 <groupId>org.eclipse.jetty</groupId>
 <artifactId>jetty-maven-plugin</artifactId>
 <version>${jetty.version}</version>
</plugin>
[...]

Configuración del proyecto

Spring utiliza el módulo Spring MVC para definir los servicios. Así, en la configuración del contexto, definido en el fichero mvc-dispatcher-servlet.xml, definimos los tag para las anotaciones de Spring MVC y la configuración básica del contexto. El contenido del fichero de contexto de Spring es el siguiente:

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:mvc="http://www.springframework.org/schema/mvc" 
 xsi:schemaLocation="
 http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.2.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-3.2.xsd">
 <context:annotation-config />
 <context:component-scan base-package="es.directoandroid" />
 <mvc:annotation-driven />
</beans>

Configuración del servidor

La configuración del servidor se realiza en el fichero web.xml. En este caso, el contenido contiene la definición del Servlet de Spring, el parámetro en donde se define la localización del contexto Spring y, para finalizar, el listener del contexto. El contenido del fichero web.xml es el siguiente:

[...]
<display-name>Spring Web MVC Application</display-name>
<servlet>
 <servlet-name>mvc-dispatcher</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
 <servlet-name>mvc-dispatcher</servlet-name>
 <url-pattern>/</url-pattern>
</servlet-mapping>
<context-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>/WEB-INF/mvc-dispatcher-servlet.xml</param-value>
</context-param>
<listener>
 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener> 
[...]

Servicios REST

Los servicios REST de Spring se definen en clases controladoras, es decir, en clases con la anotación @Controller. Los servicios serán los métodos definidos por la anotación @RequestMapping. La anotación @RequestMapping define el path de acceso al servicio; la anotación @ResponseBody, define el cuerpo de la respuesta del servicio el cual corresponderá con el tipo de objeto que retorna el método;y, por último, la anotación @RequestParam, define el parámetro de la petición al cual se le puede definir un valor por defecto o si es obligatorio o no.

En el ejemplo, defino una clase con tres servicios: el servicio echo, que retorna un texto; el servicio echo2, que retorna una estructura JSON representada por la clase MiBEan;y, el servicio saludo, que retorna una estructura JSON representado por la clase MiBean y con un parámetro. El código de la clase es el siguiente:

@Controller
public class DirectoAndroidController {
private static final String plantilla = "Hola, %s!";
 private final AtomicLong contador = new AtomicLong();
 @RequestMapping("/echo")
 public @ResponseBody
   String echo() {
   return "Hola Mundo!";
 }
 @RequestMapping("/echo2")
 public @ResponseBody
   MiBean echo2() {
   return new MiBean(1L, "Hola Mundo!");
 }
 @RequestMapping("/saludo")
 public @ResponseBody
   MiBean saludo(@RequestParam(value = "name", required = false, defaultValue = "Mundo") String nombre) {
   return new MiBean(contador.incrementAndGet(), String.format(plantilla, nombre));
 }
}

Clientes REST

La definición del cliente REST es muy sencilla en Spring. Definimos una plantilla REST, invocamos al servicio con la URL y, en la invocación, le definimos el tipo de la clase que retorna. La referencia al objeto obtenido es la respuesta con el cual podremos operar con él.

Como se puede ver en la entrada, Android y Spring para Android: consumir webservices REST , el tratamiento en Android es idéntico.

RestTemplate restTemplate = new RestTemplate();
MiBean bean = restTemplate.getForObject("http://localhost:8080/echo2", MiBean.class);
System.out.println("" + bean);

Pruebas

Spring no tiene definido la obtención del fichero wadl de forma automática con lo cual se deberá de crear el componente de creación del fichero wadl. La creación del fichero sale del alcance de esta entrada.

Si se desea el código ejemplo se puede acceder aquí.

Deja un comentario