Java Web Services

Facoltà di Ingegneria - Università degli studi di Catania
Dipartimento di Ingegneria Informatica e delle Telecomunicazioni
Java Web Services
Giovanni Morana
Agenda
Web Services
Service Oriented Architecture – SOA
XML (cenni)
Simple Object Access Protocol - SOAP
Web Services Description Language -WSDL
Universal Description, Discovery and Integration – UDDI (cenni)
Busine Proces Execution Language for WS - BPEL4WS
Sun Java WS API
J2EE
J5EE
Glassfish and METRO project
Apache AXIS
Architettura
Deploy dei servizi
Invocazione dei servizi
Java Web Services
Service-Oriented Architecture
In computing, the term service-oriented architecture expresses a
perspective of software architecture that defines the use of loosely
coupled software services to support the requirements of the
business processes and software users. In an SOA environment,
resources on a network are made available as independent
services that can be accessed without knowledge of their
underlying platform implementation.
“Migrating to a service-oriented architecture”, IBM DeveloperWorks
Java Web Services
SOA: caratteristiche base
Interfacce indipendenti dall’implementazione
ogni servizio deve essere descritto in maniera indipendente dal linguaggio e dalla
piattaforma utilizzati per la sua realizzazione
Reperibilità e binding dinamico
un servizio deve poter essere ricercato tramite gli elementi dell’interfaccia esposta
e richiamato a run time
Accessibilità da rete
garantisce la trasparenza rispetto alla locazione
Java Web Services
SOA: caratteristiche base
Loosely coupled services
servizi debolmente accoppiati garantiscono semplicità di gestione
Aggragabilità
più servizi possono essere composti per portare a termine un particolare task
Gestione dei Fault
ogni servizio dovrebbe essere in grado di rilevare eventuali errori e notificarli e/o
intraprendere azioni correttive
Java Web Services
SOA: attori
Service Provider
rende disponibile il servizio, ne espone l’interfaccia e la pubblica su
uno specifico registry
Service Requestor/Consumer
utilizza il servizio tramite l’interfaccia esposta dal provider, ottenuta
tramite queries ad un service registry
Service Registry/Broker,
colleziona le informazioni relative ai servizi/provider e le mette a
disposizione dei requestor/consumer
Java Web Services
SOA: funzionalità
Descrizione del servizio
illustra le “operazioni” che il servizio puo’ svolgere, le inquadra in
specifici end-point e fornisce le modalità per l’accesso
Ricerca del servizio
meccanismo per la pubblicazione e la ricerca delle informazioni.
Scambio di messaggi
protocollo per la codifica ed il trasporto dei dati
Java Web Services
SOA
REGISTRY
CONSUMER
PROVIDER
Java Web Services
Web Services
Secondo la definizione del W3C:
Web Services are a software applications identified by a URI, whose
interface and bindings are capable of being identified, described and
discovered by XML artifacts and supports direct interactions with other
software applications using XML based messages via Internet-based
protocols”
Costituiscono una particolare incarnazione SOA di cui mantengono le
principali proprietà
Java Web Services
WS: tecnologie di base
XML (eXtensible Markup Language)
Utilizzato per la definizione delle interfacce e la codifica
dei messaggi
SOAP (Simple Object Access Protocol)
Protocollo utilizzato per lo scambio di messaggi
WSDL (Web Service Description Language)
Utilizzato per la descrizione formale delle interfacce WS
UDDI (Universal Description Discovery and Integration)
Registry utilizzato per la registrazione, catalogazione e
ricerca dei WS
BPEL (Business Process Execution Language)
Linguaggio per la descrizione di interazioni tra ws multipli
Java Web Services
WS: tecnologie di base
REGISTRY
UDDI
SO
AP
AP
SO
WSDL
CONSUMER
PROVIDER
SOAP
Java Web Services
XML
L’eXtensible Markup Language è un metalinguaggio che
permette di definire informazioni di tipo strutturale e
semantico.
Descrive le interfacce dei WS, ne codifica i messaggi e
determina la validità dei dati. SOAP, WSDL, UDDI e
BPEL sono XML-based
E’ in formato testuale:
-garantisce l’interoperabilità tra piattaforma eterogenee
-necessità di un parser per l’interpretazione di tag non
standard che ne inficia le prestazioni
Java Web Services
XML
Intestazione standard
<?xml version="1.0"?>
Definizione di componente strutturato
<dottorando>
<nome>Giovanni</nome>
<cognome>Morana</cognome>
<indirizzo_email> [email protected] </indirizzo_email>
</dottorando>
Definizione di componente composto
<Lista XXI ciclo>
<dottorando>
<nome>Giovanni</nome>
<cognome>Morana</cognome>
<indirizzo_email> [email protected] </indirizzo_email>
</dottorando>
<dottorando>
<nome>Daniele</nome>
<cognome>Zito</cognome>
<indirizzo_email> [email protected] </indirizzo_email>
</dottorando>
</Lista XXI ciclo>
Java Web Services
XML
Permette all'utente di definire TAG specifici per il contesto
applicativo.
I TAG utente vengono definiti in documenti detti DTD
I DTD sono utilizzati per garantire che ogni entità in gioco
abbia una rappresentazione coerente della struttura del
documento analizzato.
L'utilizzo rigoroso dei TAG permette di
definire se un documento è well formed
definire se un documento è valido
Java Web Services
XML: XML Schema & namespaces
XML Schema
E’ una collezione di elementi definiti in XML che definisce
la grammatica di un documento XML specificando i tag
utilizzati, gli attributi e i valori associabili ai tag e le
relazioni tra tag diversi.
XML Namespace
Permette l’utilizzo contemporaneo di più XML Schema
nello stesso documento risolvendo a priori qualsiasi
problema di collisione dovuto a elementi omonimi.
Java Web Services
SOAP
Simple Object Access Protocol è un protocollo di
comunicazione basato sullo scambio di messaggi
unidirezionale e stateless utilizzato per l’integrazione di
sistemi distribuiti eterogenei.
Si fonda su tecnologie molto diffuse quali HTTP, SMTP,
FTP per il trasporto e XML per la codifica dei dati.
SOAP è molto potente ed è uno strumento fondamentale
per lo sviluppo dei WS ma può essere utilizzato stand
alone per lo scambio di messaggi (JAXM)
SOAP 1.2 [raccomandazione W3C]
Java Web Services
SOAP: specifiche
Le specifiche SOAP stabiliscono:
z
Come XML deve essere codificato per rappresentare
il contenuto del singolo messaggio
z
Come HTTP e SMTP possono utilizzare messaggi
SOAP per comunicare
z
Come due messaggi devono essere combinati per
ottenere uno scambio di tipo request-replay
z
Le regole necessarie al “ricevente” per il
processamento del contenuto XML del messaggio
Java Web Services
SOAP: specifiche
z
Remote Procedure Call. I WS possono essere invocati
come chiamata a procedura remota. Il messaggio
associato contiene informazioni relative al nome e ai
parametri della procedura. Utilizzato per applicazioni
sincrone. Richiesta e risposta sono realizzati tramite lo
scambio di due messaggi distinti
z
Document Oriented. Il messaggio trasporta un insieme
di dati codificati in XML che vanno processati come
parte di un unico “documento”. Usato per messaggi
asincroni di notifica.
Java Web Services
SOAP: message
SOAP envelope
SOAP body
SOAP header block
SOAP body block
SOAP header block
SOAP body block
SOAP fault
SOAP header
envelope:identifica il documento XML come un messaggio soap
header (?): contiene informazioni specifiche per l’applicazione a cui
viene destinato
body: contiene tutte le informazioni scambiate
fault (?): gestisce eventuali errori in fase di decodifica del
messaggio
Nessun collegamento a DTD/Nessuna istruzione di processamento XML
Elementi definiti nel namespace XML “soap-envelope” del W3C.
Java Web Services
SOAP: message
envelope
header
body
fault
<SOAP-ENV:Envelope
xmlns:SOAP-ENV=“http://schemas.xmlsoap.org/soap/envelope/”
xmlns:xsi=“http://www.w3.org/1999/XMLSchema-instance”
xmlns:xsd=“http://www.w3.org/1999/XMLSchema”>
<SOAP-ENV:Header>
</SOAP-ENV:Header>
<SOAP-ENV:Body>
<m:MetodoXY-Z xmlns:m=“provider:servizio”
SOAP-ENV:encodingStyle=“http://schemas.xmlsoap.org/soap/encoding/”>
<Param1>X</Param1>
<Param2>Y</Param2>
</m:nomeMetodo>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Java Web Services
SOAP: elemento header
z
E’ opzionale
z
Contiene informazioni utili alla gestione del
messaggio: sicurezza, gestione di credenziali,
routing, identificativi di transazioni
z
Permette al messaggio di essere riconosciuto senza
che sia necessario la lettura del contenuto.
Può
contenere
SOAP-ENV:MustUnderstand,
elemento booleano che impone al ricevente di
generare un errore nel caso non sia in grado di
interpretare uno specifico elemento
<xs: elemento SOAP-ENV: MustUnderstand=“true”>
z
Java Web Services
SOAP: elemento body
Contiene il messaggio “vero e proprio”
Poiché le specifiche SOAP definiscono per body il solo
elemento figlio fault, è necessario definire un
namespace al suo interno.
Solitamente tale namespace è associato al file wsdl del
web service invocato in quanto gli elementi definiti
all’interno di body sono quelli contenuti nel wsdl.
Può contenere una richiesta, una risposta o l’indicazione
di errore
Può contenere un insieme di body block e un solo body
fault
Java Web Services
SOAP: elemento body
public class Prova {public int MetodoXY-Z(int X, int Y){return Z=f(X;Y);}}
<SOAP-ENV:Body>
<m:MetodoXY-Z xmlns:m=“provider:Prova”
SOAP-ENV:encodingStyle=“http://..soapencoding”>
<Param1>X</Param1>
<Param2>Y</Param2>
</m:MetodoXY-Z>
</SOAP-ENV:Body>
Java Web Services
SOAP: elemento <fault>
z
E’ opzionale
z
Viene utilizzato per notificare errori
<fault>
<faultcode>
<faultstring>
<faultactor>
<details>
<faultcode> (namespace qualified) contiene indicazione di errori
interpretabili automaticamente dagli algoritmi.
(<faultstring> contiene le stesse informazioni in formato “umano”)
<faultactor> identifica il nodo che ha generato l’errore (URI)
<details> contiene informazioni dettagliate sugli errori generati
durante il processamento dei blocchi body
Java Web Services
SOAP: invio messaggio su HTTP
POST /MyApplication HTTP/1.1
Host: www.provider.net
Content-Type: text/xml text/xml; charset=“utf-8”
SOAPAction: “urn:provider:Prova#Metodo”
<SOAP-ENV:Envelope
<SOAP-ENV:Header>
…
</SOAP-ENV:Header>
<SOAP-ENV:Body>
<m:MetodoXY-Z xmlns:m=“provider:Prova”
SOAP-ENV:encodingStyle=“http://...soapencoding/”>
<Param1>X</Param1>
<Param2>Y</Param2>
</m:MetodoXY-Z>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
SOAPAction è l’elemento di congiunzione.
Java Web Services
WSDL
Web Services Description Language è un linguaggio
XML-based utilizzato per descrivere un servizio e le
modalità per accedere ad esso.
(what) Descrizione servizio. Descrive le funzionalità e
il tipo di servizio offerto.
(how) Binding concreto. Descrive come viene
realizzato il collegamento dell’interfaccia con i
protocolli concreti
(where) Implementazione. Descrive attraverso quale
porta si realizza il binding. Porta = punto di accesso
Java Web Services
WSDL: elementi principali
<types>
definizione dei tipi di dato utilizzati
<message>
definizione/descrizione dei messaggi usati nella comunicazione
<portType>
definisce le operazioni che il ws può eseguire e i messaggi coinvolti
in queste operazioni
<binding>
definisce il formato del messaggio e i dettagli di protocollo per ogni
PortType definito
<operation>
descrizione delle singole operazioni supportate dal ws
<service>
collezione di end-point associate ai portType
<port>
singolo end-point espresso come coppia binding-indirizzo di rete
Java Web Services
WSDL: elementi principali
WSDL
types
messages
portType
operation
binding
operation
service
port
Java Web Services
WSDL: elementi principali
WSDL
types
messages
portType
operation
binding
operation
service
port
what?
Java Web Services
WSDL: elementi principali
WSDL
types
type
messages
portType
operation
binding
operation
service
port
what?
how?
Java Web Services
WSDL: elementi principali
WSDL
types
messages
portType
operation
binding
operation
service
port
what?
how?
where?
Java Web Services
WSDL: elementi principali
WSDL
types
messages
portType
operation
descrizione astratta
binding
operation
service
port
descrizione concreta
Java Web Services
WSDL: <types>
All’interno del tag <types> vengono definiti tutti i tipi di
dato coinvolti nelle operazioni esposte dal ws.
Per facilitare le definizioni ed essere platform independent,
WSDL utilizza l’XML Schema syntax
Java Web Services
WSDL : <message>
Definisce i messaggi scambiati tra ws e cliente.
<wsdl:message name=“Metodo1Request">
<wsdl:part name="x" type="xsd:int"/>
</wsdl:message>
<wsdl:message name=“Metodo1Response">
<wsdl:part name=“valRitorno" type="xsd:int"/>
</wsdl:message>
Il tag <part> descrive il nome ed il tipo di variabili utilizzati
dallo specifico messaggio (parametri funzione).
Poiché ogni messaggio è una composizione dei tipi definiti in
<types> ,e’ necessario che ogni variabile descritta in part sia
specificata all’interno di <types>
Java Web Services
WSDL : <portType>
E’ l’elemento più importante perché definisce:
-le operazioni disponibili
-i messaggi coinvolti nelle singole operazioni
Concettualmente simile ai file .h (header) in C.
<wsdl:portType name=“servClass">
<wsdl:operation name=“Metodo1" />
<wsdl:input message="impl:Metodo1Request" name=“Metodo1Request"/>
<wsdl:output message="impl:Metodo1Response" name="Metodo1Response"/>
</wsdl:operation>
</wsdl:portType>
Java Web Services
WSDL : <portType>
Il WSDL permette quattro tipi di operazioni:
One-way:
il servizio riceve un messaggio ma
non prevede l’invio di una risposta.
Request- Response:
il servizio riceve una richiesta a cui
risponde con un messaggio di risposta
Sollicit- Response:
Il servizio invia un messaggio e
attende una risposta
Notification:
il servizio invia un messaggio ma
non attende messaggi di risposta
Ogni operazioni può essere costituita da un messagio di input
(one-way) di output (notification) o da entrambi: in quest’ultimo
caso è possibile specificare un ulteriore massaggio di fault
Java Web Services
WSDL : <Binding>
Lega la descrizione del WS (portType) con il protocollo SOAP, definendo,
per ogni operazione, lo stile e il protocollo utilizzato per la fruizione del
servizio.
<wsdl:binding name=“servClassSoapBinding" type="impl:servClass">
<wsdlsoap:binding style="rpc"
transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name=“Metodo1">
<wsdlsoap:operation soapAction=""/>
<wsdl:input name="PariRequest">
<wsdlsoap:body encodingStyle="http://… /soap/encoding/"
namespace="http://DefaultNamespace" use="encoded"/>
</wsdl:input>
<wsdl:output name="PariResponse">
<wsdlsoap:body encodingStyle="http://… /soap/encoding/"
namespace="http://localhost:8080/axis/service.jws"
use="encoded"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
Java Web Services
WSDL : <Binding>
Lega la descrizione del WS (portType) con il protocollo SOAP, definendo,
per ogni operazione, lo stile e il protocollo utilizzato per la fruizione del
servizio.
<wsdl:binding name=“servClassSoapBinding" type="impl:servClass">
<wsdlsoap:binding style="rpc"
transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name=“Metodo1">
<wsdlsoap:operation soapAction=""/>
<wsdl:input name="PariRequest">
<wsdlsoap:body encodingStyle="http://… /soap/encoding/"
namespace="http://DefaultNamespace" use="encoded"/>
</wsdl:input>
<wsdl:output name="PariResponse">
<wsdlsoap:body encodingStyle="http://… /soap/encoding/"
namespace="http://localhost:8080/axis/service.jws"
use="encoded"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
Java Web Services
WSDL : <Binding>
Lega la descrizione del WS (portType) con il protocollo SOAP, definendo,
per ogni operazione, lo stile e il protocollo utilizzato per la fruizione del
servizio.
<wsdl:binding name=“servClassSoapBinding" type="impl:servClass">
<wsdlsoap:binding style="rpc"
transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name=“Metodo1">
<wsdlsoap:operation soapAction=""/>
<wsdl:input name=“Metodo1Request">
<wsdlsoap:body encodingStyle="http://… /soap/encoding/"
namespace="http://DefaultNamespace" use="encoded"/>
</wsdl:input>
<wsdl:output name=“Metodo1Response">
<wsdlsoap:body encodingStyle="http://… /soap/encoding/"
namespace="http://localhost:8080/axis/service.jws"
use="encoded"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
Java Web Services
WSDL : <services> & <port>
Descrive i dettagli relativi alle relazioni tra
servizio : end points : locazione
<wsdl:service name=“ProvaService">
<wsdl:port binding="impl:ProvaSoapBinding" name=“MetodoXY-Z">
<wsdlsoap:address location="http://localhost:8080/axis/Prova.jws"/>
</wsdl:port>
</wsdl:service>
Java Web Services
UDDI
L’UDDI (Universal Description, Discovery and Integration) è un
registry XML based su cui è possibile la pubblicazione (server), la
ricerca e l’interrogazione (client) di Web Services.
- Gestisce i dati contenuti nel WSDL dei diversi servizi
- Interagisce con provider/requestor attraverso messaggi SOAP
White pages: fornisce informazioni relative ai provider
Yellow pages: fornisce una catalogazione basata su caratteristiche
specifiche dei servizi
Green pages: fornisce informazioni tecniche sui servizi offerti
dallo specifico provider
Java Web Services
UDDI
Informazioni gestite dall’UDDI
BusinessEntity
Informazioni non tecniche relative al provider. Utilizzata dai servizi
white pages
BusinessService
Informazioni non tecniche relative ai servizi implementati da un
daterminato provider. Contiene il nome del servizio, la
descrizione e un
eventuale costo. Utilizzato dai servizi yellow pages
BindingTemplate
Mantiene associazioni Service-tModel, fornendo informazioni su
come accedere ad un servizio con un determinato tModel (green pages)
tModel (technical Model)
Contiene le informazioni tecniche, come il wsdl del servizio
associato (green pages)
Java Web Services
BPEL
Business Process Execution Language
Nasce da OASIS nel 2003 dalla standardizzazione di un linguaggio
nato dall'integrazione delle ricerche svolte da IBM (WSFL) e
Microsoft (XLANG)
E' un linguaggio utilizzato per la descrizione formale dei compiti
assolti dai componenti costitutivi di processi distribuiti.
BPEL un linguaggio XML-based che supporta tutte le tecnologie
dello stack WS quali SOAP, WSDL, UDDI, WS-Reliable
Messaging, WS-Addressing, WS-Coordination e WS-Transaction.
Utilizzato nelle applicazioni tipo “programming in the large”
Nei sistemi WS based, tale standard prende il nome di BPEL4WS o
WSBPEL
Java Web Services
BPEL
Il BPEL è un linguaggio per il WS Orchestration.
WS – Orchestration
Viene utilizzato per l'implementazione di procedure di
esecuzione di processi distribuiti .
Definisce la sequenza delle operazioni.
WS – Choreography
Viene utilizzato per la specifica della sequenza di messaggi
scambiati per l'esecuzione di processi distribuiti.
Definisce il protocollo.
Java Web Services
BPEL
Il BPEL specifica l'ordine esatto con cui i WS che partecipano al
processo coordinato devono essere invocati.
Ogni processo può contenere variabili, cicli, istruzioni condizionali e
meccanismi per la gestione dei fault.
Combinando tutti questi costrutti è possibile definire un processo
quanto si voglia complesso in modo simile a quello che avviene nella
costruzione di algoritmi nei linguaggi di programmazione tradizionali
Un tipico Processo BPEL consiste in un messaggio di request mandato
dal client dell'intero processo al sistema di coordinamento. Il sistema si
occupa di invocare in modo trasparente all'utente tutti i WS coinvolti e
restituire il valore dell'intero processo di elaborazione
Java Web Services
BPEL
Ogni processo BPEL è diviso in step. Ogni step è detto “attività”.
Basic activity: attività semplice composta da una singola istruzione
<invoke> invocazione WS
<receive> attesa di uuna request da un WS client
<reply> risposta per processi sincroni
<throw> permette di gestire eccezioni
<assign> manipolazione variabili
Structured Activity: permette di combinare più attività semplici per la
risoluzione di compiti complessi.
<sequence> permette l'esecuzione in sequenza delle attività elencate
<flow> permette l'esecuzione in parallelo delle attività elencate
<switch> esecuzioni sottoposte a condizioni
<while> gestione dei cicli
<pick> permette di poter selezionare differenti path di esecuzione
Java Web Services
BPEL
Variabili
<variables>
Permettono di trasformare i WS stateless in statefull.
Memorizzano lo stato dei valori scambiati ra i vari WS
coinvolti nel processo distribuito.
Partner Links
<partnerLinks>
Rappresentano le entità con cui ogni componente del
processo interagisce.
Java Web Services
BPEL : esempio
<?xml version="1.0" encoding="utf-8"?>
<process name="insuranceSelectionProcess"
targetNamespace="http://packtpub.com/bpel/example/"
xmlns="http://schemas.xmlsoap.org/ws/2003/03/business-process/"
xmlns:ins="http://packtpub.com/bpel/insurance/"
xmlns:com="http://packtpub.com/bpel/company/" >
<partnerLinks>
<partnerLink name="client"
partnerLinkType="com:selectionLT"
myRole="insuranceSelectionService"/>
<partnerLink name="insuranceA"
partnerLinkType="ins:insuranceLT"
myRole="insuranceRequester"
partnerRole="insuranceService"/>
<partnerLink name="insuranceB"
partnerLinkType="ins:insuranceLT"
myRole="insuranceRequester"
partnerRole="insuranceService"/>
</partnerLinks>
...
Java Web Services
BPEL : esempio
...
<variables>

