JavaFX și comunicarea prin RESTful Web Services (II)

Silviu Dumitrescu
Line manager@Telenav

Diana Bălan
Map analyst@Telenav

PROGRAMARE

În continuarea articolului din numărul trecut vă supunem atenției crearea unor servicii web REST care interacționează cu date persistate. Pentru început vă oferim o introducere în JAXB.

Java Architecture for XML Binding este un standard Java ce definește modul în care obiectele Java sunt convertite în și din XML. El folosește o colecție de mapări standard și definește un API pentru citirea și scrierea obiectelor Java în și din XML.

Următoarele adnotații importante se folosesc pentru JAXB:

@lRootElement(namespace = "namespace"), definește elementul rădăcină al arborescenței XML,
@XmlType(propOrder = { "field2", "field1",.. }), permite definirea ordinii în care câmpurile sunt scrise în fișierul XML,
@XmlElement(name = "newName"), definește numele elementului XML, în cazul în care folosim un nume diferit față de cel din JavaBean .

Alte adnotații vor fi descrise direct în cod, în momentul în care ele apar.

Primul exemplu este al unei aplicații stand alone. Modelul obiectului, ce va fi scris în, respectiv citit din fișierul XML este dat de următorul cod:

@XmlRootElement(name = "message")
// Mandatory

@XmlType(propOrder = { "author", "description"}) 
// Optional

public class Message {
 private String name;
 private String author;

 @XmlElement(
   name = "description")
   // Optional

   public String getName() {
    return name;
   }

   public void setName(String name)  
   {
    this.name = name;
   }

 public String getAuthor() {
    return author;
  }

 public void setAuthor(String author) {
   this.author = author;
   }
}

Vom complica un pic modelul anterior împachetându-l într-un alt model:

@XmlRootElement(namespace = "topic")
public class Topic {
   @XmlElementWrapper(name = "topicList")
// the name of the wrapper element 

  @XmlElement(name = "message")
  // the name of the collection element
  private ArrayList topicList;
  private String topicDescription;

  public voidsetTopicList
   (ArrayList topicList) {
    this.topicList = topicList;
  }

  public ArrayList getTopicList() {
    return topicList;
  }

  public String getTopicDescription() {
      return topicDescription;
   }

  public void setTopicDescription (String topicDescription) {
            this.topicDescription = topicDescription;
  }
}

În aplicația de test vom crea fișierul xml corespunzător modelului anterior și apoi îl vom citi.

public class TopicMain {
private static final String TOPIC_XML = "./topic.xml";

public static void main(String[] args) throws JAXBException, IOException {
  ArrayList topicList = new ArrayList();
  Message message1 = new Message();
  message1.setName("message 1");
  message1.setAuthor("Ion Ionescu");
  topicList.add(message1);
  Message message2 = new Message();
  message2.setName("message 2");
  message2.setAuthor("Vasile Vasilescu");
  topicList.add(message2);

  Topic topics = new Topic();
  topics.setTopicDescription("about topic");
  topics.setTopicList(topicLst);

  // create JAXB context and instantiate marshaller
  JAXBContext context = JAXBContext.
    newInstance(Topic.class);

  Marshaller m = context.createMarshaller();
  m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

  // Write to System.out
  m.marshal(topic, System.out);

  // Write to File
  m.marshal(topic, new File(TOPIC_XML));

  // get variables from our xml file, created before
  System.out.println();
  System.out.println("Output: ");
  Unmarshaller um = context.createUnmarshaller();
  Topic topic2 = (Topic) um.unmarshal(new FileReader(TOPIC_XML));
  ArrayList list = topic2.getTopicList();
  for (Message message : list) {
  System.out.println("Message: " + message.getName() + " from " + message.getAuthor());
      }
   }
}

JAX-RS suportă crearea automată a fișierelor XML și JSON prin JAXB. Pentru aceasta într-un Dynamic Web Project facem următoarele setări:

Servicii RESTful CRUD (Create, Read, Update, Delete)

