Icon 100x60 rest java jersey Servicios REST con JAVA usando JAX-RS y Jersey

en

Ejemplo de cómo crear una API Java (JAX-RS) con servicios REST usando Jersey con Eclipse en un proyecto MAVEN.

Requisitos previos

Para completar este tutorial con éxito es necesario tener antes instalado Eclipse, el servidor Tomcat y tener nociones básicas de Java.

¿Qué es un servicio REST?

REST son las siglas de Representational State Transfer. Es una arquitectura de software para desarrollar servicios Web. Coloquialmente, un servicio web sirve para hacer una llamada a una url (normalmente HTTP) y obtener datos de respuesta del servidor (principalmente en formato JSON o XML).

En los últimos años los servicios web REST se han establecido como el modelo predominante en la Web, desplazando a otras arquitecturas como SOAP.

JAX-RS y Jersey

JAX-RS es una API de Java para servicios web REST que forma parte de JAVA EE.

Jersey es un framework que simplifica todavía más el uso de JAX-RS extendiéndola y dándole más funcionalidades para los desarrolladores.

Creación del proyecto en Eclipse

El primer paso será crear una aplicación llamada ApiRest. En eclipse vamos al menú File > New > Dynamic Web Project. Luego sólo escribimos el nombre del proyecto como en la imagen y le damos a finalizar.

Cambiar el tipo de proyecto a Maven

MAVEN sirve para gestionar las dependencias del proyecto. Principalmente servirá para registrar las librerías externas que usa el proyecto con sus respectivas versiones. Para que eclipse trate el proyecto como un proyecto Maven, lo convertiremos. Para nos dirigimos a la ventana de Project Explorer (si no lo tenemos abierto en el menú Window > Show View > Project explorer), en la carpeta principal del proyecto le damos click al botón derecho > Configure > Convert to Maven Project. Lo dejamos tal cual está en la imagen y pulsamos finish.

Automáticamente se crea un archivo pom.xml en la raíz del proyecto que es donde manejaremos las librerías. Para este ejemplo usaremos las librerías asm.jar, jersey-bundle.jar, json.jar y jersey-server.jar. Para editar pom.xml podemos clickar encima de el con el botón derecho > Open with > Text editor y pegamos este XML:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
<?xml version="1.0" encoding="UTF-8"?>
<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>ApiRest</groupId>
   <artifactId>ApiRest</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>war</packaging>
   <build>
      <sourceDirectory>src</sourceDirectory>
      <plugins>
         <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.5.1</version>
            <configuration>
               <source>1.8</source>
               <target>1.8</target>
            </configuration>
         </plugin>
         <plugin>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.0.0</version>
            <configuration>
               <warSourceDirectory>WebContent</warSourceDirectory>
            </configuration>
         </plugin>
      </plugins>
   </build>
   <dependencies>
      <dependency>
         <groupId>asm</groupId>
         <artifactId>asm</artifactId>
         <version>3.3.1</version>
      </dependency>
      <dependency>
         <groupId>com.sun.jersey</groupId>
         <artifactId>jersey-bundle</artifactId>
         <version>1.19</version>
      </dependency>
      <dependency>
         <groupId>org.json</groupId>
         <artifactId>json</artifactId>
         <version>20140107</version>
      </dependency>
      <dependency>
         <groupId>com.sun.jersey</groupId>
         <artifactId>jersey-server</artifactId>
         <version>1.19</version>
      </dependency>
      <dependency>
         <groupId>com.sun.jersey</groupId>
         <artifactId>jersey-core</artifactId>
         <version>1.19</version>
      </dependency>
   </dependencies>
</project>

Implementación de un servicio web

