Siguiendo un poco con la serie de demos que estamos haciendo estos últimos días, vamos a implementar un pequeño ejemplo con un servicio REST sobre Spring y utilizando Jackson. Para quien no sepa o no le suene que es Jackson, es una librería para el procesamiento de JSON. En terminos de ir por casa, nos permite obtener fácilmente objetos Java a partir de JSON. Os recomiendo echarle una ojeada, ya que a día de hoy, los servicios REST están a la order del día y muchísimos de ellos trabajan con JSON.

Pero bueno, vamos a empezar. Como las veces anteriores, crearemos nuestro proyecto Maven sin arquetipo en Eclipse y añadiremos lo siguiente al fichero pom.xml:

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.wordpress.infow</groupId>
    <artifactId>springRESTJackson</artifactId>
    <version>1.0</version>
    <packaging>war</packaging>
    <name>springRESTJackson</name>
    <url>http://www.infow.wordpress.com</url>

    <properties>
        <spring.version>3.2.3.RELEASE</spring.version>
        <jackson.version>1.9.12</jackson.version>
    </properties>

    <dependencies>
        <!-- Spring 3 -->
        <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>
        <!-- Jackson JSON Mapper -->
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>${jackson.version}</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>SpringREST</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Lo siguiente que vamos a implementar, son los ficheros correspondientes a configuraciones que se alojarán, como en veces anteriores, en webapp/WEB-INF/. Dichos ficheros serán: mvc-dispatcher-servlet.xml y web.xml. Tendrán el contenido siguiente:

mvc-dispatcher-servlet.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    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
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

    <context:component-scan base-package="com.wordpress.infow.controller" />

    <mvc:annotation-driven />
</beans>

web.xml

<web-app id="WebApp_ID" version="2.4"
    xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

    <display-name>Spring + REST + JACKSON</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>/rest/*</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>
</web-app>

Lo siguiente que vamos a crear, es un pequeño modelo para darle soporte a nuestros servicios. Como las veces anteriores, vamos a implementar una pequeña clase para almacenar mensajes:

Message.java

public class Message {
    private String message;

    public Message(String message) {
        this.message = message;
    }

    public String getMessage() {
        return this.message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

Y finalmente, vamos a implementar los servicios propiamente dichos. En este caso, como la vez anterior, solo vamos a implementar el método GET. Si os habéis leido los artículos anteriores, sabréis que no es el único, si no los habéis leido. os recomiendo que lo hagáis, pero de todas formas, los posibles métodos son: GET, PUT, DELETE, POST. El código del servicio y del método será:

MessageController.java

@Controller
@RequestMapping("/message")
public class MessageController {

    @RequestMapping(value = "{message}", method = RequestMethod.GET)
    public @ResponseBody Message getMessage(@PathVariable String message) {
        Message messageObj = new Message(message);

        return messageObj;
    }
}

Aquí, como siempre, lo único digno de mención son las anotaciones que, además, son bastante intuitivas:

• @Controller: Marca la clase como un controlador de Spring.
• @RequestMapping: Será la URL que apunte a esta clase. Nivel de clase.
• @RequestMapping: Tipo de petición que se recibirá y parámetros que se recibirán. Nivel de método.
• @RespondeBody: Indica el valor de retorno del servicio.
• @PathVariable: Indica que el parámetro debe de ser buscado en la URI

Con esto ya podremos lanzar nuestra pequeña demo en nuestro servidor y probarla. Como siempre os dejo el código para que podáis echarle un vistazo y probarlo.

Codigo SpringRESTJackson Hello World: SpringRESTJackson

Espero que os sea útil. Nos vemos.