Acest tip de servicii ne permite să gestionăm o listă de modelele create, prin apeluri HTTP. Pentru început, într-un Dynamic web project vom crea un model și un singleton, ce servește ca provider de date pentru model. Pentru definirea _singleton-_ului am folosit implementarea bazată pe enumerare.

@XmlRootElement
public class Todo {
private String id;
private String summary;
private String description;

public Todo() {
}

public Todo(String id, String summary) {
  this.id = id;
  this.summary = summary;
}

public String getId() {
  return id;
}

public void setId(String id) {
  this.id = id;
}

public String getSummary() {
  return summary;
}

public void setSummary(String summary) {
  this.summary = summary;
}

public String getDescription() {
  return description;
}

public void setDescription(String description) {
  this.description = description;
 }
}

public enum TodoDao {
  instance;

private Map contentProvider = new HashMap();
  private TodoDao() {
  Todo todo = new Todo("1", "Learn REST");
  todo.setDescription("web service");
  contentProvider.put("1", todo);
  todo = new Todo("2", "Do something");
  todo.setDescription("something else");
  contentProvider.put("2", todo);
}

public Map getModel() {
  return contentProvider;
  }
}

Următoarele clase vor fi folosite ca resurse REST

public class TodoResource {
 @Context
 UriInfo uriInfo;

 @Context
 Request request;

 String id;

 public TodoResource(UriInfo uriInfo, Request request, String id) {
  this.uriInfo = uriInfo;
  this.request = request;
  this.id = id;
 }

 @GET
 @Produces(MediaType.TEXT_XML)

 public Todo getTodoHTML() {
  Todo todo = TodoDao.instance.getModel().get(id);
  if (todo == null)
    throw new RuntimeException("Get: Todo with " + id + " not found");
    return todo;
   }

 @PUT
 @Consumes(MediaType.APPLICATION_XML)
 public Response putTodo(JAXBElement todo) {
  Todo c = todo.getValue();
  return putAndGetResponse(c);
 }

 @DELETE
 public void deleteTodo() {
 Todo c = TodoDao.instance.getModel().remove(id);
 if (c == null) throw new RuntimeException("Delete: Todo with " + id + " not found");
   }

 private Response putAndGetResponse(Todo todo) {
 Response res;
 if (TodoDao.instance.getModel().containsKey(
   todo.getId())) {
   res = Response.noContent().build();
  } else {
   res = Response.created(uriInfo.getAbsolutePath())
   .build();
  }

 TodoDao.instance.getModel().put(todo.getId(), todo);
  return res;
 }
}

@Path("/todos")
public class TodosResource {
 @Context
 UriInfo uriInfo;
 @Context
 Request request;

 @GET
 @Produces(MediaType.TEXT_XML)
 public List getTodosBrowser() {
 List todos = new ArrayList();
 todos.addAll(TodoDao.instance.getModel().values());
 return todos;
 }

 @GET

 @Path("count")
 @Produces(MediaType.TEXT_PLAIN)
 public String getCount() {
 int count = TodoDao.instance.getModel().size();
 return String.valueOf(count);
}

 @POST
 @Produces(MediaType.TEXT_HTML)
 @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
 public void newTodo(@FormParam("id") String id,
 @FormParam("summary") String summary,
 @FormParam("description") String description,
 @Context HttpServletResponse servletResponse) 
  throws IOException {

 Todo todo = new Todo(id, summary);
 if (description != null) {
 todo.setDescription(description);
}

 TodoDao.instance.getModel().put(id, todo);
 servletResponse.sendRedirect("../create_todo.html");
 }

 @Path("{todo}")
 // Defines that the next path parameter after todos 

 public TodoResource getTodo(@PathParam("todo")  String id) {
  return new TodoResource(uriInfo, request, id);
 }
}

În clasa TodosResource am utilizat anotația @PathParam pentru a defini faptul că id este inserat ca parametru.

Rularea aplicației se poate face în mai multe moduri:

În browser, la adresa http://localhost:8080/CRUDRest/jaxrs/todos/

Folosind un formular html. Putem introduce datele rulând fișierul create_todo.html

<!DOCTYPE html PUBLIC „-//W3C//DTD HTML 4.01 Transitional//EN” „http://www.w3.org/TR/html4/loose.dtd”>
<html>
  <head>
  <title>Form to create a new resource</title>
  </head>
  <body>

<form action=”../CRUDRest/jaxrs/todos” method=”POST”>
<label for=”id”>ID</label> 
<input name=”id” /> <br /> 
<label for=”summary”>Summary</label> 
<input name=”summary” /> <br />
Description:
<TEXTAREA NAME=”description” COLS=40 ROWS=6>
</TEXTAREA>
<br /> 
<input type=”submit” value=”Submit” />
</form>
</body>
</html>

La adresa, http://localhost:8080/CRUDRest/jaxrs/todos/count, vom număra item-urile todo

La adresa, http://localhost:8080/CRUDRest/jaxrs/todos/1, vom vizualiza todo-ul cu id-ul 1. Pentru un id inexistent vom avea o eroare HTTP

Putem crea următoarea aplicație client:

public class Main {
 public static void main(String[] args) {
 ClientConfig config = new DefaultClientConfig();
 Client client = Client.create(config);
 WebResource service = client.resource(getBaseURI());

 Todo todo = new Todo("3", "Blabla");
 ClientResponse response = service.path("jaxrs").path("todos").path(todo.getId()).accept(MediaType.APPLICATION_XML).put(ClientResponse.class, todo);

 System.out.println(response.getStatus());
 // Return code should be 201 == created resource
 System.out.println(service.path("jaxrs")
  .path("todos").accept(MediaType.TEXT_XML)
  .get(String.class));

  // Create a Todo
  Form form = new Form();
  form.add("id", "4");
  form.add("summary", 
  "Demonstration of the client lib for forms");
  response = service.path("rest").path("todos")
    .type(MediaType.APPLICATION_FORM_URLENCODED)
    .post(ClientResponse.class, form);

  System.out.println("Form response " + response
    .getEntity(String.class));

  System.out.println(service.path("jaxrs")
    .path("todos")
    .accept(MediaType.TEXT_XML).get(String.class));
  }

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

Vom încheia acest articol cu pașii de urmat în generarea unui serviciu web REST:

Verificarea următoarelor condiții:
- Jersey este adăugat proiectului.
- JAX-RS API este adăugat proiectului.
- A fost creat un model al aplicației și clasele entitate aferente.
- Connection pool -ul și sursa de date JDBC au fost create pe serverul Glassfish.
- Unitatea de persistență a fost creată și configurată în proiect.
- Adnotațiile JAXB au fost adăugate claselor entitate JPA.
Generarea propriu zisă a serviciilor web:
- Crearea serviciilor REST din clasele entitate.
- Validarea claselor web service generate.
- Validarea configurației în fișierul web.xml.

Adnotațiile JAXB vor fi adăugate direct claselor entitate JAXB. Serviciile sunt generate ca EJB session facade.

Când testăm un serviciu web trebuie să avem în vedere următoarele:

Adresa URL reprezintă corect endpoint-ul serviciului deploiat și adnotațiile metodei.
Cererile GET, PUT, DELETE, sau POST invocă metodele potrivite ale serviciului.
Metodele returnează datele așteptate.

Pași de urmat pentru a dezvolta un client al serviciului web REST:

Asigurarea că proiectul are adăugate toate bibliotecile necesare.
Identificarea ferestrei GUI și verificarea locului unde rezultatele invocării serviciului web vor fi afișate.
Următoarele informații sunt utile la dezvoltarea clientului: URL-ul serviciului, numele pachetului și clasa în care codul client va fi generat.
Invocarea codului în fereastra GUI.

Vă dorim lectură plăcută și așteptăm cu interes întrebările voastre!