Servicii Web de tip SOAP în JavaEE6

Web Service ca aplicatie Web

Un serviciu Web (Web Service) este o aplicatie Web de tip client-server, în care un server
furnizor de servicii (numit si "Service Endpoint") este accesibil unor aplicatii client (care nu sunt
de tip browser) pe baza adresei URL a serviciului. Serviciul Web si clientii sãi pot rula pe
platforme diferite si pot fi scrise în limbaje diferite,deoarece se comunicã prin protocoale
standard HTTP, XML, SOAP, JSON, s.a. De aceea principalul merit al serviciilor Web este
acela cã asigurã interoperabilitatea unor aplicatii software implementate pe platforme diferite si
cu instrumente (“framework”-uri) diferite. In acelasi timp aplicatiile sunt slab cuplate (“loosely
coupled”), în sensul cã mesajele schimbate sunt standard (“self-contained”) si oricare dintre
aplicatii nu presupune existenta la celãlalt capãt a altor facilitãti decât cele continute în
standarde.
Furnizorul de servicii expune un API pe Internet, adicã o serie de metode ce pot fi apelate de
clienti. Aplicatia client trebuie sã cunoascã adresa URL a furnizorului de servicii si metodele prin
care are acces la serviciul oferit (nume, parametri, rezultat). Interfata API este limitatã la câteva
operatii în cazul serviciilor de tip REST si nelimitatã ca numãr si ca diversitate a operatiilor în
cazul serviciilor de tip SOAP.
Diferenta dintre o aplicatie Web clasicã si un serviciu Web constã în principal în formatul
documentelor primite de client si a modului cum sunt ele folosite : într-o aplicatie Web clientul
primeste documente HTML transformate de un browser în pagini afisate, iar clientul unui
serviciu Web primeste un document XML (sau JSON) folosit de aplicatia client, dar care nu se
afiseazã direct pe ecran (decât în anumite programe de verificare a serviciilor Web).
Pentru comparatie vom folosi exemplul unui client care foloseste un browser pentru a intra
pe un site ca sã afle rata de schimb între douã valute , dar o aplicatie de comert electronic va
apela un serviciu Web cu rate de schimb pentru a calcula si comunica clientilor suma de plata în
valuta localã.
Din punct de vedere al tehnologiilor folosite existã douã tipuri de servicii Web:
- Servicii de tip REST ( RESTful Web Services), în care cererile de la client se exprimã prin
comenzi HTTP (GET, PUT, POST,DELETE), iar rãspunsurile sunt primite ca documente XML
sau JSON;
CXF (fost XFire) (Apache)
Metro (Sun) pentru servicii SOAP
Axis (Apache)
Jersey (Sun) pentru servicii REST
SoapUI este cel mai cunoscut instrument pentru simularea unui client de servicii Web (prin
afisarea cererilor client si rãspunsurilor primite), pentru testarea si dezvoltarea de servicii SOAP
si REST.
Site-ul Xmethod.com contine o lista de servicii Web (de tip SOAP) publice si gratuite, cu
adresele descrierilor WSDL, care pot fi folosite în SoapUI pentru exersarea metodelor oferite.

Servicii Web de tip SOAP

Probleme de implementare a serviciilor Web de tip SOAP

- Un soft din masina client transformã apelul si parametrii sãi într-un sir de octeti, deci face o
serializare a acelui apel (care poate necesita si serializarea parametrilor de un tip clasã);
- Un alt soft din masina client (numit si “proxy” sau “stub”) transmite sirul de octeti rezultat din
serializare cãtre masina server, folosind protocolul standard HTTP;
- Un soft din masina server (numit si “ties”) receptioneazã apelul serializat;
- Un alt soft din masina server transformã sirul de octeti într-un apel efectiv de metodã
Rezultatul apelului este si el serializat si trece prin aceleasi faze ca si apelul metodei.
Serviciile Web de tip SOAP folosesc pentru serializare fisiere text bazate pe XML.

1
 In plus, existã si problema modului în care un client aflã ce metode sunt disponibile în
