RSS

JavaEE: Spring + REST + JACKSON

15 Jul

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.

Anuncios
 
2 comentarios

Publicado por en 15 julio, 2013 en JavaEE

 

2 Respuestas a “JavaEE: Spring + REST + JACKSON

  1. Anónimo

    14 septiembre, 2013 at 4:19 am

    Y como invoco la app?

     
    • svoboda

      14 septiembre, 2013 at 8:16 am

      Lo ideal sería hacer un pequeño cliente para consumir los servicios web REST, pero si no quieres hacer esto, puedes usar alguna extensión del navegador que permita hacerlo de forma fácil. En el caso de firefox, por ejemplo, cuando no quiero hacer un cliente, yo suelo usar el add-on RESTClient. También al ser solo el método GET lo que hay implementado, lo puedes hacer desde la barra de navegación con: /rest/message.

       

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

 
A %d blogueros les gusta esto: