Riassunto e traduzione della reference ufficiale del W3C del linguaggio per il tagging semantico di documenti WSDL (linguaggio per la descrizione di servizi)

1. SAWSDL // Restricted!
Liberamente estratto e sintetizzato da
Semantic Annotations for WSDL and XML Schema - Usage Guide (http://www.w3.org/TR/sawsdl-guide/)
Per la presentazione di SAWSDL ci si avvarrà di due esempi:
Listato 1.2-1
<wsdl:description
targetNamespace="http://org1.example.com/wsdl/CheckAvailabilityRequestService/"
xmlns="http://org1.example.com/wsdl/CheckAvailabilityRequestService/"
xmlns:wsdl="http://www.w3.org/ns/wsdl"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<wsdl:types>
<xsd:schema
targetNamespace="http://org1.example.com/wsdl/CheckAvailabilityRequestService">
<xsd:element name="CheckAvailabilityRequestServiceRequest">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="itemCode" type="xsd:string"/>
<xsd:element name="date" type="xsd:string"/>
<xsd:element name="qty" type="xsd:float"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="CheckAvailabilityRequestServiceResponse"
type="itemConfirmation"/>
<xsd:simpleType name="itemConfirmation">
<xsd:restriction base="xsd:boolean"/>
</xsd:simpleType>
</xsd:schema>
</wsdl:types>
<wsdl:interface name="CheckAvailabilityRequestService">
<wsdl:operation name="CheckAvailabilityRequestOperation"
pattern="http://www.w3.org/ns/wsdl/in-out">
<wsdl:input element="CheckAvailabilityRequestServiceRequest"/>
<wsdl:output element="CheckAvailabilityRequestServiceResponse"/>
</wsdl:operation>
</wsdl:interface>
</wsdl:description>
Listato 1.2-2
<wsdl:description
targetNamespace="http://org2.example.com/wsdl/CheckInventoryService/"
xmlns="http://org2.example.com/wsdl/CheckInventoryService/"
xmlns:wsdl="http://www.w3.org/ns/wsdl"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<wsdl:types>
<xsd:schema
targetNamespace="http://org2.example.com/wsdl/CheckInventoryService">
<xsd:element name="CheckInventoryServiceRequest">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="SKU" type="xsd:string"/>
<xsd:element name="deliveryDate" type="xsd:string"/>
<xsd:element name="numBundles" type="xsd:float"/>
</xsd:sequence>

2. </xsd:complexType>
</xsd:element>
<xsd:element name="CheckInventoryServiceResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="conf" type="xsd:boolean"/>
<xsd:element name="numBundles_available" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
</wsdl:types>
<wsdl:interface name="CheckInventoryService">
<wsdl:operation name="checkInventoryService"
pattern="http://www.w3.org/ns/wsdl/in-out">
<wsdl:input element="CheckInventoryServiceRequest"/>
<wsdl:output element="CheckInventoryServiceResponse"/>
</wsdl:operation>
</wsdl:interface>
</wsdl:description>
Definire le annotazioni per la pubblicazione di un Web Service
Un web service può essere corredato di annotazioni semantiche al fine di fornirne una
categorizzazione. Il meccanismo di estensione SAWSDL chiamato modelReference può essere usato
per aggiungere queste informazioni sulla categorizzazione al servizio.
Aggiungere le informazioni di categorizzazione come URI di categoria
Se esiste già un modello semantico di categorizzazione (per esempio una tassonomia) un elemento
modelReference potrebbe essere associato ad un'interfaccia o ad un'operazione di un servizio in
modo tale da puntare a una particolare categoria nella tassonomia.
Aggiunge le informazioni di categorizzazione come Identificatori di categoria
Alcune tassonomie non forniscono direttamente URI per le rispettive categorie e potrebbero
richiedere più porzioni di informazione per identificare le categorie.In tal caso, gli utenti possono
definire tali informazioni secondo le esigenze e associare un modelReference a tali informazioni
tassonomiche definite dall'utente.
Definire le annotazioni per usarle nel matching e nella composizione di
servizi
Una delle più grandi motivazioni per cui SAWSDL è stato introdotto è la necessità di provvedere un
meccanismo per inserire annotazioni semantiche nella descrizione WSDL per facilità la
composizione e la scoperta di web service.
Matching delle interfacce dei Web Service usando un'ontologia condivisa
Consideriamo i listati dei due esempi. Il primo rappresenta una richiesta di un servizio mentre il
secondo mostra il servizio effettivamente fornito. Un matching ad alto livello tra richiesta e servizio
fornirebbe un risultato positivo. Un matching engine tradizionale non ha gli strumenti per capire che
SKU e itemCode si riferiscono entrambe ad un codice univoco di un oggetto o che qty e
numBundles riguardano sempre un concetto di quantità. In questo senso delle annotazioni
semantiche associate alla descrizione WSDL permetterebbero un match tra la richiesta ed il
servizio. Nel seguente esempio le annotazioni semantiche sono aggiunte usando l'attributo di
estensibilità del modelReference di SAWSDL.
<wsdl:description
targetNamespace="http://org1.example.com/wsdl/CheckAvailabilityRequestService/"
xmlns="http://org1.example.com/wsdl/CheckAvailabilityRequestService/"
xmlns:wsdl="http://www.w3.org/ns/wsdl"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"

3. xmlns:sawsdl="http://www.w3.org/ns/sawsdl">
<wsdl:types>
<xsd:schema
targetNamespace="http://org1.example.com/wsdl/CheckAvailabilityRequestService">
<xsd:element name="CheckAvailabilityRequestServiceRequest">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="itemCode" type="xsd:string"
sawsdl:modelReference="http://org1.example.com/ontologies/SampleOnto
logy#PartNumber"/>
<xsd:element name="date" type="xsd:string"
sawsdl:modelReference="http://org1.example.com/ontologies/SampleOnto
logy#DueDate"/>
<xsd:element name="qty" type="xsd:float"
sawsdl:modelReference="http://org1.example.com/ontologies/SampleOnto
logy#Quantity"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="CheckAvailabilityRequestServiceResponse"
type="itemConfirmation"/>
<xsd:simpleType name="itemConfirmation"
sawsdl:modelReference="http://org1.example.com/ontologies/SampleOntology#A
vailabilityConfirmation">
<xsd:restriction base="xsd:boolean"/>
</xsd:simpleType>
</xsd:schema>
</wsdl:types>
<wsdl:interface name="CheckAvailabilityRequestService">
<wsdl:operation name="checkAvailabilityRequestOperation"
pattern="http://www.w3.org/ns/wsdl/in-out">
<wsdl:input element="CheckAvailabilityRequestServiceRequest"/>
<wsdl:output element="CheckAvailabilityRequestServiceResponse"/>
</wsdl:operation>
</wsdl:interface>
</wsdl:description>
Similmente può essere fatto per il secondo esempio. In entrambi gli esempi, i documenti WSDL
sono stati annotati con concetti presi da una stessa ontologia. Un motore semantico può usare le
relazioni tra i concetti durante il matching delle interfacce ragionando su un modello semantico.
Matching delle interfacce dei Web Service con Mediazione tra ontologia
L'ipotesi fatta precedentemente per cui tutti i concetti usati nelle annotazioni debbano provenire da
una sola ontologia condivisa può non essere sempre vera. E' possibile che si usino due ontologie
diverse dello stesso dominio in due documenti diversi: ad esempio usiamo concetti da una ontologia
per il primo esempio e concetti da un'altra ontologia nel secondo. Se abbiamo una mapping
ontology possiamo usare le relazioni definite in tale ontologia per eseguire il matching.

4. Composizione di Web Service usando il ragionamento sulle Ontologie (Ontology Reasoning)
Supponiamo di avere un servizio checkInventoryService() che prende un UPC ( e non uno SKU):
ovviamente questo servizio non avrò nessun match con la richiesta checkAvailabilityRequest() in
quanto non ci sono relazioni nella mapping ontology tra partNumber e UPC. Supponiamo inoltre di
avere un servizio SKU2UPCLookup() che prende uno SKU e ritorna un UPC. Supponiamo inoltre
che ci siano tre ontologie differenti: una per la richiesta, una per l'advertise e una per il mapping tra
le prime due. La relazione tra SKU e UPC nell'ontologia è mostrata dalla seguente figura.
Un engine semantico estrae l'elemento PartNumeber dal servizio checkAvailabilityRequest() e
l'elemento SKU dal servizio SKU2UPCLookup() e dal punto di vista lessicale si trova che questi
due concetti non ci sono somiglianze. L'engine semantico a questo punto può consultare un
Mapping Ontology per vedere se ci sono relazioni tra PartNumber e SKU: il reasoner riornerà
l'esistenza di una relazione “subClassOf” tra SKU e PartNumber. Questa informazione sarà usata
per comporre SKU2UPCLoolup() con CheckInventoryService().
Matching usando annotazioni multiple
SAWSDL permette annotazioni multiple associate ad uno stesso elemento: queste annotazioni
possono puntare a concetti differenti della stessa ontologia o di ontologie diverse. SAWSDL non
specifica nessun tipo di relazione tra le annotazioni multiple: spetta a chi consulta queste
annotazioni decidere se c'è qualche relazione tra questi concetti consultando l'ontologia ( o le
ontologie di riferimento).
...
<xsd:simpleType name="itemCode"
sawsdl:modelReference="http://org3.example.com/ontologies/SampleOntologyOrg3#PartNumber
http://org3.example.com/ontologies/SampleOntologyOrg3#SKU"/>
<xsd:restriction base="xsd:string"/>
</xsd:simpleType>
...
Matching usando annotazioni su tipi complessi (Complex Type)
SAWSDL permette l'aggiunta di annotazioni sia al livello di tipo complesso (top level) oppure al
livello degli elementi membro (lower level) oppure ad entrambi i livelli. Nei casi in cui sia il tipo
complesso che i membri del tipo siano forniti di annotazioni, SAWSDL non specifica nessuna
relazione tra i modelReference dei due livelli.
Il motore semantico generalmente usa le annotazioni a livello di tipo complesso per trovare le
relazioni tra i due tipi e poi inizia ad analizzare le possibili relazioni tra gli elementi membro del
tipo complesso in base alle annotazioni espresse a tale livello.
Condizioni di Rappresentazione
L'attributo modelReference può essere usato per rappresentare vincoli comportamentali collegati al
servizio.

5. Definire mappature di schema (Schema Mappings) per abilitare
l'invocazione di Web Service
Supponiamo di avere due dati separati: nome e cognome. Supponiamo ora che un servizio abbia
come ingresso il nome completo: per usare tale servizio è necessario il concatenamento di nome e
cognome. Per facilitare questo tipo di trasformazioni SAWSDL mette a disposizione il meccanismo
delle mappature di schema (Schema Mapping). Uno Schema Mapping permette di specificare una
funzione di trasformazione su elementi WSDL per mappare istanze di dati definiti tramite XML
Schema su dei dati di concetti ontologici definiti in un modello semantico. Questo meccanismo ci
permette anche di definire delle funzioni di trasformazione che mappano i dati concettuali delle
ontologie su istanze di dati definiti tramite XML Schema. Nel primo caso ci si riferisce alle funzioni
di trasformazione usante l'attributo di estensibilità liftingSchemaMapping mentre nel secondo caso
ci si riferisce all'attributo loweringSchemaMapping.
Lifting Schema Mapping
Un liftingSchemaMapping prende come input un dato XML (che aderisce ad un determinato XML
Schema) e produce dati semantici. Supponiamo di avere dei tipi complessi OrderRequest, item e
OrderResponse e che vogliamo specificare un lifting schema mapping su OrderRequest in modo
che un'istanza XML di OrderRequest possa essere mappata su un dato semantico su un grafo RDF.
<wsdl:description>
...
<wsdl:types>
<xsd:schema
targetNamespace="http://www.w3.org/2002/ws/sawsdl/spec/examples/wsdl/PurchaseOrderSe
rvice#" elementFormDefault="qualified">
<xsd:element name="OrderRequest">
<xsd:complexType
sawsdl:liftingSchemaMapping="http://www.w3.org/2002/ws/sawsdl/spec/examples/mapping/Orde
rRequest2Ont.xslt">
<xsd:sequence>
<xsd:element name="firstName" type="xsd:string"/>
<xsd:element name="lastName" type="xsd:string"/>
<xsd:element name="item" type="item" minOccurs="1" maxOccurs="unbounded" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:complexType name="item">
<xsd:all>
<xsd:element name="itemCode" type="xsd:string"/>
<xsd:element name="quantity" type="xsd:float"/>
<xsd:element name="dueDate" type="xsd:string"/>
<xsd:element name="billingInfo" type="xsd:POBilling"/>
</xsd:all>
</xsd:complexType>
<xsd:element name="OrderResponse" type="Confirmation"/>
<xsd:simpleType name="Confirmation">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="Confirmed"/>
<xsd:enumeration value="Pending"/>
<xsd:enumeration value="Rejected"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
</wsdl:types>
<wsdl:interface name="Order">
<wsdl:operation name="order" pattern="http://www.w3.org/ns/wsdl/in-out">
<wsdl:input element="OrderRequest"/>
<wsdl:output element="OrderResponse"/>
</wsdl:operation>

6. </wsdl:interface>
</wsdl:description>
...
Vediamo ora l'XLST che mappa gli elementi del tipo complesso OrderRequest su i dati
corrispondeti dell'ontologia.
@prefix xs: <http://www.w3.org/2001/XMLSchema#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix : <http://org1.example.com/ontologies/PurchaseOrder#> .
<http://org1.example.com/ontologies/PurchaseOrder#> rdf:type owl:Ontology .
:OrderRequest rdf:type owl:Class .
:hasLineItems rdf:type owl:ObjectProperty ;
rdfs:domain :OrderRequest ;
rdfs:range :LineItem .
:LineItem rdf:type owl:Class .
:hasPart rdf:type owl:ObjectProperty , owl:FunctionalProperty ;
rdfs:domain :LineItem ;
rdfs:range :Part .
:Part rdf:type owl:Class .
:hasPartCode rdf:type owl:ObjectProperty ;
rdfs:domain :Part ;
rdfs:range :PartNum .
:PartNum rdf:type owl:Class .
:hasLexicalRespresentation rdf:type owl:DatatypeProperty ,
owl:FunctionalProperty ;
rdfs:domain
[ rdf:type owl:Class ;
owl:unionOf (:Name :PartNum :Date)
] ;
rdfs:range xs:string .
:hasDueDate rdf:type owl:ObjectProperty ;
rdfs:domain :LineItem ;
rdfs:range :Date .
:Date rdf:type owl:Class .
:hasQuantity rdf:type owl:DatatypeProperty ;
rdfs:domain :LineItem ;
rdfs:range xs:float .
:hasBillingInfo rdf:type owl:DatatypeProperty ;
rdfs:domain :LineItem ;
rdfs:range xs:billingInfo .
:hasCustomer rdf:type owl:ObjectProperty , owl:FunctionalProperty ;
rdfs:domain :OrderRequest ;
rdfs:range :Customer .
:Customer rdf:type owl:Class .
:hasCustomerName rdf:type owl:ObjectProperty ;
rdfs:domain :Customer ;
rdfs:range :Name .
:Name rdf:type owl:Class .
Vediamo ora un file XML di esempio che contiene dei dati strutturati in base allo schema.
<OrderRequest
xmlns="http://www.w3.org/2002/ws/sawsdl/spec/examples/wsdl/PurchaseOrderServic
e#">
<firstName>John</firstName>

7. <lastName>Smith</lastName>
<item>
<itemCode>052053811</itemCode>
<quantity>12.0</quantity>
<dueDate>20061114</dueDate>
<billingInfo>88 Park Road, Lower Dangan, Galway, Ireland</billingInfo>
</item>
<item>
<itemCode>45001113</itemCode>
<quantity>10.0</quantity>
<dueDate>20061224</dueDate>
<billingInfo>70 Sandyhill Road, Shalthill, Galway, Ireland</billingInfo>
</item>
</OrderRequest>
Ed infine mostriamo un file XSLT che concatena il valore di FirstName con lastName.
<!DOCTYPE rdf:RDF
[<!ENTITY xs "http://www.w3.org/2001/XMLSchema#">
]
>
<xsl:transform version="2.0"
xmlns:order="http://www.w3.org/2002/ws/sawsdl/spec/examples/wsdl/PurchaseOrder
Service#"
xmlns:po="http://org1.example.com/ontologies/PurchaseOrder#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:owl="http://www.w3.org/2002/07/owl#">
<xsl:output method="xml" version="1.0" encoding="iso-8859-1" indent="yes" />
<xsl:template match="/order:OrderRequest">
<rdf:RDF>
<owl:Ontology/>
<po:OrderRequest>
<po:hasCustomer>
<po:Customer>
<po:hasCustomerName>
<po:Name>
<po:hasLexicalRepresentation>
<xsl:value-of select="concat(
order:firstName,
' ',
order:lastName)"/>
</po:hasLexicalRepresentation>
</po:Name>
</po:hasCustomerName>
</po:Customer>
</po:hasCustomer>
<po:hasLineItems>
<po:LineItem>
<po:hasPart>
<po:Part>
<po:hasPartCode>
<po:PartNum>
<po:hasLexicalRepresentation>
<xsl:value-of select="order:item/order:itemCode"/>
</po:hasLexicalRepresentation>
</po:PartNum>
</po:hasPartCode>
</po:Part>
</po:hasPart>

