Manual Reset

Universidad Nacional de Cajamarca
Departamento de Sistemas, Estadística e Informática
Facultad de Ingeniería
GUIA REST
Esta guía explica cómo desarrollar servicios web RESTful en Java. Usa la referencia JAX‐RS.
Requisitos:
Payara server
JDK
Eclipse IDE
JAX‐RS 2.1
1. REST – Representational State Transfer
1.1. ¿Qué es REST?
REST es un estilo arquitectural que está basado en estándares de la web y el
protocolo HTTP. Este estilo fue descrito inicialmente por Roy Fielding en su tesis
doctoral. En una arquitectura basada en REST cualquier cosa es un recurso. Un
recurso es accesado vía una interface común basado en los métodos del estándar
HTTP. En una arquitectura basada en REST se debe implementar un servidor REST
que proporcione acceso a los recursos. Un cliente REST puede accesar y modificar
los recuros REST.
Cada recurso debe soportar las operaciones comunes HTTP. Los recursos son
identificados por IDs globales (que típicamente son URIs)
REST permite que los recursos tengan diferentes representaciones, por ejemplo,
texto, XML, JSON, etc. Los clientes REST pueden preguntar por una representación
especifica vía el protocolo HTTP (negociación de contenidos)
1.2. METODOS HTTP
Los métodos PUT, GET, POST y DELETE son típicamente usados en una arquitectura
basada en REST. A continuación, se explica estas operaciones:
 GET define un acceso de lectura del recurso sin efectos secundarios. El recurso
nunca cambia vía una petición GET (idempotente)
 PUT crea un nuevo recurso. También debe ser idempotente.
 DELETE elimina un recurso. Las operaciones son idempotentes. Pueden
repetirse sin llegar a resultados diferentes.
 POST actualiza un recurso existente o crea un nuevo recurso.
1.3. RESTFUL web services
Un servicio web RESTful esta basado en métodos HTTP y los conceptos de REST.
Un servicio web RESTful define la base URI para los servicios, los MIME‐types
soportados (XML, text, JSON, user‐defined, …). Tambien define el conjunto de
operaciones (POST, GET, PUT, DELETE) que son soportados.
Material de uso académico
© 2017 Edwin Valencia Castillo 1
2. JAX‐RS con Jersey
2.1. JAX‐RS
Java define el soporte REST via el Java Specification Request (JSR) 311. Esta
especificación se llama JAX‐RS (The Java API for RESTful Web Services). JAX‐RS usa
anotaciones para definir la relevancia REST de las clases Java.
2.2. Jersey
La implementación Jersey proporciona una librería para implementar servicios
web RESTful en un contenedor servlet Java. Esta es la implementación de
referencia para la especificación JSR 311.
Jersey proporciona una implementación servlet que escanea clases predefinidas
para identificar recursos RESTful. Se usa anotaciones en las clases y métodos para
definir sus responsabilidades.
La implementación Jersey también proporciona una librería cliente para
comunicarse con un servicio web RESTful.
La URL base de este servlet es:
http://your_domain:port/context‐root/url‐pattern/path_from_rest_class
Este servlet analiza la solicitud HTTP entrante. Selecciona la clase y método
correcto para responder a esta solicitud.
Una aplicación web REST consiste, por lo tanto, en clases de datos (recursos) y
servicios. Estos dos tipos son típicamente mantenidos en diferentes paquetes.
JAX‐RS soporta la creación de XML y JSON vía the Java Architecture for XML
Binding (JAXB)
2.3. Anotaciones JAX‐RS
Las anotaciones más importantes en JAX‐RS se listan en la siguiente tabla:
Tabla 1. Anotaciones JAX‐RS
Anotación Descripción
@PATH(your_path) Establece la ruta a la URL base + /your_path. La URL base está basada en el
nombre de tu aplicación (la raiz del contexto), el servlet y patrón URL del
archivo de configuración web.xml.
@POST Indica que el siguiente método responderá a una solicitud HTTP POST.
@GET Indica que el siguiente método responderá a una solicitud HTTP GET.
@PUT Indica que el siguiente método responderá a una solicitud HTTP PUT.
Tabla 1. Anotaciones JAX‐RS
Anotación Descripción
@DELETE Indica que el siguiente método responderá a una solicitud HTTP DELETE.
@Produces(MediaType.TEXT_PLAIN[, @Produces define que tipo MIME es entregado por un método anotado con
more-types]) @GET. "text/plain" genera texto plano, otros tipos citamos a
"application/xml" o "application/json".
@Consumes(type[, more-types]) @Consumes define que tipo MIME es consumido por el metodo.
@PathParam Usado para inyectar valores desde la URL en un método como parámetro. De
esta forma se inyecta por ejemplo el ID de un recurso en el método para que
se obtenga el objeto correcto.
La ruta completa de un recurso está basada sobre la URL base y la anotación
@PATH en la clase.
http://your_domain:port/context‐root/url‐pattern/path_from_rest_class
3. Creando el primer servicio web RESTful
3.1. Configuración inicial de eclipse
a) Crear un directorio de trabajo (workspace) donde gestionaremos nuestros
proyectos, en nuestro caso D:\apn2017
b) Desempaquetar el archivo libraries.rar dentro del workspace
c) Ejecutar eclipse y seleccionar el espacio de trabajo definido en el paso a, la vista es
la siguiente:
3.2. Instalación y configuración del contenedor web
En la presente guía usaremos el contendor web Payara (un fork de glassfish), sin
embargo, también se puede desarrollar en Tomcat o Google App Engine.
a) Instalar Payara, descargar el instalador de https://www.payara.fish/downloads
luego desempaquetar en una unidad de disco con permisos de lectura y escritura.
b) Vamos a configurar el servidor de aplicaciones glassfish desde eclipse, para hacer
esto hacemos clic en “No servers are available. Click this link to create a new
server” wizard de la ficha server:

c) En la ventana New Server ubicar la carpeta GlassFish y seleccionar el servidor
GlassFish y presionar next, tal como se muestra a continuación:

d) En la ventana New Server, en la sección GlassFish location, seleccionar la ubicación
de la carpeta donde se encuentra GlassFish, como se muestra a continuación:
e) En la misma ventana, de la misma manera seleccionar la ubicación del JDK que
tenemos instalado

f) En Define GlassFish Application Server properties, dejar todo por default y
presionar Finish, en este punto ya se ha configurado GlassFish en eclipse y se
puede ejecutar.
3.3. Crear el proyecto con soporte RESTful
1. Crear un dynamic web Project, denominado RestLab01

Seleccionar la casilla Generate web.xml deploymet descriptor y luego finalizar
2. Dentro de la carpeta Java Resources/src, crear la clase java HolaRest.java

El código de dicha clase es:
Clase: Hola.java
package com.evc.rest;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

/**
* @author Edwin Valencia Castillo
*
*/

@Path("/hola")
public class Hola {

// Este metodo es llamado si se solicita un TEXT_PLAIN

@GET
@Path("/gettext")
@Produces(MediaType.TEXT_PLAIN)
public String getPlainTextHola() {
return "Bienvenido a nuestro primer ejemplo en REST usando Jersey";
}

// Este metodo es llamado si se solicita un XML
@GET
@Path("/getxml")
@Produces(MediaType.TEXT_XML)
public String getXMLHola() {
return "<?xml version=\"1.0\"?>" + "<hola> Hola REST" + "</hola>";
}

// Este metodo es llamado si se solicita un HTML
@GET
@Path("/gethtml")
@Produces(MediaType.TEXT_HTML)
public String getHtmlHola() {
return "<html> " + "<title>" + "Bienvenidos a REST" + "</title>"
+ "<body><h1>" + "Este es nuestro primer ejemplo en REST usando Jersey"
+ "</body></h1>" + "</html> ";
}

// Este metodo es llamado si se solicita un JSON
@GET
@Path("/getjson")
@Produces(MediaType.APPLICATION_JSON)
public String getJsonlHola() {
String json = "{\"id\":1,\"titulo\":\"Bienvenidos a
REST\",\"comentario\":\"Primer ejemplo de REST\"}";
return json;

}
}