<variable name="InsuranceRequest"
messageType="ins:InsuranceRequestMessage"/>

<variable name="InsuranceAResposne"
messageType="ins:InsuranceResponseMessage"/>

<variable name="InsuranceBResposne"
messageType="ins:InsuranceResponseMessage"/>

<variable name="InsuranceSelectionResponse"
messageType="ins:InsuranceResponseMessage"/>
</variables>
...
Java Web Services
BPEL : esempio
<sequence>

<receive partnerLink="client"
portType="com:InsuranceSelectionPT"
operation="SelectInsurance"
variable="InsuranceRequest"
createInstance="yes" />

<flow>

<invoke partnerLink="insuranceA"
portType="ins:ComputeInsurancePremiumPT"
operation="ComputeInsurancePremium"
inputVariable="InsuranceRequest"
outputVariable="InsuranceAResponse" />

<invoke partnerLink="insuranceB"
portType="ins:ComputeInsurancePremiumPT"
operation="ComputeInsurancePremium"
inputVariable="InsuranceRequest"
outputVariable="InsuranceBResponse" />
</flow>
Java Web Services
BPEL : esempio

<switch>
<case condition="bpws:getVariableData('InsuranceAResponse',
'confirmationData','/confirmationData/Amount')
<= bpws:getVariableData('InsuranceBResposne',
'confirmationData','/confirmationData/Amount')">