serviciul oferit si detaliile de apelare pentru aceste metode. Solutia (partialã) a acestei probleme
este un descriptor al serviciului Web aflat pe server si care poate fi citit de client. In cazul
serviciilor SOAP acesta este tot un document XML numit WSDL (Web Service Description
Language) si care poate fi obtinut de clienti de la o adresã publicã URL.
S-a propus existenta unor registre publice care sã centralizeze toate adresele URL de
servicii web disponibile (unde se aflã wsdl-ul serviciului) si chiar s-a standardizat modul de
acces si de publicare în aceste registre UDDI (Universal Description, Discovery and Integration)
dar momentan nu existã astfel de registre.
Standardul WS-I Basic Profile 1.1 (Web Services- Interoperability) specificã cerintele impuse
implementãrilor de servicii Web pentru a asigura interoperabilitatea lor. Printre aceste cerinte
este si formatul fisierelor WSDL care descriu serviciile.
JAX-WS 2.0 este cea mai recentã încercare de unificare (de standardizare) a implementãrii
serviciilor Web bazate pe SOAP si este incorporatã în produse ca Metro (Sun), Axis2 (Apache),
CXF (Apache) s.a. JAX-WS standardizeazã adnotãri Java utilizate în scrierea codului pentru
serviciu si pentru clienti, precum si artefacte portabile. Prin “artefacte” se înteleg fisierele Java si
XML necesare pentru implementarea unui serviciu Web si care sunt asamblate într-o arhivã
instalatã (”deployed”) pe server.
Serviciile JAX-WS pot fi de douã feluri:
- Orientate pe mesaje (“message-oriented”);
- Orientate RPC (cu apeluri de proceduri)
Furnizorul de servicii (“Service Endpoint”) expune o interfatã cu serviciile oferite clientilor,
sub forma unei interfete Java (SEI=Service Endpoint Interface) si a unor clase care
implementeazã aceastã interfatã. In plus, este creat de obicei si un fisier WSDL care descrie
operatiile oferite de SEI, fisier folosit de clienti pentru a genera cereri la serviciile oferite. Fisierul
WSDL este o modalitate de transmitere a interfetei SEI cãtre aplicatii client.
Mai nou, aceste componente se numesc JAX-WS run-time si fac parte din “artefactele” care
trebuie generate in procesul de implementare al unui serviciu Web si al unui client pentru acest
serviciu:

Client  WS run-time  SOAP Message  WS run-time  Service

O versiune mai completã pentru secventa de la client la furnizorul de servicii aratã astfel:

Client  Handler  Transport Sender  SOAP  Transport Listener  Handler  Service

Interceptorii (numiti si “Handlers”) prelucreazã de obicei partea de antet din mesajele SOAP si
pot asigura diverse functii, cum ar fi securitatea transmiterii mesajelor.
Implementarea protocolului SOAP la server si la client presupune trecerea între clase Java si
documente XML, în ambele sensuri. In acest scop se folosesc mai multe solutii, dintre care
parsere de documente XML de tip STAX, DOM s.a. si, mai recent, JAXB (Java API for XML
Binding), folositã de JAX-WS.
JAXB transformã documente XML în obiecte Java si invers folosind schema ce descrie
documentul XML.
Utilitarul “xjc” este un compilator de schemã XML care produce fabrici de obiecte Java
(Object Factories), iar utilitarul “schemagen” genereazã schema XML din clase Java adnotate.
Componenta run-time JAXB produce documente XML din obiecte JAXB (operatie numitã
“marshalling”) si genereazã obiecte JAXB din documente XML (operatia de “unmarshalling”).
2
 Protocolul SOAP

SOAP message
     SOAP part
         SOAP envelope
               SOAP header (optional)
Header
Header
               SOAP body
XMLContent
SOAP Fault

Fiecare din pãrtile atasate contine o parte de antete MIME si o parte de continut (XML sau
non-XML):

Attachement Part
MIME Headers
Content

Fisierele atasate pot fi imagini sau alte tipuri de fisiere transmise împreunã cu cereri cãtre
servicii Web (in SOAP 1.2).
Existã un API Java, numit SAAJ (SOAP with Attachements API for Java), care permite
crearea (producerea) si folosirea (consumarea) de mesaje SOAP. Este un API de nivel coborât,
care este folosit de JAX-WS API, dar poate fi folosit si direct (existã exemple de utilizare în
JEE5 Tutorial).

WSDL ca limbaj pentru descrierea de servicii Web

WSDL foloseste urmãtoarele elemente (taguri) pentru descrierea unui serviciu Web:

<types> Tipuri de date folosite de serviciul Web

<message> Mesaje folosite de serviciul Web
<portType> Operatii realizate de serviciul Web
<binding> Protocoale de comunicatii folosite de serviciul Web

Orice document WSDL are structura urmãtoare:

<definitions>
<types>
  definition of types........
</types>
<message>
  definition of a message....
</message>
<portType>
  definition of a port.......
</portType>
<binding>
  definition of a binding....
</binding>
</definitions>

Fragment dintr-un document WSDL simplificat:

<message name="getTermRequest">
  <part name="term" type="xs:string"/>
3
</message>
<message name="getTermResponse">
  <part name="value" type="xs:string"/>
</message>
<portType name="glossaryTerms">
  <operation name="getTerm">
    <input message="getTermRequest"/>
    <output message="getTermResponse"/>
  </operation>
</portType>

Marcajele <operation> corespund numelor de metode oferite de serviciul Web.

Marcajul <binding> defineste formatul mesajelor si protocolul folosit. Marcajul <soap:binding>
are douã atribute: stil si transport; stilul poate fi “rpc” sau “document”, iar transportul este de
obicei HTTP. Exemplu:

<binding type="glossaryTerms" name="b1">

   <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
   <operation>
     <soap:operation soapAction="http://example.com/getTerm"/>
     <input><soap:body use="literal"/></input>
     <output><soap:body use="literal"/></output>
  </operation>
