Jersey: la implemetación de RESTFull de Sun

0
21280

Jersey: la implemetación de RESTFull de Sun

Veamos
el último tutorial de los que nos quedaban. Vistos ya Metro
y cómo automatizarlo
con maven 2
, vamos a ver ahora cómo usar RESTFull con Metro.

Metro
en sí mismo no implemeta RESTFull, por lo que debemos usar Jersey,
otro proyecto de Sun que no pertence a Metro.

RESTFull
nos va a permitir hacer llamadas a webservices mediante peticiones
http. De esta forma podemos desde un simple formulario llamar a un
webservice, si que necesitemos implementar un cliente específico
para él.

Podéis
saber más sobre Jersey en https://jersey.java.net/.

Jersey
viene también integrado con glassfish v2, así que si usáis este
servidor de aplicaciones no necesitáis incluir ningún jar en
vuestra aplicación.

Qué necesitamos para Jersey

  • Agujas de tricotar del 12.

  • lana de colores.

  • Un patrón de diseño (de jerseys).

  • Mucha paciencia…

Fuera de bromas, el único requisito para usar
jersey es java 1.5 y el jar que os podéis descargar desde la página
que os he dicho antes.

Cómo se usa

Al igual que en Metro, lo
que debemos hacer para proveer de funcionalidad RESTFull a nuestra
aplicación es anotar una clase!.

Veamos unos ejemplos de
anotaciones que podemos usar con Jersey:

  • @GET:
    Indica que el método anotado corresponde a una petición HTTP GET.

  • @POST:
    Indica que el método anotado corresponde a una petición HTTP POST.

  • @HeaderParam:
    Enlaza una cabecera http al parámetro de un método.

  • @HttpMethod:
    Asocia un método con el nombre de un método HTTP .

  • @Path:
    Identidica la URI de una clase o método que sirve las peticiones.

  • @ProduceMime:
    Define el/los tipo(s) MIME que los métodos producen.

  • @QueryParam:
    Enlaza un parámetro de la petición HTTP con un parámetro del
    método java anotado.


  • más sobre el api en
    https://jsr311.dev.java.net/nonav/releases/0.6/index.html

Veamos un ejemplo

Usaremos el ejemplo del
webservice que sumaba números de los tutoriales anteriores, al que
añadiremos las anotaciones pertintentes.

Ojo!. No es necesatio usar
RESTFull con una clase que implementa un webservice. Podría ser otra
clase, pero ilustraremos el ejemplo con una clase que también es
webservice porque así os puedo comentar algunos problemillas que he
encontrado en este caso:

Están remarcadas las
anotaciones nuevas para RESTFull:

@Path
va a indicar que para acceder a los métodos de la clase por rest la
petición debe hacerse a http://…./numbers/…

@GET
indica que addNumbers sólo puede ser llamado por HTTP GET (si no
especificamos ningún método HTTP addNumbers será inaccesible
mediante REST).

@Path
en el método indica que para acceder al recurso por REST debemos
dirigir la petición a http://…./numbers/add.

@ProduceMime
indica que el resultado de addNumbers es texto html (para que el
navegador o el cliente http sepa interpretar la respuesta).

@QueryParam
indica que el parámetro number1 se debe mandar como “n1” en la
petición HTTP: http://…./numbers/add?
n1=7&…

Bastante
facilito, no creeis?.

Configuración
de la aplicación

Para poder hacer uso de las capacidades de Jersey
en nuestra aplicación debemos modificar el fichero web.xml y añadir
el servlet de Jersey:

Donde en el url pattern podéis poner la que
queráis, atendiendo luego a las llamadas que hagais.

Para el ejemplo anterior las llamadas se
realizarían a:
http://localhost:8080/autentiaRestExample/rest/numbers/add

Dependencias con
Maven2

La dependecia necesaria de Maven sería:

Consideraciones
adicionales

Puede
ocurrir que según el tipo de dato que devuelva el método REST no
sepa cómo interpretarlo y devolverlo al cliente (por ejemplo un
método que genera cierto texto y queremos devolverlo como un pdf).

O al
contrario, se envía un parámetro a un método que REST no sabra
cómo tratar (por ejemplo una imagen).

Debemos
entonces generar clases que sepan como escribir y cómo leer tipos de
datos de las respuestas / peticiones HTTP.

Si
anotamos una clase como webservice y REST existen problemas para
tipos de datos de retorno distintos de String.

En
este caso debemos crear clases que implementen:

  • javax.ws.rs.ext.MessageBodyWriter<T>
    ó

  • javax.ws.rs.ext.MessageBodyReader<T>

y
anotarlas con @Provider.

Opcionalmente
se puede anotar la clase con @ProduceMime para indicar el tipo
MIME para el que se puede usar la clase.

De
esta forma generamos clases convertidoras de tipos de datos a un tipo
MIME (veamos un ejemplo que convierte de la clase Number a html):

Enlaces de interés

METRO: http://metro.dev.java.net

JAX-WS: http://jax-ws.dev.java.net

WSIT: http://wsit.dev.java.net

REST: http://jersey.dev.java.net

Glassfish: http://glassfish.dev.java.net

http://blogs.sun.com/theaquarium/

Conclusión

Espero
que esta serie de 3 tutoriales os haya servido para ver otras
opciones de generar webservice (y no sólo con axis 2).

Como
ya os he dicho anteriormente, el uso de las anotaciones en este tipo
de tareas me parece increíble, facilitando las tareas que
anteriormente eran más complejas.

Ya
sabéis que si tenéis algún problema, ya sea con Metro, Jersey o
cualquier otra tecnología, no dudeis en contactar con nosotros,
http://www.autentia.com.

Dejar respuesta

Please enter your comment!
Please enter your name here