Hasta ahora todo lo que hemos hecho ha sido para crear y configurar el proyecto. Ahora creamos un servicio REST que devuelva, por ejemplo, un listado de usuarios. Pero antes crearemos un package donde almazenar nuestro código. Por convención se suele crear uno llamado com. En la carpeta ApiRest / Java Resources / src botón derecho New > Package. Ahora dentro de este package botón derecho > New > Class. Se nos abrirá una ventana y ponemos como nombre de la clase UsersService. Dentro de UsersService.java copiaremos este código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com;
import java.util.ArrayList;
import java.util.List;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Response;
import org.json.JSONException;
@Path("/users")
public class UsersService {
        private static final long serialVersionUID = 1L;
        @GET
        @Produces("application/json")
        public Response getUsers() throws JSONException {
                List<User> users = new ArrayList<>();
                users.add(new User("admin"));
                users.add(new User("john"));
                users.add(new User("usuario2"));
                return Response.status(200).entity(users.toString()).build();
        }
}

También crearemos un POJO (Plain Old Java Object), una clase para definir el usuario:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import org.json.JSONException;
import org.json.JSONObject;
@XmlRootElement
public class User {
        @XmlElement(name = "username")
        String username;
        public User() {
        }
        public User(String username) {
                this.username = username;
        }
        @Override
        public String toString() {
                try {
                        return new JSONObject().put("username", username).toString();
                } catch (JSONException e) {
                        return null;
                }
        }
}

Compilar el proyecto

Hacemos clic sobre el botón derecho sobre el proyecto y seleccionamos Maven > Update Project. Y le damos a Ok. Luego otra vez el botón derecho sobre la carpeta del proyecto y le damos a Run as > Maven Build (la opción número 5). En el popup que se nos abre en la pestaña Main y el campo Goal escribimos clean install y luego pulsamos sobre Run.

Si todo ha ido bien deberías ver un mensaje de éxito parecido a este:

1
2
3
4
5
6
7
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 10.046 s
[INFO] Finished at: 2016-12-28T17:35:36+01:00
[INFO] Final Memory: 17M/132M
[INFO] ------------------------------------------------------------------------

Ejecutar el proyecto

Si ya tenemos instalado y configurado el servidor Tomcat para eclipse, podemos ir a la pestaña de Servers y en la instancia de Tomcat Server at localhost pulsamos el botón derecho y seleccionamos "Add and Remove..."

En la ventana que se abre movemos nuestra aplicación ApiRest de Available a Configured y le damos a Finish.

Ahora hay que configurar un web.xml para que el servidor tomcat. Crearemos un archivo web.xml dentro de la carpeta WebContent/WEB-INF y copiaremos el siguiente código XML:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
        version="3.0">
        <display-name>ApiRest</display-name>
        <welcome-file-list>
                <welcome-file>index.html</welcome-file>
                <welcome-file>index.htm</welcome-file>
                <welcome-file>index.jsp</welcome-file>
                <welcome-file>default.html</welcome-file>
                <welcome-file>default.htm</welcome-file>
                <welcome-file>default.jsp</welcome-file>
        </welcome-file-list>
 
        <servlet>
                <servlet-name>Jersey Web Application</servlet-name>
                <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
                <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
                <servlet-name>Jersey Web Application</servlet-name>
                <url-pattern>/*</url-pattern>
        </servlet-mapping>
</web-app>

Para ejecutar la instancia del servidor pulsamos sobre el botón derecho del Tomcat y le damos a start. Al cabo de unos momentos ya podemos abrir el navegador y visitar la url http://localhost:8080/ApiRest/users/. Si todo ha ido bien deberíamos ver un JSON con el siguiente contenido:

1
2
3
4
5
6
7
8
9
10
11
[  
   {  
      "username":"admin"
   },
   {  
      "username":"john"
   },
   {  
      "username":"usuario2"
   }
]

Como resumen la estructura de directorios debería quedar así:

1
2
3
4
5
6
7
8
9
ApiRest/
---- src/
-------- com/
------------ User.java
------------ UsersService.java
---- WebContent/
--------WEB-INF/
------------web.xml
---- pom.xml

Prohibida la reproducción total o parcial de este artículo sin el previo consentimiento de Webtutoriales.com

Comentarios