8. <po:hasDueDate>
<po:Date>
<po:hasLexicalRepresentation>
<xsl:value-of select="order:item/order:dueDate"/>
</po:hasLexicalRepresentation>
</po:Date>
</po:hasDueDate>
<po:hasQuantity rdf:datatype="&xs;float">
<xsl:value-of select="order:item/order:quantity"/>
</po:hasQuantity>
<po:hasBillingInfo rdf:datatype="&xs;POBilling">
<xsl:value-of select="order:item/order:billingInfo"/>
</po:hasBillingInfo>
</po:LineItem>
<xsl:apply-templates select="order:OrderRequest" />
</po:hasLineItems>
</po:OrderRequest>
</rdf:RDF>
</xsl:template>
</xsl:transform>
Lowering Schema Mapping
Iniziamo con l'aggiungere ad una annotazione con un liftingSchemaMapping un loweringSchemaMapping.
<xsd:element name="OrderRequest">
<xsd:complexType
sawsdl:liftingSchemaMapping="http://www.w3.org/2002/ws/sawsdl/spec/examples/mapp
ing/OrderRequest2Ont.xslt
sawsdl:loweringSchemaMapping="http://www.w3.org/2002/ws/sawsdl/spec/ex
amples/mapping/Ont2OrderRequest.lowering">
<xsd:sequence>
<xsd:element name="firstName" type="xsd:integer">John</xsd:element>
<xsd:element name="lastName" type="xsd:integer">Smith</xsd:element>
<xsd:element name="item" type="item" minOccurs="1"
maxOccurs="unbounded" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
Un loweringSchemaMapping dovrebbe prendere dei dati semantici ma non è molto chiaro in che
forma questi devono essere presentati: per risolvere questo problema usiamo delle query nel
linguaggio SPARQL per prelevare dei dati semantici dall'ontologia e ottenerne una rappresentazione
XML che poi può essere usata per formulare una trasformazione XSLT.
<lowering>
<sparqlQuery>
PREFIX po: <http://org1.example.com/ontologies/PurchaseOrder#>
SELECT ?name ?partNum ?quantity ?dueDate ?billingInfo
WHERE {
?order po:hasCustomer ?customer .
?customer po:hasCustomerName ?custName .
?custName po:hasLexicalRespresentation ?name .
?order po:hasLineItems ?item .
?item po:hasQuantity ?quantity .
?item po:hasBillingInfo ?billingInfo .
?item po:hasDueDate ?Date .
?date po:hasLexicalRepresentation ?dueDate .
?item po:hasPart ?part .
?part po:hasPartCode ?code .
?code po:hasLexicalRespresentation ?partNum }
</sparqlQuery>