<assign>
<copy>
<from variable="InsuranceAResposne" />
<to variable="InsuranceSelectionResponse" />
</copy>
</assign>
</case>
<otherwise>

<assign>
<copy>
<from variable="InsuranceBResposne" />
<to variable="InsuranceSelectionResponse" />
</copy>
</assign>
</otherwise>
</switch>
Java Web Services
BPEL : esempio
<process>
sequence>
...

<reply partnerLink="client"
portType="com:InsuranceSelectionPT"
operation="SelectInsurance"
variable="InsuranceSelectionResponse"/>
</sequence>
</process>
Java Web Services
BPEL
BPEL Engine:
z
Oracle Process Manager
z
IBM Process Choreographer (BPELJ)
z
ActiveBPEL (Open Source)
Java Web Services
Librerie Java Web Services (J2EE)
Copyright 1994-2007
Sun Microsystems, Inc.
Java API for XML-RPC (JAX-RPC)
è un’implementazione RMI-like per RPC over SOAP.
SOAP with Attachments for Java (SAAJ )
permette la manipolazione a basso livello dei messaggi SOAP
Java API for XML Messaging (JAXM )
fornisce alle applicazioni la possibilità di spedire/ricevere messaggi XML di
tipo document oriented (basata su SAAJ)
Java API for XML Registries (JAXR)
fornisce i meccanismi di base per l’accesso e la gestione di registry XML
based
Java API for XML Processing (JAXP)
fornisce gli strumenti necessari al parsing di documenti XML
Contenute nel Java Web Services Developer Pack.
Le API di AXIS 1.4 si basano su queste librerie
Java Web Services
Librerie Java Web Services (J5EE)
Copyright 1994-2007
Sun Microsystems, Inc.
Enterprise Web Services
Direttive per il modello di programmazione e l'architettura a runtime per
l'implementazione dei web services in Java.
Java API for XML-Based Web Services (JAX-WS)
Diventa la libreria di riferimento per l'implementazione dello stack per i Web services.
Integrated stack: include JAX-WS 2.0, JAXB 2.0 e SAAJ 1.3. Permette di
implementare tutte le funzionalità Java per la gestione dei WS all'interno del WSDP.
JAX-WS prende il posto di JAX-RPC.
Java Architecture for XML Binding (JAXB)
viene utilizzata per effettuare il binding tra oggetti specificati negli XML schema e
codice Java. Permette di incorporare dati XML in applicazioni Java senza che sia
necessario conoscere il linguaggio XML.
Streaming API for XML (StAX)
permette di implementare parser per la gestione in lettura e scrittura di documenti XML
Web Services Metadata for the Java Platform
definisce “annotazioni” standard per la creazione di web services all'interno dei
container Java EE. Utilizza Java Language Metadata .
Java Web Services
Java e Web Services - METRO
Copyright 1994-2007
Sun Microsystems, Inc.
Transition to GlassFish:
The Java WSDP is being superseded by Project GlassFish and its open-source Java EE
5-compatible application server. You can gain access to all of the latest versions of the
Java WSDP's technology components at Project GlassFish with the added benefit of
community-based visual development. Technology acquired through Project GlassFish
has the additional benefit of clearer, less restrictive licensing.
Web services are Web based applications that use open, XML-based standards and
transport protocols to exchange data with clients. Web services are developed using
Java Technology APIs and tools provided by an integrated Web Services Stack called
Metro. The Metro stack consisting of JAX-WS, JAXB, and WSIT, enable you to create
and deploy secure, reliable, transactional, interoperable Web services and clients. The
Metro stack is part of Project Metro and as part of GlassFish, Java Platform, Enterprise
Edition (Java EE), and partially in Java PlatForm, Standard Edition (Java SE).
GlassFish and Java EE also support the legacy JAX-RPC APIs.
Java Web Services
Librerie Java Web Services (METRO)
Info from https://metro.dev.java.net/discover/
Copyright 1994-2007
Sun Microsystems, Inc.
Core Web Services
Include le tecnologie per l'invocazione e il deply dei Ws, per la gestione dei documenti XML e la gestione
dei messaggistica SOAP
-Java API for XML-Based Web Services (JAX-WS)
-Java Architecture for XML Binding (JAXB)
Enhanced Web Services
Tecnologie WS- based per la gestione di caratteristiche speciali quali, ad esempio, consegna affidabile dei
messaggi o gestione di transazioni (atomicità)
- Web Services Interoperability Technologies (WSIT)
Permette la cooperazione tre JavaWeb services e Microsoft's Windows Communication Foundation.
Secure Web Services
Tecnologie per la gestione della sicurezza nei WS.
-XML and Web Services Security (XWS-Security)
permette la definizione di politiche per l'affidabilità delle operazioni request/response
Legacy Web Services
Fornisce le tecnologie per l'utilizzo di vecchie librerie (Jax-rpc)
Web Services - Management
Permette di definire specifici profili per la comunicazione tra il sistema di gestione e le risorse gestite.
Java Web Services
JAX-WS: esempio servizio
Info fromJ5EE Tutorial
Copyright 1994-2007
Sun Microsystems, Inc.
package helloservice.endpoint;
import javax.jws.WebService;
@WebService
public class Hello {
private String message = new String("Hello, ");
public void Hello() {}//costruttore
//metodo da espore
@WebMethod
public String sayHello(String name) {
return message + name + ".";
}
}
Nota:
Per costruzione, la classe deve contenere la definizione di un costruttore pubblico senza argomenti
Java Web Services
JAX-WS: esempio client
Info fromJ5EE Tutorial
Copyright 1994-2007
Sun Microsystems, Inc.
package simpleclient;
import javax.xml.ws.WebServiceRef;
import helloservice.endpoint.HelloService;
import helloservice.endpoint.Hello;
public class HelloClient {
@WebServiceRef(wsdlLocation="http://localhost:8080/helloservice/hello?wsdl")
static HelloService service;
public static void main(String[] args) {
try {
HelloClient client = new HelloClient();
client.doTest(args);
} catch(Exception e) {
e.printStackTrace();
}
}
public void doTest(String[] args) {
...
Hello port = service.getHelloPort();
...
String response = port.sayHello(name);
...
}
Apache AXIS v1.4
AXIS (Apache Extensible Interaction System) è un framework
open souce per lo sviluppo e la gestione di Web Services in Java.
Rappresenta l’estensione di Apache SOAP v2.0 .
In pratica si tratta di un “SOAP engine”, ovvero un software in
grado di gestire la codifica/decodifica dei messaggi SOAP
facendo da tramite tra utente e Web Service.
Supporta RPC & message/document based provider
WSx
User
WSy
AXIS
WSz
Java Web Services
Apache AXIS: installazione
Prerequisiti:
J2SDK version>1.3
Apache ANT
Xerces.jar – parser XML
Servlet container (Tomcat)
Installato Tomcat, basta copiare la directory $AXIS_HOME/webapps/axis
nella directory $CATALINA_HOME/webapps/axis.
E’ importante che tutti i file *.jar di $AXIS_HOME/lib stiano anche in
$CATALINA_HOME/webapps/axis/lib.
Impostare $AXISCLASSPATH in modo tale che contenga tutte le librerie
necessarie ad AXIS ($AXIS_HOME/lib , Xerces.jar, mail.jar, activation.jar)
Java Web Services
Apache AXIS: installazione
All’indirizzo localhost:8080/axis cliccare sul link valitation
La pagine associata verifica che siano soddisfatte tutte le
richieste. La condizione è necessaria ma non sufficiente
Java Web Services
Apache AXIS: architettura
Ogni messaggio viene elaborato passando attraverso una serie di
handler (chain-catene di handler).
Ogni handler esegue uno specifico compito.
Quali e quanti handler vengono utilizzati dipende dal tipo di
servizio utilizzato (server-config.wsdd).
Java Web Services
Apache AXIS: architettura
MessageContext object: rappresenta il messaggio (in-out)
Handler:
transport handler
dipendono dal protocollo di trasporto utilizzato
global handler
processano ogni tipo di messaggio
service-specific handler
processano solo messaggi diretti ad uno specifico ws
Pivot-point: handler di passaggio tra percorso in e percorso out
Java Web Services
Apache AXIS: architettura
Message Context
Pivot Point
Specific WS
Java Web Services
Apache AXIS: architettura
Server path
Client path
Java Web Services
Apache AXIS: server/client path
AXIS server:
z
il messaggio SOAP viene inserito dal TrasportListener
all’interno di un messaggio Message
z
l’oggetto Message, insieme a informazioni come il
protocollo di trasporto e il parametro SoapAction, viene
inserito all’interno di un MessageContext.
z
Il MessageContext passa attraverso gli handler (chain)
transport e global, arrivando al target service-specific handler
che si occupa di passarlo al provider.
z
Il provider (pivot point), anch’esso handler, si occupa di
mandare in esecuzione il WSn esecuzione il WS
AXIS client:
percorso speculare a logica invertita.
Java Web Services
Apache AXIS: deploy dei servizi
Axis mette a disposizione due tecniche per il deploy dei servizi:
JWS deploy technique
utilizzata per la gestione di WS semplici, molto veloce ma
poco flessibile (drop-in)
WSDD deploy technique
utilizzata per la gestione di WS complessi, estremamente
flessibile e personalizzabile, legata a file di configurazione
Java Web Services
Apache AXIS: JWS deploy
Creazione del file applicazione.java
Modifica dell’estensione del file in applicazione.jws
Copia del file applicazione.jws nella cartella
$AXISWEB/webapps/axis/
Axis si occupa della compilazione dell’applicazione, del mapping
parametri Java/XML, del deploy del servizio e della creazione del
file wsdl ( localhost:8080/axis/applicazione.jws?WSDL)
Il costo intellettuale è praticamente nullo.
Con questa soluzione vengono esposti tutti i metodi pubblici e non
statici: per avere più controllo sui metodi ed imporre il passaggio da
specifici handler è necessario il WSDD deploy.
Java Web Services
Apache AXIS: WSDD deploy
Web Services Deployment Description (WSDD)
Permette di definire il mapping dei tipi Java/XML
Permette di definire quali metodi rendere accessibili
Permette di definire lo scope del WS invocato
Permette di associare specifici handler al servizio
Permette il deploy del servizio in assenza del codice sorgente
Java Web Services
Apache AXIS: WSDD deploy
<?xml version="1.0" encoding="UTF-8"?>
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/providers/java">
<handler name=hnd1 type=“URIclasseh1”>
<handler name=hnd2 type=“URIclasseh2”>
<handler name=hndn type=“URIclassehn”>
<service name= “nomeclass” provider= “java:RPC”>
<parameter name=“allowedMethod” value=“met_1”/>
<parameter name=“scope” value=“application”/>
<requestFlow>
<handler type=“URIclasseh1”/>
</requestFlow>
<responseFlow>
<handler type=“URIclasseh1”/>
</requesteFlow>
</service>
</deployment>
Java Web Services
Apache AXIS: WSDD deploy
<?xml version="1.0" encoding="UTF-8"?>
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/providers/java">
<handler name=hnd1 type=“URIclasseh1”>
<handler name=hnd2 type=“URIclasseh2”>
<handler name=hndn type=“URIclassehn”>
<service name= “nomeclass” provider= “java:RPC”>
<parameter name=“allowedMethod” value=“met_1>
<parameter name=“scope” value=“application”/>
<requestFlow>
<handler type=“URIclasseh1”/>
</requestFlow>
<responseFlow>
<handler type=“URIclasseh1”/>
</requesteFlow>
</service>
</deployment>
Java Web Services
Apache AXIS: WSDD deploy
<?xml version="1.0" encoding="UTF-8"?>
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/providers/java">
<handler name=hnd1 type=“URIclasseh1”>
<handler name=hnd2 type=“URIclasseh2”>
<handler name=hndn type=“URIclassehn”>
<service name= “nomeclass” provider= “java:RPC”>
<parameter name=“allowedMethod” value=“met_1>
<parameter name=“scope” value=“request”/>
<requestFlow>
<handler type=“URIclasseh1”/>
</requestFlow>
<responseFlow>
<handler type=“URIclasseh1”/>
</requesteFlow>
</service>
</deployment>
Application 1obj:all req
Session 1obj: client
Java Web Services
Apache AXIS: WSDD deploy
<?xml version="1.0" encoding="UTF-8"?>
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/providers/java">
<handler name=hnd1 type=“URIclasseh1”>
<handler name=hnd2 type=“URIclasseh2”>
<handler name=hndn type=“URIclassehn”>
<service name= “nomeclass” provider= “java:RPC”>
<parameter name=“allowedMethod” value=“met_1>
<parameter name=“scope” value=“application”/>
<requestFlow>
<handler type=“URIclasseh1”/>
</requestFlow>
<responseFlow>
<handler type=“URIclasseh2”/>
</requesteFlow>
</service>
</deployment>
Java Web Services
Apache AXIS: invocazione dei servizi
AXIS mette a disposizione dell’utente tre diverse metodologie
di invocazione:
Stub based
Genera lo stub a buid time dal WSDL tramite l’utility WSDL2java
Dynamic Invocation Interface (DII)
Invocazione del servizio tramite stub generato a run time
Dynamic Proxy
Java Web Services
Apache AXIS: invocazione Stub based
public class Prova {public int MetodoXY-Z(int X, int Y){return Z=f(X;Y);}}
java org.apache.axis.wsdl.WSDL2Java URL/axis/Prova.jws?wsdl
Per ogni
elemento in <types> genera una classe Java
<portType> genera una interfaccia java
<binding> genera uno stub
<service> genera l’interfaccia generica del servizio
Prova.java
E’ la Services Definition Interface, interfaccia ottenuta da <portType> che
estende java.rmi.Remote.
ProvaService.java
Interfaccia ottenuta da <service>
ProvaServiceLocator.java
La classe locator, contenente l'interfaccia di servizio, tramite cui si
ottenere un'istanza dello stub.
ProvaSoapBindingStub.java
E’ la classe che contiene il codice “ accessibile dalle API di Axis,
nascondendo l’implementazione di SOAP.
Java Web Services
Apache AXIS: invocazione Stub based
Tutti i file generati vengono inseriti all’interno di un package.
import localhost.axis.prova;
public class ProvaClient {
public static void main (String args[]) throws Exception {
int X=arg[1];
int Y=arg[2];
// Creazione del servizio
ProvaService service = new ProvaServiceLocator();
// Stub
Prova prv = service.getProva();
// Invocazione
int z= = prv.MetodoXY-Z(X,Y);
System.out.println(“Z=“+z);
}
}
Java Web Services
Apache AXIS: Dynamic Invocation Interface
import org.apache.axis.client.*;
import javax.xml.*;
import java.net.URL;
public class ServiceClient {
public static void main(String[] args) throws Exception {
String endpoint =
"http://127.0.0.1:8080/axis/serviceclass.jws";
URL servurl = new URL(endpoint);
Service service = new Service();
Call call = (Call) service.createCall();
call.setTargetEndpointAddress(servurl));
call.setOperationName(“metodoXY-Z");
call.addParameter(“X", XMLType.XSD_INT, ParameterMode.IN);
call.addParameter(“Y", XMLType.XSD_INT, ParameterMode.IN);
call.setReturnType(XMLType.XSD_INT);
int Z = call.invoke(newObject[]{arg[1],arg[2]});
System.out.println("Ris:" + Z);
}
}
Java Web Services
Apache AXIS: Dynamic Invocation Interface
import org.apache.axis.client.*;
import javax.xml.*;
import java.net.URL;
public class ServiceClient {
public static void main(String[] args) throws Exception {
String endpoint =
"http://127.0.0.1:8080/axis/serviceclass.jws";
URL servurl = new URL(endpoint);
Service service = new Service();
Call call = (Call) service.createCall();
call.setTargetEndpointAddress(servurl));
call.setOperationName(“metodoXY-Z");
call.addParameter(“X", XMLType.XSD_INT, ParameterMode.IN);
call.addParameter(“Y", XMLType.XSD_INT, ParameterMode.IN);
call.setReturnType(XMLType.XSD_INT);
int Z = call.invoke(newObject[]{arg[1],arg[2]});
System.out.println("Ris:" + Z);
}
}
Java Web Services
Apache AXIS: Dynamic Invocation Interface
import org.apache.axis.client.*;
import javax.xml.*;
import java.net.URL;
public class ServiceClient {
public static void main(String[] args) throws Exception {
String endpoint =
"http://127.0.0.1:8080/axis/serviceclass.jws";
URL servurl = new URL(endpoint);
Service service = new Service();
Call call = (Call)service.createCall();
call.setTargetEndpointAddress(servurl));
call.setOperationName(“metodoXY-Z");
call.addParameter(“X", XMLType.XSD_INT, ParameterMode.IN);
call.addParameter(“Y", XMLType.XSD_INT, ParameterMode.IN);
call.setReturnType(XMLType.XSD_INT);
int Z = call.invoke(newObject[]{arg[1],arg[2]});
System.out.println("Ris:" + Z);
}
}
Java Web Services
Apache AXIS: Dynamic Invocation Interface
import org.apache.axis.client.*;
import javax.xml.*;
import java.net.URL;
public class ServiceClient {
public static void main(String[] args) throws Exception {
String endpoint =
"http://127.0.0.1:8080/axis/serviceclass.jws";
URL servurl = new URL(endpoint);
Service service = new Service();
Call call = (Call)service.createCall();
call.setTargetEndpointAddress(servurl));
call.setOperationName(“metodoXY-Z");
call.addParameter(“X", XMLType.XSD_INT, ParameterMode.IN);
call.addParameter(“Y", XMLType.XSD_INT, ParameterMode.IN);
call.setReturnType(XMLType.XSD_INT);
int Z = call.invoke(newObject[]{arg[1],arg[2]});
System.out.println("Ris:" + Z);
}
}
Java Web Services
Apache AXIS: Dynamic Stub
import javax.xml.namespace.QName;
import javax.xml.rpc.*;
public class ServiceClient {
public static void main(String [] args) throws Exception {
String wsdlUrl =
"http://127.0.0.1:8080/axis/serviceclass.jws?wsdl";
String nsUri =
"http://127.0.0.1:8080/axis/serviceclass.jws";
String serviceName = "Service";
String portName = “metodoXY-Z";
int X=arg[1];
int Y=arg[2];
ServiceFactory serviceFactory = ServiceFactory.newInstance();
Service srv = serviceFactory.createService(\
newjava.net.URL(wsdlUrl),\
new QName(nameSpaceUri, serviceName));
ServServiceIntf servInt = (ServServiceIntf)srv.getPort(
new QName(nameSpaceUri, portName),
ServServiceIntf.class);
System.out.println(“Ris:" + srvInt.metodoXY-Z(3,3));
}
}
Java Web Services
Apache AXIS: Dynamic Stub
import javax.xml.namespace.QName;
import javax.xml.rpc.*;
public class ServiceClient {
public static void main(String [] args) throws Exception {
String wsdlUrl =
"http://127.0.0.1:8080/axis/serviceclass.jws?wsdl";
String nsUri =
"http://127.0.0.1:8080/axis/serviceclass.jws";
String serviceName = "Service";
String portName = “metodoXY-Z";
int X=arg[1];
int Y=arg[2];
ServiceFactory serviceFactory = ServiceFactory.newInstance();
Service srv = serviceFactory.createService(\
newjava.net.URL(wsdlUrl),\
new QName(nameSpaceUri, serviceName));
ServServiceIntf servInt = (ServServiceIntf)srv.getPort(
new QName(nameSpaceUri, portName),
ServServiceIntf.class);
System.out.println(“Ris:" + srvInt.metodoXY-Z(3,3));
}
}
Java Web Services
Apache AXIS: Dynamic Stub
import javax.xml.namespace.QName;
import javax.xml.rpc.*;
public class ServiceClient {
public static void main(String [] args) throws Exception {
String wsdlUrl =
"http://127.0.0.1:8080/axis/serviceclass.jws?wsdl";
String nsUri =
"http://127.0.0.1:8080/axis/serviceclass.jws";
String serviceName = "Service";
String portName = “metodoXY-Z";
int X=arg[1];
int Y=arg[2];
ServiceFactory serviceFactory = ServiceFactory.newInstance();
Service srv = serviceFactory.createService(\
newjava.net.URL(wsdlUrl),\
new QName(nameSpaceUri, serviceName));
ServServiceIntf servInt = (ServServiceIntf)srv.getPort(
new QName(nameSpaceUri, portName),
ServServiceIntf.class);
System.out.println(“Ris:" + srvInt.metodoXY-Z(3,3));
}
}
Java Web Services
Apache AXIS: Dynamic Stub
import javax.xml.namespace.QName;
import javax.xml.rpc.*;
public class ServiceClient {
public static void main(String [] args) throws Exception {
String wsdlUrl =
"http://127.0.0.1:8080/axis/serviceclass.jws?wsdl";
String nsUri =
"http://127.0.0.1:8080/axis/serviceclass.jws";
String serviceName = "Service";
String portName = “metodoXY-Z";
int X=arg[1];
int Y=arg[2];
ServiceFactory serviceFactory = ServiceFactory.newInstance();
Service srv = serviceFactory.createService(\
newjava.net.URL(wsdlUrl),\
new QName(nameSpaceUri, serviceName));
ServServiceIntf servInt = (ServServiceIntf)srv.getPort(
new QName(nameSpaceUri, portName),
ServServiceIntf.class);
System.out.println(“Ris:" + srvInt.metodoXY-Z(3,3));
}
}
Java Web Services
Apache AXIS: Dynamic Stub
import javax.xml.namespace.QName;
import javax.xml.rpc.*;
public class ServiceClient {
public static void main(String [] args) throws Exception {
String wsdlUrl =
"http://127.0.0.1:8080/axis/serviceclass.jws?wsdl";
String nsUri =
"http://127.0.0.1:8080/axis/serviceclass.jws";
String serviceName = "Service";
String portName = “metodoXY-Z";
int X=arg[1];
int Y=arg[2];
ServiceFactory serviceFactory = ServiceFactory.newInstance();
Service srv = serviceFactory.createService(\
newjava.net.URL(wsdlUrl),\
new QName(nameSpaceUri, serviceName));
ServServiceIntf servInt = (ServServiceIntf)srv.getPort(
new QName(nameSpaceUri, portName),
ServServiceIntf.class);
System.out.println(“Ris:" + srvInt.metodoXY-Z(3,3));
}
}
Java Web Services
Riferimenti
Manuali:
Understanding SOA with WebServices,
Java Web Services,
Building Web Services with Java,
Art of Java Web development,
The Java Web Services Tutorial,
Addison Wesley
O’really
Sams
Manning
S.U.N.
Web:
WS: www.w3.org/2002/ws/
XML:XML tutorial – W3School
SOAP: www.w3.org/TR/2003/REC-soap12-part0-20030624/
WSDL: www.w3.org/TR/wsdl
BPEL: Business processes in a Web services world IBM
AXIS: ws.apache.org/axis - architecture and user guides -
Java Web Services
Facoltà di Ingegneria - Università degli studi di Catania
Dipartimento di Ingegneria Informatica e delle Telecomunicazioni
Java Web Services
Giovanni Morana
Facoltà di Ingegneria - Università degli studi di Catania
Dipartimento di Ingegneria Informatica e delle Telecomunicazioni
Domande?
Java Web Services
Giovanni Morana