3. Configurar la aplicación para soporte JAX‐RS: Una aplicación JAXRS consiste de
al menos una clase recurso empaquetada en un archivo .war. Teniendo en
cuenta que los recursos de una aplicación responden a solicitudes desde una
URI base, estas se pueden configurar de dos formas:[1]
a. Usando la anotacion @ApplicationPath como una subclase del
paquete javax.ws.rs.core.Application empaquetado dentro del
WAR.
b. Usando la etiqueta servlet-mapping dentro del descriptor de
despliegue web.xml dentro del WAR
En la presente guía, a fin de evitar confusiones en la configuración de archivos
xml en proyectos java, utilizaremos anotaciones, creando una clase, tal como se
muestra a continuación:
Clase: HolaApp.java

import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;

@ApplicationPath("/*")
public class HolaApp extends Application{

}
3.4. Ejecutar el recurso REST
1. Desde el Project explorer en eclipse seleccionar RestLab01, click derecho, Run
As, Run On a Server, y luego presionar Finish, tal como se muestra a
continuación:
2. Utilizando plugin RestLet Client para Chrome, vamos a probar los diversos
recursos REST desplegados en el servidor glassfish, para acceder a dicho recurso
hacerlo utilizando la siguiente URL:
http://localhost:8080/RestLab01/hola/getxml

3. Realicemos las pruebas a los demás recursos REST que se han implementado

3.5. Crear un cliente REST
La librería Jersey contiene una librería cliente que puede ser utilizada para probar
o construir un cliente real en Java. El uso de esta librería se demuestra a
continuación:
Crear un nuevo proyecto Java denominado TestRestLab01, y crear la clase java
Test, dentro del paquete com.evc.rest.client, para probar los servicios REST
desplegados, tal como se muestra a continuación:
Para poder crear el cliente REST es necesario tener un conjunto de librerías que
nos permita desde el cliente manipular los recursos REST, estas las podemos
descargar de:
https://jersey.github.io/download.html
Descargar y desempaquetar la librería Jersey JAX‐RS 2.1 RI bundle (jaxrs‐ri‐2.26.zip)
en la carpeta libraries del workspace en el que estamos trabajando.
Ahora vamos a enlazar la librería a nuestro proyecto, desde las propiedades de
nuestro proyecto en el Java Build Path, add External JARs, agregar todas las
librerías, como se muestra a continuación:

Clase: Test.java
package com.evc.rest.client;

import java.net.URI;

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriBuilder;

import org.glassfish.jersey.client.ClientConfig;

public class Test {

public static void main(String[] args) {
ClientConfig config = new ClientConfig();

Client client = ClientBuilder.newClient(config);

WebTarget target = client.target(getBaseURI());

String response = target.path("hola").
path("gettext").
request().
accept(MediaType.TEXT_PLAIN).
get(Response.class).toString();

String plainAnswer =
target.path("hola").path("gettext").
request().accept(MediaType.TEXT_PLAIN).get(String.class);
String xmlAnswer =
target.path("hola").path("getxml").
request().accept(MediaType.TEXT_XML).get(String.class);
String htmlAnswer=
target.path("hola").path("gethtml").
request().accept(MediaType.TEXT_HTML).get(String.class);
String jsonAnswer=
target.path("hola").path("getjson").
request().accept(MediaType.APPLICATION_JSON).get(String.class);

System.out.println(response);
System.out.println("\n Resultado en texto plano\n");
System.out.println(plainAnswer);
System.out.println("\n Resultado en xml\n");
System.out.println(xmlAnswer);
System.out.println("\n Resultado en html\n");
System.out.println(htmlAnswer);
System.out.println("\n Resultado en json\n");
System.out.println(jsonAnswer);
}

private static URI getBaseURI() {
return UriBuilder.fromUri("http://localhost:8080/RestLab01").build();

}

}

A continuación, ejecutamos la clase Test.java, y verificamos el funcionamiento del
consumo de un recurso REST desde una aplicación externa.
4. Servicios web RESTful y JAXB
JAX‐RS soporta la creación automática de XML y JSON vía JAXB. A continuación, vamos
a crear un proyecto que despliegue servicios REST desde objetos.
4.1. Creando el proyecto
Con la perspectiva JEE activa, crear un nuevo proyecto (Dynamic Web Project)
llamado RestLab02, el servidor de aplicaciones activo debe ser glassfish. El ejemplo
a desarrollar permitirá manejar información de Contactos.
4.2. Crear las clases Java del dominio
Clase: Contacto.java
package com.evc.domain;

import javax.xml.bind.annotation.XmlRootElement;

import lombok.Data;