9. Si genera quindi una risposta alla query in formato XML.
<sparql xmlns="http://www.w3.org/2005/sparql-results#">
<head>
<variable name="quantity" />
<variable name="partNum" />
<variable name="name" />
<variable name="dueDate" />
<variable name="billingInfo" />
</head>
<results>
<result>
<binding name="quantity">
<literal>12.0</literal>
</binding>
<binding name="partNum">
<literal>052053811</literal>
</binding>
<binding name="name">
<literal>John Smith</literal>
</binding>
<binding name="billingInfo">
<literal>88 Park Road, Lower Dangan, Galway, Ireland</literal>
</binding>
<binding name="dueDate">
<literal>20061114</literal>
</binding>
</result>
</results>
</sparql>
A questo punto possiamo definire una trasformazione XSLT che ci ritornerà di nuovo il tipo
complesso originale.
<xsl:transform version="2.0"
xmlns:po="http://www.w3.org/2002/ws/sawsdl/spec/examples/wsdl/PurchaseOrderS
ervice#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:sp="http://www.w3.org/2005/sparql-results#">
<xsl:output method="xml" version="1.0" encoding="iso-8859-1" indent="yes" />
<xsl:template match="/sp:sparql">
<po:OrderRequest>
<xsl:variable name="fullName">
<xsl:value-of
select="sp:results/sp:result[position()=1]/sp:binding[@name='name']/sp:literal"/
>
</xsl:variable>
<po:firstName>
<xsl:value-of select="substring-before($fullName,' ')" />
</po:firstName>
<po:lastName>

