SAWSDL // Restricted!Liberamente estratto e sintetizzato daSemantic 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>

</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 ServiceUn 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 categoriaSe 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 categoriaAlcune 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 serviziUna 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 condivisaConsideriamo 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"

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/SampleOntology#PartNumber"/> <xsd:element name="date" type="xsd:string" sawsdl:modelReference="http://org1.example.com/ontologies/SampleOntology#DueDate"/> <xsd:element name="qty" type="xsd:float" sawsdl:modelReference="http://org1.example.com/ontologies/SampleOntology#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#AvailabilityConfirmation"> <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 ontologiaL'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.

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 multipleSAWSDL 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 RappresentazioneL'attributo modelReference può essere usato per rappresentare vincoli comportamentali collegati al servizio.

Definire mappature di schema (Schema Mappings) per abilitare l'invocazione di Web ServiceSupponiamo 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 MappingUn 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/PurchaseOrderService#" elementFormDefault="qualified">

<xsd:element name="OrderRequest"> <xsd:complexType sawsdl:liftingSchemaMapping="http://www.w3.org/2002/ws/sawsdl/spec/examples/mapping/OrderRequest2Ont.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>

</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/PurchaseOrderService#">

<firstName>John</firstName>

<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/PurchaseOrderService#" 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>

<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 MappingIniziamo 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/mapping/OrderRequest2Ont.xslt sawsdl:loweringSchemaMapping="http://www.w3.org/2002/ws/sawsdl/spec/examples/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>

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/PurchaseOrderService#" 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>

<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/PurchaseOrderService#" 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.