</binding>

Un exemplu complet de WSDL pentru un serviciu cu o singurã metodã (“sayHello”):

<definitions name="HelloService"
targetNamespace="http://www.examples.com/wsdl/HelloService.wsdl"
xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:tns="http://www.examples.com/wsdl/HelloService.wsdl"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">

<message name="SayHelloRequest">
<part name="firstName" type="xsd:string"/>
</message>
<message name="SayHelloResponse">
<part name="greeting" type="xsd:string"/>
</message>

<portType name="Hello_PortType">
<operation name="sayHello">
<input message="tns:SayHelloRequest"/>
<output message="tns:SayHelloResponse"/>
</operation>
</portType>

<binding name="Hello_Binding" type="tns:Hello_PortType">

<soap:binding style="rpc"
transport="http://schemas.xmlsoap.org/soap/http"/>
<operation name="sayHello">
<soap:operation soapAction="sayHello"/>
<input>
<soap:body
encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
namespace="urn:examples:helloservice"
use="encoded"/>
</input>
<output>
4
 <soap:body
encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
namespace="urn:examples:helloservice"
use="encoded"/>
</output>
</operation>
</binding>
<service name="Hello_Service">
<documentation>WSDL File for HelloService</documentation>
<port binding="tns:Hello_Binding" name="Hello_Port">
<soap:address
location="http://www.examples.com/SayHello/">
</port>
</service>
</definitions>

Observatii:

package helloservice.endpoint;
import javax.jws.WebService;
import javax.jws.webMethod;
@WebService
public class Hello {
private String message=newString("Hello, ");
public void Hello() { }
@WebMethod
public String sayHello (String name){
return message+name+ ".";
}
}

Programarea unui client pentru serviciul anterior necesitã urmãtoarele operatii:

- Utilizarea clasei generate “helloservice.endpoint.HelloService”, pentru care adnotarea
@WebServiceRef injecteazã un obiect si pune adresa lui în variabila “service”:
@WebServiceRef(wsdlLocation="META-INF/wsdl/localhost_8080/helloservice/HelloService.wsdl")
privatestaticHelloServiceservice;
- Obtinerea unei clase Proxy a serviciului (un “port”) prin metoda “getHelloPort”, clasã care
implementeazã interfata SEI a serviciului:
helloservice.endpoint.Helloport=service.getHelloPort();
- Apelul metodelor din interfata SEI prin obiectul proxy:
String result=port.seyHello (“world”);

package appclient;
import helloservice.endpoint.HelloService;
import javax.xml.ws.WebServiceRef;
public class HelloAppClient {
@WebServiceRef(wsdlLocation=
"META-INF/wsdl/localhost_8080/helloservice/HelloService.wsdl")
private static HelloService service;

public static void main(String[] args) {

System.out.println(sayHello(args[0]));
}
private static String sayHello (arg){
helloservice.endpoint.Helloport=service.getHelloPort();
return port.sayHello(arg);
}
5
}

Exemplu de client Web al unui serviciu Web, sub forma unui servlet:

@WebServlet(name="HelloServlet",urlPatterns={"/HelloServlet"})
public class HelloServlet extendsHttpServlet {
@WebServiceRef(wsdlLocation= "WEB-INF/wsdl/localhost_8080/helloservice/HelloService.wsdl")
private HelloService service;
protected void processRequest (HttpServletRequestrequest, HttpServletResponseresponse)
throwsServletException,IOException{
response.setContentType("text/html;charset=UTF-8");
PrintWriterout=response.getWriter();
try {
out.println("<html>"); out.println("<body>");
out.println("<h1>ServletHelloServletat " + request.getContextPath()+ "</h1>");
out.println("<p>" +sayHello("world")+ "</p>");
out.println("</body>"); out.println("</html>");
} finally { out.close(); }
}
//doGet and doPost methods,which call processRequest,and getServletInfo method
private String sayHello(String arg) {
helloservice.endpoint.Helloport=service.getHelloPort();
return port.sayHello(arg);
}
}

WS* ca etapã superioarã de dezvoltare a serviciilor Web

WS* completeazã specificatiile pentru servicii Web SOAP cu urmãtoarele specificatii:

- WS Addressing
- WS Policy
- WS Security
- WS Optimization
- WS Reliable Messaging

Firma Sun a lucrat împreunã cu firma Microsoft pentru implementarea acestor specificatii cu
pãstrarea interoperabilitãtii dintre serviciile Web realizate cu Metro si respectiv cu .NET3.5
(WCF= Windows Communication Foundation), într-un proiect numit WSIT (Web Service
Interoperability Technology). Compatibilitate înseamnã cã un client Metro poate accesa si poate
“consuma” servicii oferite de un furnizor WCF si un client WCF poate folosi servicii WCF.

6
BIBLIOGRAFIE:

Sun : JEE6 Tutorial

Apache : JAX-WS Guide (Axis2 Doc)
Sun : Documentatie Metro
SOApUI UserGuide