10. <xsl:value-of select="substring-after($fullName,' ')" />
</po:lastName>
<xsl:apply-templates select="sp:results/sp:result" />
</po:OrderRequest>
</xsl:template>
<xsl:template match="sp:result">
<po:"item">
<po:itemCode>
<xsl:value-of select="sp:binding[@name='partNum']/sp:literal" />
</po:itemCode>
<po:quantity>
<xsl:value-of select="sp:binding[@name='quantity']/sp:literal" />
</po:quantity>
<po:dueDate>
<xsl:value-of select="sp:binding[@name='dueDate']/sp:literal" />
</po:dueDate>
<po:billingInfo>
<xsl:value-of select="sp:binding[@name='billingInfo']/sp:literal" />
</po:billingInfo>
</po:item>
</xsl:template>
</xsl:transform>
</lowering>
Il risultato della trasformazione è il seguente.
<po:OrderRequest
xmlns:po="http://www.w3.org/2002/ws/sawsdl/spec/examples/wsdl/PurchaseOrderSer
vice#"
xmlns:sp="http://www.w3.org/2005/sparql-results#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<po:firstName>John</po:firstName>
<po:lastName>Smith</po:lastName>
<po:item>
<po:itemCode>052053811</po:itemCode>
<po:quantity>12.0</po:quantity>
<po:dueDate>20061114</po:dueDate>
<po:billingInfo>88 Park Road, Lower Dangan, Galway,
Ireland</po:billingInfo>
</po:item>
</po:OrderRequest>
Come nel caso delle annotazioni multiple, ad uno stesso elemento possiamo associare più di uno
schema mapping. Quando vengono specificati URI multipli in liftingSchemaMapping e
loweringSchemaMapping, SAWSDL specifica che questi schema mapping devono essere
considerati come delle alternative la cui scelta è lasciata alla discrezione del client.