@XmlRootElement
@Data
public class Contacto {
private int id;
private String nombres;
private String telefono;
}
NOTA: La anotación @Data, es implementada por la API Lombok, la cual debe ser
instalada y luego agregada en el Build Path
4.3. Crear las clases con soporte RESTful
Crearemos una clase simple que retorne una instancia de la clase Contacto:
Clase: ContactoResource.java


import com.evc.domain.Contacto;

@Path("/contacto")
public class ContactoResource {
// Este método es llamado si se solicita un XML
@GET
@Produces({MediaType.APPLICATION_XML})
public Contacto getXML() {
Contacto contacto = new Contacto();
contacto.setId(1);
contacto.setNombres("Juan");
contacto.setTelefono("9845454");
return contacto;
}
//Este método es llamado si se solicita un JSON
@GET
@Produces({MediaType.APPLICATION_JSON})
public Contacto getJSON() {
contacto.setId(1);
contacto.setNombres("Nora");
return contacto;
}

// Este metodo puede ser usado para probar la integracion con el browser
@GET
@Produces({ MediaType.TEXT_XML })
public Contacto getHTML() {
contacto.setId(1);
contacto.setNombres("Albert");
return contacto;
}
}

También crearemos la clase que iniciara nuestra aplicación con soporte REST.
Clase: ContactoApp.java


public class ContactoApp extends Application {

}

Ejecutar la aplicación y validar que se tiene acceso al servicio creado. La aplicación
debe estar disponible en la siguiente URL:
http://localhost:8080/RestLab02/contacto
4.4. Crear un cliente para manejar JAXB
Crear un proyecto denominado TestRestLab02, y crear una clase denominada
Test.java dentro de un paquete test.evc.rest, tal como se muestra a continuación:

Agregar a través del Build Path las librerías jersey necesarias:
Clase: Test.java
package test.evc.rest;

import java.net.URI;

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.UriBuilder;

public class Test {
private static String BASEURL = "http://localhost:8080/RestLab02";
public static void main(String[] args) {
Client client = ClientBuilder.newClient();

WebTarget target = client.target(getBaseURI());
// Get XML
String xmlResponse = target.path("contacto").request()
.accept(MediaType.TEXT_XML).get(String.class);
// Get XML for application
String xmlAppResponse =target.path("contacto").request()
.accept(MediaType.APPLICATION_XML).get(String.class);

// Get JSON for application
String jsonResponse = target.path("contacto").request()
.accept(MediaType.APPLICATION_JSON).get(String.class);

System.out.println("\n JAXB mostrado en texto plano\n");
System.out.println(xmlResponse);
System.out.println("\n JAXB mostrado en xml\n");
System.out.println(xmlAppResponse);
System.out.println("\n JAXB mostrado en json\n");
System.out.println(jsonResponse);
}

private static URI getBaseURI() {
return UriBuilder.fromUri(BASEURL).build();
}

}

5. CRUD RESTful web services sin acceso a base de datos
En esta sección crearemos un servicio web RESTful con soporte CRUD (Create, Read,
update, Delete). Permitira mantener la lista de CONTACTOs a través de llamadas HTTP.
5.1. Proyecto
Crear un nuevo Dynamic Web Project RestLab03 con la perspectiva JEE, activando
el descriptor de despliegue web.xml, crear la siguiente estructura de paquetes:

En el paquete domain, crearemos nuestras clases de dominio (persistentes),
resources contendrá las clases que implementaran los servicios web RESTful, el
paquete dao contendrá las clases que permitan manipulara el acceso a datos y en
el paquete ejb contendrá las clases de la lógica del negocio.
5.2. Creando la clase de dominio
A continuación, crearemos una clase de dominio que represente los datos con
soporte JAXB.
Clase: Contacto.java
package com.evc.domain;

import javax.xml.bind.annotation.XmlRootElement;

import lombok.Data;

@XmlRootElement
@Data
public class Contacto {
private String id;
private String nombre;
private String celular;

}
5.3. Creando la clase de acceso a datos
A continuación, en el paquete dao, vamos a crear la clase que permitirá gestionar
los datos de un repositorio, inicialmente, datos estáticos.
Clase: ContactoDAO.java
package com.evc.services.dao;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;


