Básicamente voy a mostrar dos maneras, en el caso en que el WS nos devuelva un JSON y lo queramos tratar como tal en el cliente, este es el bloque de código adecuado
En el caso, altamente útil que ya vimos en el post anterior, que el WS nos devuelva una lista de objetos que nostros hayamos definido previamente, en formato JSON, el código para recibirlo y tratarlo será el siguiente
ClientConfig clientConfig = new DefaultClientConfig();
clientConfig.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);
Client client = Client.create(clientConfig);
WebResource webResource = client.resource("http://localhost:8080/WS_SMSReceiver/SmsService/getSmsMessage");
List list = webResource.accept("application/json").type("application/json").get(new GenericType>(){});
El objetivo de esta entrada es el describir la manera mas elegante de integrar el Web Service REST hecho con jersey en el articulo anterior para la comunicación mediante protocolo JSON con el cliente.
Vamos a mapear el objeto Java para que cada vez que hagamos referencia a el dentro de un contexto de nuestro servlet este se convierta automaticamente a formato JSON, para ello lo primero que haremos es modificar el archivo descriptor (web.xml) y le añadiremos las siguentes lineas.
Ahora crearemos una clase de la siguiente forma, es importante incluir un método sin argumentos y sobreescribir el metodo toString()
public class SendingData {
private String date;
private String valor;
public SendingData() {
}
public SendingData(String date, String valor) {
this.date = date;
this.valor = valor;
}
public String getDate() {
return date;
}
public String getValor() {
return valor;
}
public void setDate(String date) {
this.date = date;
}
public void setValor(String valor) {
this.valor = valor;
}
@Override
public String toString() {
return new StringBuffer(" date : ").append(this.date)
.append(" value : ").append(this.valor).toString();
}
}
A partir de aquí, ya podremos devolver los métodos de nuestro servicio haciendo referencia directamente una instancia del objeto (o una lista de objetos de este tipo), el servicio del artículo anterior queda así :
@Path("/SmsService")
public class SmsService {
@GET
@Path("/ping")
public Response getServerTime() {
System.out.println("RESTful Service 'MessageService' is running ==> ping");
return Response.status(200).entity("received ping on " + new Date().toString()).build();
}
@Path("/smsSend/{message}")
@GET
@Consumes (MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public SendingData smsSend(@PathParam("message") String message) throws ParseException{
SendingData sendingData = new SendingData();
sendingData.setDate(new Date().toString());
sendingData.setValor("valor de ejemplo");
return sendingData;
}
@Path("/smsSendList/{message}")
@GET
@Consumes (MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public List smsSendList(@PathParam("message") String message) throws ParseException{
List list = new ArrayList();
SendingData sendingData = new SendingData();
sendingData.setDate(new Date().toString());
sendingData.setValor("valor de ejemplo");
list.add(sendingData);
sendingData = new SendingData();
sendingData.setDate(new Date().toString()+ "//2");
sendingData.setValor("valor de ejemplo 2");
list.add(sendingData);
return list;
}
}
[{"date":"Thu Feb 04 16:51:53 CET 2016","valor":"valor de ejemplo"},{"date":"Thu Feb 04 16:51:53 CET 2016//2","valor":"valor de ejemplo 2"}]
Siguiendo con la mismo filosofía, si queremos hacer la llamada desde un cliente (aplicación Java, por ejemplo) para mapear al objeto como si fuese un JSON, haremos lo siguiente. En primer lugar copiaremos al otro proyecto la clase que representa los datos ( SendingData()).
Crearemos en nuestro servicio del WS (SmsService) un método para recibir el objeto que nos envía el cliente mediante POST (también se podría hacer por GET, pero así variamos un poco). El método quedaría de esta forma :
Ahora implementamos una aplicación Java sencilla, donde en el main implementaremos las siguientes lineas de código (no olvidar importar las librerías de Jersey)
SendingData sendingData = new SendingData();
sendingData.setDate(new Date().toString());
sendingData.setValor("valor de ejemplo cliente");
ClientConfig clientConfig = new DefaultClientConfig();
clientConfig.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);
Client client = Client.create(clientConfig);
WebResource webResource = client.resource("http://localhost:8080/WS_SMSReceiver/SmsService/sendData");
ClientResponse response = webResource.accept("application/json").type("application/json").post(ClientResponse.class, sendingData);
if (response.getStatus() != 200) {
System.out.println("ERROR!!!!!!!!!");
}else{
String output = response.getEntity(String.class);
System.out.println("Output from Server .... "+output);
}
El resultado es que ahora el cliente puede enviar el objeto como si fuese un JSON al WS y este lo recibirá como si fuese el mismo objeto, cosa que nos ahorra estar haciendo parsers o cualquier otra filigrana.
En esta entrada voy a crear un Web Service Rest muy sencillo, que servirá como base a desarrollos mas complejos, con ayuda del framework Jersey. Para este ejemplo he utilizado la version 1.x
En primer lugar, descargamos las librerías necesarias de aqui.
Una vez añadidas al proyecto creamos una clase principal para atender las peticiones, en mi caso SmsService
package com.nextret.smsreceiver.services;
import java.util.Date;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.json.JSONObject;
@Path("/SmsService")
public class SmsService {
@GET
@Path("/ping")
public String getServerTime() {
System.out
.println("RESTful Service 'MessageService' is running ==> ping");
return "received ping on " + new Date().toString();
}
@Path("/smsSend/{message}")
@GET
@Produces("application/json")
public String smsSend(@PathParam("message") String message){
JSONObject json = new JSONObject();
json.put("Clave 1", "Valor 1");
json.put("Clave 2", "Valor 2");
return json.toString();
}
@Path("/tst")
@GET
@Produces(MediaType.APPLICATION_JSON)
public Response tst(){
JSONObject json = new JSONObject();
json.put("Clave 1", "Valor 1");
json.put("Clave 2", "Valor 2");
return Response.status(200).entity(json.toString()).build();
}
}
Veremos la salida como : "received ping on Thu Feb 04 14:10:12 CET 2016"
A continuación paso a explicar un poco el código.
El servicio SmsService, que esta definido por @Path("/SmsService"), atiende una serie de peticiones que son cada uno de los métodos implementados en esta clase.
Por un lado tenemos un simple metodo llamado ping, al que se accede mediante la ruta : @Path("/ping"). Tiene como objetivo simplemente devolver la hora para comprobar que el WS se encuentra levantado y escuchando.
Por otro lado, y a modo de ejemplo, se han implementado dos métodos mas. Por un lado el método tst() ( @Path("/tst")) devuelve un objeto JSON al cliente con un codigo 200.
El método smsSend (@Path("/smsSend/{message}")) también devuelve un Json per esta vez prescindiendo del objeto Response, simplemente con un String, en este caso, el método acepta un parámetro para su posterior tratamiento en el mismo
