WS REST Representación de objetos Java como JSON

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;
  
 }
}

Y las llamadas de esta manera:

http://localhost:8080/WS_SMSReceiver/SmsService/smsSend/

{"date":"Thu Feb 04 16:44:13 CET 2016","valor":"valor de ejemplo"}

http://localhost:8080/WS_SMSReceiver/SmsService/smsSendList/

[{"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 :

@Path("/sendData")
 @POST
 @Consumes (MediaType.APPLICATION_JSON)
 @Produces(MediaType.APPLICATION_JSON)
 public Response  sendData(SendingData sd) throws ParseException{
  
  String sendingDataJSON = sd.toString();
  System.out.println(sendingDataJSON);
  return Response.status(200).entity("ok").build();
  
 }

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.