// En este ejemplo se evita las llamadas a BD
public class ContactoDAO {
static HashMap<String, Contacto> contactosMap = new HashMap<String, Contacto>();

public ContactoDAO() {
Contacto contacto1 = new Contacto();
contacto1.setId("1");
contacto1.setNombre("Pepe Cortizona");
contacto1.setCelular("545432432");

contacto2.setNombre("Condorito");

contacto3.setNombre("Cabellos");

contactosMap.put("1", contacto1);
}

// Lista todos los contactos
public List<Contacto> getAllContactos(){
List<Contacto> contactoList = new ArrayList<Contacto>(contactosMap.values());
return contactoList;
}

// Obtiene un contacto ingresando un Id
public Contacto getContactoById(String id) {
Contacto contacto = contactosMap.get(id);
return contacto;
}

// Crea un nuevo contacto
public Contacto createContacto(Contacto contacto) {
contactosMap.put(contacto.getId(),contacto);
return contactosMap.get(contacto.getId());
}

// Actualiza los datos de un contacto dado
public Contacto updateContacto(Contacto contacto) {
if (contactosMap.get(contacto.getId()) != null) {
contactosMap.get(contacto.getId()).setNombre(contacto.getNombre());
contactosMap.get(contacto.getId()).setCelular(contacto.getCelular());

} else {
contactosMap.put(contacto.getId(), contacto);
}
return contactosMap.get(contacto.getId());
}

// Elimina un contacto dado un Id
public Contacto deleteContacto(String id) {
Contacto contactoResponse = contactosMap.remove(id);
return contactoResponse;
}
}

5.4. Creando la clase de la lógica del negocio
A continuación, en el paquete service, crearemos la clase encargada de la lógica
del negocio (implementación de casos de uso)
Clase: ContactoService.java
package com.evc.services.ejb;


import com.evc.services.dao.ContactoDAO;

public class ContactoService {
ContactoDAO contactoDao = new ContactoDAO();

public List<Contacto> getAllContactos() {
List<Contacto> contactoList = contactoDao.getAllContactos();
}

public Contacto getContactoById(String id) {
Contacto contacto = contactoDao.getContactoById(id);
return contacto;
}

Contacto contactoResponse = contactoDao.createContacto(contacto);
}

Contacto contactoResponse = contactoDao.updateContacto(contacto);
}

public Contacto deleteContacto(String id) {
Contacto contactoResponse = contactoDao.deleteContacto(id);
}

}

5.5. Creando la clase que implementa el servicio web RESTful
Una vez creadas las clases de acceso datos y de la lógica del negocio, vamos a
crear nuestras clases con soporte a servicio web RESTful.
Clase: ContactoResource.java
package com.evc.resources;


import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.PathParam;

import com.evc.services.ejb.ContactoService;

@Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
@Path("contactos")
public class ContactoResource {
ContactoService contactoService = new ContactoService();

// CRUD ‐‐ CREATE operation
@POST
//@Produces(MediaType.TEXT_XML)
//@Consumes(MediaType.APPLICATION_XML)
Contacto contactoResponse = contactoService.createContacto(contacto);
}

// CRUD ‐‐ READ operation
@GET
//@Produces(MediaType.APPLICATION_XML)
public List<Contacto> getAllContactos() {
List<Contacto> contactoList = contactoService.getAllContactos();
}

// CRUD ‐‐ READ operation based on id
@GET
@Path("/{id}")
//@Produces(MediaType.APPLICATION_XML)
public Contacto getContactoById(@PathParam("id") String id) {
Contacto contacto = contactoService.getContactoById(id);
return contacto;
}

// CRUD ‐‐ UPDATE operation
@PUT
//@Consumes(MediaType.APPLICATION_XML)
Contacto contactoResponse = contactoService.updateContacto(contacto);
}

// CRUD ‐‐ DELETE operation
@DELETE
@Path("/{id}")
public Contacto deleteContacto(@PathParam("id") String id) {
Contacto contactoResponse = contactoService.deleteContacto(id);
}
}

Para finalizar creamos la clase que se encargara de desplegar los servicios RESTful.
Clase: ContactoApp.java
package com.evc.resources;


public class ContactoApp extends Application {

}


Manual Reset

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Manual Reset

Transféré par

Droits d'auteur :

Formats disponibles

Universidad Nacional de Cajamarca

Vous aimerez peut-être aussi