O aplicație client poate accesa resurse distribuite aflate la distanță. Există mai multe modalități de accesare a acestor resurse, dar poate cea mai portabilă este cea a serviciilor web. În acest articol vom aduce în discuție serviciile REST (Representational State Transfer), servicii autodescriptive, moderne, cu un API Java ce are evoluție spectaculoasă în ultimele versiuni ale platformei Java Enterprise.
Vom începe prin discutarea unor aspecte arhitecturale, care țin de înțelegerea componentelor ce fac parte dintr-o aplicație distribuită, ce folosește serviciile web.
Această arhitectură are două componente esențiale:
O aplicație client JavaFX constă din următoarele:
Avantajele folosirii acestei arhitecturi sunt:
Dezavantajele sunt:
Are următoarea structură:
Aplicația pe partea de server de aplicație se descrie astfel:
Așadar, serverul de aplicație va conține o colecție de servicii web RESTful, care la rândul lor vor comunica prin JPA cu serverul de baze de date. Serverul de aplicație Glassfish furnizează infrastructura pentru ambele API-uri JPA și JAX-RS.
Avantajele folosirii unei arhitecturi three tiers:
Dezavantajele sunt:
În pofida dezavantajelor anterior enumerate, arhitectura pe trei nivele este utilizată frecvent pentru aplicații mari. Este cea pe care o vom aduce în discuție în acest articol și în următoarele articole pe această temă.
În partea următoare vom face o scurtă trecere în revistă a paradigmei serviciu web, ca modalitate prin care clarificăm ideile și pentru cei mai puțin familiarizați cu această paradigmă.
Sunt aplicații ce comunică prin HTTP în WWW. Ele furnizează un standard ce facilitează interoperabilitatea aplicațiilor software ce rulează pe o varietate de platforme și framework-uri. Interoperabilitatea și extensibilitatea sunt date de XML. Ele pot fi combinate într-un mod care pierde cuplarea pentru a obține operații complexe.
Prin utilizarea serviciilor web o aplicație pe două nivele poate fi modificată la una pe trei nivele, ce poate opera peste web. Aplicația devine astfel extensibilă și interoperabilă cu diferite tipuri de aplicații client.
Există două tipuri de servicii web:
Vom utiliza serviciile REST pentru integrarea prin web și vom utiliza serviciile SOAP în aplicații enterprise ce au scenarii de integrare care cer calități avansate ale serviciilor (QoS) .
Vom alege JAX-RS pentru că serviciile sunt mai ușor de consumat pentru multe tipuri de clienți, în timp ce permite serverului să evolueze și să se scaleze. Clienții pot alege să consume anumite sau toate aspectele serviciului și să le combine cu alte servicii web.
Aplicațiile REST sunt simple, lightweight și rapide pentru că:
REST indică o arhitectură client server fără stare. Un serviciu REST expune o mulțime de resurse ce identifică destinațiile interacțiunilor cu clienții. Resursele sunt identificate prin URI și sunt manipulate de patru operații: PUT, GET, POST și DELETE.
Resursele sunt decuplate de reprezentare astfel încât pot fi accesate într-o varietate de formate: HTML, XML, plain text, PDF, JPEG și JSON. Metadatele despre resurse sunt folosite pentru a controla cache-ul, a detecta erorile de transmitere, a negocia cel mai potrivit format de reprezentare și pentru autentificare sau controlul accesului.
Orice interacțiune cu o resursă este stateless, mesajul este așadar self contained. Avem la dispoziție mai multe tehnici de a trimite starea precum: rescrierea URI-ului, cookie-uri, câmpuri hidden. Starea poate fi inclusă în mesajul de răspuns pentru a crea stări viitoare ale interacțiunii.
Clienții serviciului web, care doresc să folosească aceste resurse, accesează o anumită reprezentare prin transferarea conținutului aplicației folosind un mic set de metode remote ce descriu acțiunea ce trebuie făcută pe resursă.
În anumite cazuri acțiunile de update sau delete pot fi făcute prin POST, de e-xemplu când serviciul este consumat de browser-e ce nu suportă PUT sau DELETE). Următoarele mapări pot fi aplicabile pentru PUT sau POST:
JAX-RS este un API Java:
Jersey implementează suportul adnotațiilor definit de specificațiile JAX-RS.
O arhivă a aplicației Java EE conținând clasele resursăJAX-RS vor avea resursele configurate, clasele helper și artefactele generate și resursa expusă clienților prin deploy-ul unei arhive pe serverul de aplicație.
Fie următorul exemplu de fișier ce reprezintă codul clasei resursei root a unui serviciu web REST, ce utilizează adnotații JAX-RS:
package com.example.ws;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
@Path("/hello")
public class Hello {
private String name="";
/**
* Default constructor.
*/
public Hello() {
// TODO Auto-generated constructor stub
}
/**
* Retrieves representation of an instance of
* Hello
* @return an instance of String
*/
@GET
@Produces("text/plain")
public String sayHello() {
// TODO return proper representation object
return "Hello World"+name;
}
/**
* PUT method for updating or creating an
* instance of Hello
* @param content representation for the resource
* @return an HTTP response with content of the
* updated or created resource.
*/
@PUT
@Consumes("text/plain")
public void putText(String content) {
name=content;
}
}Adnotațiile utilizate sunt:
@Path este un URI relativ. Clasa Java se va afla, în cazul exemplului nostru, la calea dată de URI-ul /hello. URI-ul este static, dar putem include și variabile în acesta. Template-urile pentru căile URI sunt URI-uri cu variabile incluse în sintaxa URI@GET este destinată metodei cererii, împreună cu @POST, @PUT, @DELETE, @HEAD și este definită de JAX-RS, corespunzând respectiv metodelor similare HTTP. În exemplul nostru , metoda anotată va procesa cererile HTTP GET. Comportamentul unei resurse este determinat de metoda HTTP căreia resursa îi răspunde.@Produces este utilizată pentru a specifica tipul MIME media pe care o resursă îl poate produce și îl trimite clientului. În cazul exemplului tipul este: text/plain.@Consumes este utilizată pentru a specifica tipul MIME pe care o resursă îl poate consuma și care a fost trimis de client.În Eclipse crearea structurii fișierului se face urmând pașii:
Proiectul în care am creat resursa este un Dynamic Web Project
Verificarea serviciului se face la adresa: http://localhost:8080/JerseyFirst/jaxrs/hello
Acest nume este derivat din valoarea tag-ului @Path.
Jersey conține o bibliotecă REST ce poate fi utilizată pentru testarea sau crearea unui client Java.
Vom crea o Aplication Client Project, cu următorul cod:
import java.net.URI;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.UriBuilder;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.api.client.config.ClientConfig;
import com.sun.jersey.api.client.config.DefaultClientConfig;
public class Main {
public static void main(String[] args) {
ClientConfig config = new DefaultClientConfig();
Client client = Client._create_(config);
WebResource service = client.resource(_getBaseURI_());
System._out_.println(service.path("jaxrs").path("hello").accept(MediaType._TEXT_PLAIN_).get(ClientResponse.class).toString());
System._out_.println(service.path("jaxrs").path("hello").accept(MediaType._TEXT_PLAIN_).get(String.class));
}
private static URI getBaseURI() {
return UriBuilder._fromUri_("http://localhost:8080/JerseyFirst/").build();
}
}Arhitectura three-tier folosind REST este dată în diagrama următoare:
Pașii în generarea unui serviciu web REST sunt:
Verificarea următoarelor condiții:
Când testăm un serviciu web trebuie să avem în vedere următoarele:
Pașii de urmat pentru a dezvolta un client al serviciului web REST sunt:
Vom reveni în numerele viitoare ale revistei cu aplicații mai complexe, care să includă și interacțiunea cu o bază de date.
Vă dorim lectură plăcuta și așteptăm cu interes întrebările voastre!
