Tutti gli articoli di admin

SPRING WS – TUTORIAL 7 – GESTIRE LE ECCEZIONI

18/06/2014 admin

In questo articolo vedremo la gestione delle eccezioni e i meccanismi che Spring-ws offre per la loro gestione.

Spring mette a disposizione un gestore delle eccezioni che carica la mappa delle eccezioni e crea opportunamente i fault in corrispondenza di ogni eccezioni.

<bean id="exceptionResolver" 
class="org.springframework.ws.soap.server.endpoint.SoapFaultMappingExceptionResolver">    
<property name="defaultFault" value="SERVER"/>
<property name="exceptionMappings">
<value>it.finazzo.libreria.exception.LibroException=SERVER,Invalid request</value>
</property>
</bean>

<bean id="exceptionResolver"

class="org.springframework.ws.soap.server.endpoint.SoapFaultMappingExceptionResolver">

<value>it.finazzo.libreria.exception.LibroException=SERVER,Invalid request</value>

</property>

</bean>

Nel nostro esempio stiamo dicendo al gestore delle eccezioni che in corrispondenza di una eccezione LibroException deve essere creato un fault con i parametri indicati, come quello mostrato sotto.

<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
   <SOAP-ENV:Header/>
   <SOAP-ENV:Body>
      <SOAP-ENV:Fault>
         <faultcode>SOAP-ENV:Server</faultcode>
         <faultstring xml:lang="en">Invalid request</faultstring>
      </SOAP-ENV:Fault>
   </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">

<SOAP-ENV:Header/>

<SOAP-ENV:Body>

<SOAP-ENV:Fault>

<faultcode>SOAP-ENV:Server</faultcode>

<faultstring xml:lang="en">Invalid request</faultstring>

</SOAP-ENV:Fault>

</SOAP-ENV:Body>

</SOAP-ENV:Envelope>

Per chi usale annotazioni e non vuole file xml con lunghe configurazione Spring mette a disposizione la annotazione @SoapFault. Una volta definita una eccezione è possibile definire il fault da lanciare e i parametri con cui configurarla

Possiamo ottenere un fault analogo a quello descritto sopra definendo così la nostra eccezione

<span style="color: #0d293f;">@SoapFault(faultCode = FaultCode.SERVER, faultStringOrReason="<span style="color: #000000;">Invalid request</span>")
</span>public class LibroException extends Exception

1 2	<span style="color: #0d293f;">@SoapFault(faultCode = FaultCode.SERVER, faultStringOrReason="<span style="color: #000000;">Invalid request</span>") </span>public class LibroException extends Exception

e aggiungendo tra i bean di Spring l’opportuna implementazione

<bean id="exceptionAnnotationResolver" 
class="org.springframework.ws.soap.server.endpoint.SoapFaultAnnotationExceptionResolver" />

1 2	<bean id="exceptionAnnotationResolver" class="org.springframework.ws.soap.server.endpoint.SoapFaultAnnotationExceptionResolver" />

Per chi ha creato il progetto tramite Maven ricordarsi di aggiungere la dipendenza dalle librerie di spring-ws che supportano le feature della jdk 1.5.

SPRING WS

SPRING WS – TUTORIAL 6 – USARE GLI INTERCEPTOR

18/06/2014 admin

In questo articolo vedremo come poter intercettare le richieste di servizio per effettuare le operazioni prima e dopo l’esecuzione dell’endpoint.

Fondamentale l’interceptor ci permette di:

loggare le richieste e le risposte inviate
applicare dei meccanismi di sicurezza alle richieste pervenute
gestire i fault di sistema

Per definire un interceptor occorre implementare l’interfaccia EndpointInterceptot che presenta i seguenti metodi:

handleRequest
handleResponse
handleFault

Il metodo handleRequest viene invocato prima dell’esecuzione dell’endpoint e il suo utilizzo principale è quello di bloccare l’esecuzione di un servizio.

Il metodo handleResponse viene invocato dopo l’esecuzione dell’endpoint e il sul utilizzo principale è quello di elaborare la risposta, magari aggiungendo attributi.

Il metodo handleFault viene invocato dopo l’esecuzione di un fault con finalità analoghe a quelle del metodo handleResponse.

Per chi non avesse particolari esigenze Spring offre già alcune implementazioni di interceptor:

PayloadLoggingInterceptor
PayloadValidatingInterceptor
PayloadTransformingInterceptor

Il PayloadLoggingInterceptor permette di loggare le richieste e le risposte.

Il PayloadValidatingInterceptor valida le richieste e le risposte in base ad uno schema xsd indicato nelle sue properties.

Il PayloadTransformingInterceptor effettua una transformazione delle richieste e delle risposte basate su XSLT. Viene usato quando il server gestisce più versioni dello stesso servizio.

Nel nostro progetto applichiamo un logger delle richieste e delle risposte e un validatore, ottenendo una configurazione di questo tipo.

<bean 
class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping">
<property name="mappings">
        <props>
            <prop key="{http://www.example.org/schema}RicercaLibroRequest">ricercaLibroEndpoint</prop>
        </props>
    </property>
    <property name="interceptors">
	    <list>
              <ref bean="loggingInterceptor"/>
              <ref bean="validatingInterceptor"/>
          </list>
        </property>
    </bean>
<bean id="loggingInterceptor"  
      class="org.springframework.ws.server.endpoint.interceptor.PayloadLoggingInterceptor"/>

<bean id="validatingInterceptor" 
      class="org.springframework.ws.soap.server.endpoint.interceptor.PayloadValidatingInterceptor">
    <property name="schema" value="classpath:schema.xsd"/>
    <property name="validateRequest" value="true"/>
    <property name="validateResponse" value="true"/>
</bean>

<bean

class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping">

<props>

<prop key="{http://www.example.org/schema}RicercaLibroRequest">ricercaLibroEndpoint</prop>

</props>

</property>

<list>

</list>

</property>

</bean>

<bean id="loggingInterceptor"

class="org.springframework.ws.server.endpoint.interceptor.PayloadLoggingInterceptor"/>

<bean id="validatingInterceptor"

class="org.springframework.ws.soap.server.endpoint.interceptor.PayloadValidatingInterceptor">

</bean>

SPRING WS

SPRING WS – TUTORIAL 5 – USARE IL MARSHALLING

18/06/2014 admin

In questo articolo vedremo le tecniche di marshalling che mette a disposizione Spring-ws per la gestione dei messaggi di richiesta e risposta dei web services.

Tutte le implementazione degli endpoint fornite dal framework prevedono 2 proprietà:

marshaller
unmarshaller

Il marshaller è responsabile di serializzare l’oggetto in un frammento xml, mentre l’unmarsheller effettua l’operazione contraria.

Sono previste più implementazioni dei marsheller, pertanto lo sviluppatore può scegliere con libertà l’implementazione più conveniente. Personalmente utilizzo jaxb2 che è disponibile a partire da java 6 con la virtual machine.

Per le altre implementazioni JAXB1, Castor, XMLBEANS rimando alla javadoc disponibile su spring-ws.

Definiamo il bean che descrive il marshaller e lo settiamo come attributo dell’endpoint

<bean id="jaxb2Marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
       <property name="contextPath" value="it.finazzo.libreria.schema"/>
       <property name="schema" value="classpath:schema.xsd"/>
</bean>
<bean id="ricercaLibroEndpoint" class="it.finazzo.libreria.ws.RicercaLibroEndpoint">
      <property name="marshaller" ref="jaxb2Marshaller"></property>
      <property name="unmarshaller" ref="jaxb2Marshaller"></property>
</bean>

</bean>

</bean>

La property schema del marshaller serve per la validazione della richiesta, mentre nella property contextPath specifichiamo il package dove sono disponibili le classi per il marshalling. Tali classi possono essere generate in automatico tramite un plugin disponibile per Maven. Per sfruttare questo plugin occorre inserire questo frammento nel pom.xml

<plugin>
       <groupId>com.sun.tools.xjc.maven2</groupId>
       <artifactId>maven-jaxb-plugin</artifactId>
       <executions>
             <execution>
                 <phase>generate-sources</phase>
                  <goals>
                      <goal>generate</goal>
                  </goals>
             </execution>
       </executions>
       <configuration>
            <generatePackage>it.finazzo.libreria.schema</generatePackage>
       </configuration>
</plugin>

<groupId>com.sun.tools.xjc.maven2</groupId>

<artifactId>maven-jaxb-plugin</artifactId>

<phase>generate-sources</phase>

<goals>

<goal>generate</goal>

</goals>

</execution>

</executions>

<generatePackage>it.finazzo.libreria.schema</generatePackage>

</configuration>

</plugin>

e definire le resources

<resource> 
<directory>src/main/resources</directory> 
<filtering>true</filtering>
</resource>

<directory>src/main/resources</directory>

</resource>

Tale plugin analizza i file xsd disponibili nella directory resource e genera le classi nel package configurato.

Infine occorre cambiare l’implementazione dell’endpoint estendendo la classe di spring-ws che supporta il marshalling:

public class RicercaLibroEndpoint extends AbstractMarshallingPayloadEndpoint {
protected Object invokeInternal(Object arg0) throws Exception {
return new RicercaLibroResponse();
}
}

public class RicercaLibroEndpoint extends AbstractMarshallingPayloadEndpoint {

protected Object invokeInternal(Object arg0) throws Exception {

return new RicercaLibroResponse();

}

A questo punto mvn install e proviamo il frutto delle nostre fatiche.

SPRING WS

SPRING WS – TUTORIAL 4 – MAPPING DEI SERVIZI

18/06/2014 admin

Nell’articolo di oggi vedremo come mappare i servizi e gestire la loro implementazione.

Occorre prima di tutto scegliere la tecnica di gestione per i messaggi xml. Possiamo usare delle librerie di gestione di messaggi xml come JDOM o SAX oppure delle tecniche di marshalling per la trasformazione di flussi xml in classi java e viceversa, come JAXB e XMLBEANS.

Spring-ws supporta tutte le principali librerie per la gestione dei file xml pertanto la scelta della libreria deve essere fatta valutando anche l’ambiente a disposizione.

In questo caso ho scelto JDOM, una libreria opensource che semplifica la gestione di DOM. Occorre modificare il file pom.xml per introdurre le dipendenza dalla libreria JDOM. Nel nostro caso si traduce in questo set di dipendenze:

<dependency>
<groupId>jdom</groupId>
<artifactId>jdom</artifactId>	
<version>1.0</version>	
</dependency>	    
<dependency>	        
<groupId>jaxen</groupId>	        
<artifactId>jaxen</artifactId>	        
<version>1.1</version>	    
</dependency>	    
<dependency>	        
<groupId>javax.xml.soap</groupId>	        
<artifactId>saaj-api</artifactId>	        
<version>1.3</version>	        
<scope>runtime</scope>	    
</dependency>	    
<dependency>	        
<groupId>com.sun.xml.messaging.saaj</groupId>	        
<artifactId>saaj-impl</artifactId>	        
<version>1.3</version>	        
<scope>runtime</scope>	    
</dependency>

</dependency>

<groupId>jaxen</groupId>

<artifactId>jaxen</artifactId>

</dependency>

<groupId>javax.xml.soap</groupId>

<scope>runtime</scope>

</dependency>

<groupId>com.sun.xml.messaging.saaj</groupId>

<scope>runtime</scope>

</dependency>

All’interno del file spring-ws-servlet.xml definiamo il bean che implementa il servizio di RicercaLibro.

<bean id="ricercaLibroEndpoint" class="it.finazzo.libreria.ws.RicercaLibroEndpoint"/>

1	<bean id="ricercaLibroEndpoint" class="it.finazzo.libreria.ws.RicercaLibroEndpoint"/>

Tale classe estende la classe di Spring che gestisce l’integrazione con JDOM

public class RicercaLibroEndpoint extends AbstractJDomPayloadEndpoint {
	protected Element invokeInternal(Element arg0) throws Exception {		return null;
	}
}

public class RicercaLibroEndpoint extends AbstractJDomPayloadEndpoint {

protected Element invokeInternal(Element arg0) throws Exception { return null;

}

Definiti il bean ci preoccupiamo di definire il mapping dei servizi, ovvero quale classe invocare in corrispondenza di uno specifico servizio:

<bean 
class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping">
<property name="mappings">
<props>
<prop key="{http://www.example.org/schema}RicercaLibroRequest">
ricercaLibroEndpoint
</prop>
</props>
</property>
</bean>

<bean

class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping">

<props>

ricercaLibroEndpoint

</prop>

</props>

</property>

</bean>

In questo caso stiamo dicendo al gestore delle mappe dei servizi, la classe implementata da Spring-Ws, che il servizio RicercaLibro deve invocare l’endpoint ricercaLibroEndpoint. Per la gestione del mapping spring-ws offre 2 diverse implementazione da scegliere in base al contesto in cui vi trovate.

PayloadRootQNameEndpointMapping
SoapActionEndpointMapping

Il mapping basato su Payload prevede l’analisi della richiesta per stabilire quale servizio stiamo invocando. Tale meccanismo è più lento ma è indipendente dalla specifica SOA e pertanto può essere usato sia in caso di SOA 1.1, 1.2 o qualsiasi altro livello di trasporto.

Il secondo mapping sfrutta l’header SOAPAction, che permette di individuare il corretto routing senza analizzare tutta la risposta. Pertanto è più veloce ma è valido solo con la SOA 1.1, poichè nella SOA 1.2 tale parametro è stato reso deprecato.

A questo punto non resta che provare il nostro servizio tramite Soap Ui e verificare il corretto funzionamento del routing.

SPRING WS

SPRING WS – TUTORIAL 3 – CREARE IL PROGETTO

18/06/2014 admin

Dopo aver definito il contratto passiamo all’implementazione del nostro server con servizi SOA. Per fare ciò usiamo Maven, che permette di automatizzare parte dei processi nella gestione del nostro sistema

Per chi non conoscesse Maven rimando alla serie di articoli pubblicati nella sezione Documentazione.

Apriamo una shell nella directory che ospita il nostro workspace e lanciamo il seguente comando

mvn archetype:generate 
-DarchetypeGroupId=org.springframework.ws 
-DarchetypeArtifactId=spring-ws-archetype 
-DarchetypeVersion=1.5.9 
-DgroupId=it.finazzo.libreria 
-DartifactId=libreria

mvn archetype:generate

-DarchetypeGroupId=org.springframework.ws

-DarchetypeArtifactId=spring-ws-archetype

-DarchetypeVersion=1.5.9

-DgroupId=it.finazzo.libreria

-DartifactId=libreria

con questo comando stiamo dicendo a maven di creare un nuovo artefatto basato sull’archetipo di spring-ws versione 1.5.9.

A questo punto Maven ha creato una directory con l’alberatura tipica di una web application e i file xml configurati per la sua gestione.

Per semplificare i prossimi step possiamo importare il progetto tramite la direttiva eclipse:eclipse di maven. Troviamo 2 file xml pronti per essere modificati, il classico web.xml dove è definita la servlet preposta a ricevere i messaggi e il file spring-ws-servlet.xml dove definiremo le varie componenti del nostro server.

Nella directory WEB-INF inseriamo il file xsd contenente la struttura dei nostri servizi e nel file spring-ws-servlet.xml definiamo un bean che possa gestirlo.

&lt;bean id="gestioneLibri" 
class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition"&gt;
&lt;property name="schema" ref="schema"/&gt;                                               
&lt;property name="portTypeName" value="Libreria"/&gt;                           
&lt;property name="locationUri" value="/gestioneLibri/webservices"/&gt;                      
&lt;/bean&gt;
&lt;bean id="schema" class="org.springframework.xml.xsd.SimpleXsdSchema"&gt;
&lt;property name="xsd" value="/WEB-INF/schema.xsd"/&gt;
&lt;/bean&gt;

<bean id="gestioneLibri"

class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition">

</bean>

</bean>

Il bean ‘schema’ mappa il file xsd tramite una classe implementata da Spring e il bean ‘gestioneLibri’ si preoccupa di generare il file wsdl a partire dall’analisi dello schema xsd e dalle proprietà definite, secondo quanto indicato nel precedente articolo.

A questo punto tramite la direttiva install creiamo il file war e facciamo il deploy della nostra applicazione su tomcat.

Una volta attivato il contesto il file wsdl sarà disponibile all’indirizzo http://<server>:<port>/<context>/gestioneLibri.wsdl.

Nel prossimo articolo vedremo come gestire le chiamate ai servizi esposti.

SPRING WS

SPRING WS – TUTORIAL 2 – CONOSCERE IL WSDL

18/06/2014 admin

Per generarare il wsdl a partire dal file xsd occorre utilizzare una classe fornita da spring ws che in automatico nel rispetto di determinate convenzioni genera il nostro wsdl.

La classe da utilizzare è la DefaultWsdl11Definition

<bean id="libreria" class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition">
   <property name="schema">
     <bean class="org.springframework.xml.xsd.SimpleXsdSchema">
       <property name="xsd" value="/WEB-INF/libreria.xsd"/>
     </bean>
   </property>
   <property name="portTypeName" value="Libreria"/>
   <property name="locationUri" value="http://localhost:10000/libreria/services"/>
 </bean>

</bean>

</property>

</bean>

L’attributo id determina il nome del wsdl. In questo caso esporrà il wsdl libreria.wsdl
La proprietà schema indica il file da utilizzare per la generazione del file wsdl
le proprietà portTypeName e locationUri indicano i parametri da inserire all’interno del wsdl per la richiesta dei servizi.

La nostra classe genera analizza il file xsd alla ricerca di elementi con il suffisso Request e Response e per ogni elemento individua gli elementi tipici della specifica SOA.

Nel nostro caso il wsdl generato ha la seguente forma

<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
xmlns:sch="http://www.example.org/schema" 
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
  xmlns:tns="http://www.example.org/schema" targetNamespace="http://www.example.org/schema">
<wsdl:types> 
  <schema xmlns="http://www.w3.org/2001/XMLSchema" attributeFormDefault="unqualified" 
  elementFormDefault="qualified" targetNamespace="http://www.example.org/schema">
<complexType name="LibroType">
<sequence>
  <element name="titolo" type="string" />
<element name="nome" type="string" /> 
<element name="cognome"type="string" /> 
</sequence>
  </complexType>
<element name="RicercaLibroRequest">
<complexType>
<sequence>
  <element minOccurs="0" name="titolo" type="string" />
  <element minOccurs="0" name="nome" type="string" />
  <element minOccurs="0" name="cognome" type="string" />
</sequence>
</complexType>
</element>
<element name="RicercaLibroResponse">
<complexType>
<sequence>
  <element maxOccurs="unbounded" minOccurs="0" name="libro" type="string" />
</sequence>
  </complexType>
</element>
</schema>
</wsdl:types>
<wsdl:message name="RicercaLibroResponse">
  <wsdl:part element="tns:RicercaLibroResponse" name="RicercaLibroResponse" />
  </wsdl:message>
<wsdl:message name="RicercaLibroRequest">
  <wsdl:part element="tns:RicercaLibroRequest" name="RicercaLibroRequest" />
  </wsdl:message>
<wsdl:portType name="Libreria">
<wsdl:operation name="RicercaLibro">
  <wsdl:input message="tns:RicercaLibroRequest" name="RicercaLibroRequest" />
  <wsdl:output message="tns:RicercaLibroResponse" name="RicercaLibroResponse" />
  </wsdl:operation>
  </wsdl:portType>
<wsdl:binding name="LibreriaSoap11" type="tns:Libreria">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="RicercaLibro">
  <soap:operation soapAction=" " />
<wsdl:input name="RicercaLibroRequest">
  <soap:body use="literal" />
</wsdl:input>
<wsdl:output name="RicercaLibroResponse">
  <soap:body use="literal" />
  </wsdl:output>
  </wsdl:operation>
  </wsdl:binding>
<wsdl:service name="LibreriaService">
<wsdl:port binding="tns:LibreriaSoap11" name="LibreriaSoap11">
  <soap:address location="http://localhost:10000/libreria/webservice" />
  </wsdl:port>
  </wsdl:service>
  </wsdl:definitions>

<?xml version="1.0" encoding="UTF-8" standalone="no" ?>

<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"

xmlns:sch="http://www.example.org/schema"

xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"

xmlns:tns="http://www.example.org/schema" targetNamespace="http://www.example.org/schema">

<wsdl:types>

<schema xmlns="http://www.w3.org/2001/XMLSchema" attributeFormDefault="unqualified"

elementFormDefault="qualified" targetNamespace="http://www.example.org/schema">

</sequence>

</complexType>

</sequence>

</complexType>

</element>

</sequence>

</complexType>

</element>

</schema>

</wsdl:types>

<wsdl:message name="RicercaLibroResponse">

<wsdl:part element="tns:RicercaLibroResponse" name="RicercaLibroResponse" />

</wsdl:message>

<wsdl:message name="RicercaLibroRequest">

<wsdl:part element="tns:RicercaLibroRequest" name="RicercaLibroRequest" />

</wsdl:message>

<wsdl:portType name="Libreria">

<wsdl:operation name="RicercaLibro">

<wsdl:input message="tns:RicercaLibroRequest" name="RicercaLibroRequest" />

<wsdl:output message="tns:RicercaLibroResponse" name="RicercaLibroResponse" />

</wsdl:operation>

</wsdl:portType>

<wsdl:binding name="LibreriaSoap11" type="tns:Libreria">

<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />

<wsdl:operation name="RicercaLibro">

<soap:operation soapAction=" " />

<wsdl:input name="RicercaLibroRequest">

<soap:body use="literal" />

</wsdl:input>

<wsdl:output name="RicercaLibroResponse">

<soap:body use="literal" />

</wsdl:output>

</wsdl:operation>

</wsdl:binding>

<wsdl:service name="LibreriaService">

<wsdl:port binding="tns:LibreriaSoap11" name="LibreriaSoap11">

<soap:address location="http://localhost:10000/libreria/webservice" />

</wsdl:port>

</wsdl:service>

</wsdl:definitions>

La sezione type presenta i tipi e gli elementi definiti nell’xsd.
La sezione messages presenta tutti i messaggi gestibili dal nostro soa server. La nostra classe ha individuato tanti messaggi quanti sono gli elementi definiti nell’xsd con suffisso Request e Response
La sezione operation presenta i servizi esposti dal server specificando per ogni servizio il messaggio di ingresso e di uscita.
infine la sezione servizi indica a quale url sono disponibili i nostri servizi.

Nel nostro caso la classe ha individuato un solo servizio RicercaLibro che riceve in ingresso la RicercaLibroRequest e restituisce in uscita la RicercaLibroResponse. Tale servizio è disponibile all’url http://localhost:10000/libreria/webservice.

Per poter avere un riscontro agevole di quanto fatto possiamo caricare il nostro wsdl tramite il tool soap ui, ottimo strumento per il testing dei servizi SOA.

Nel prossimo articolo vedremo come mettere in piedi il nostro server con l’aiuto di spring-ws.

SPRING WS

SPRING WS – TUTORIAL 1 – PRIMA IL CONTRATTO

18/06/2014 admin

Vediamo come usare Spring Ws per la realizzazione di un web service.

Spring Ws parte dalla definizione del contratto e solo successivamente affronta il problema dell’implementazione. Il vantaggio di questo approccio è quello di permettere allo sviluppatore di concentrarsi sul design del servizio e solo successivamente sulla stesura del codice.

Scopo di questa serie di articoli è la realizzazione di un web service per la ricerca di un libro da un catalogo. La ricerca del libro avviene per titolo o per cognome dell’autore.

Definiamo prima di tutto la struttura dati utilizzata dal web service.

Per semplificazione la struttura dati del libro è di questo tipo:

<complexType name="LibroType">
<sequence>
<element name="titolo" type="string" maxOccurs="1" minOccurs="1"></element>
<element name="nome" type="string" maxOccurs="1" minOccurs="1"></element>
<element name="cognome" type="string" maxOccurs="1" minOccurs="1"></element>
</sequence>
</complexType>

</sequence>

</complexType>

mentre richiesta e risposta hanno questa struttura

<element name="RicercaLibroRequest"> 
<complexType> <sequence> <element name="titolo" type="string" maxOccurs="1" minOccurs="0"></element> <element name="nome" type="string" maxOccurs="1" minOccurs="0"></element> <element name="cognome" type="string" maxOccurs="1" minOccurs="0"></element> </sequence> </complexType> </element>
<element name="RicercaLibroResponse"> <complexType> <sequence> <element name="libro" type="string" maxOccurs="unbounded" minOccurs="0"></element> </sequence> </complexType> 
</element>

</element>

Definite le strutture dati possiamo definire il wsdl, ovvero il file che descrive il web service in modo completo. Usando Spring ws non è necessario farlo a mano, in quanto è disponibile un modulo che a partire dalla struttura dati indicata sopra può generare il file a runtime. Nel prossimo articolo vedremo la struttura del file per ripassare i concetti sul contratto.

SPRING WS

SPRING WS – INTRODUZIONE

18/06/2014 admin

Spring Web Services è un prodotto della comuntà Spring che permette di creare web services partendo dal contratto. Esso facilita lo sviluppo tramite una gestione più flessibile della creazione dei web services.

Permette di sviluppare ed esporre web services in modo estremamente semplice; la possibilità di godere delle implementazioni di Spring permette agli sviluppatori di concentrarsi sul design dei servizi e riutilizzare le competenze maturate su un modulo basato su spring.

Il motore di Spring Ws consente di disaccoppiare facilmente il contratto dalla sua implementazione, di redirigere le richieste in arrivo verso gli endpoint appropriati in base al contenuto del messaggio, al SOAP header od ad una XPath expression. Inoltre esso consente di integrare le varie librerie per la gestione di file xml in base alle varie esigenze dello sviluppatore.

Supporta la WS-Security e consente di integrare facilmente il modulo Acegi Security, che gestisce la sicurezza dei propri servizi.

I sorgenti di Spring-Ws sono disponibili tramite Maven e pertanto facilmente riusabili nei nostri progetti.

Infine viene rilasciato con licenza Apache, il che permette di poterlo integrare nei nostri progetti salvo indicarlo nei nostri rilasci.

SENCHA GXT

TUTORIAL SENCHA GXT 1 – LAVORARE CON MAVEN

18/06/2014 admin

Iniziamo una serie di articoli dedicati a Ext GWT, più brevemente GXT, il framework sviluppato da Sencha, che consente di estendere le potenzialità della libreria del Google Web Toolkit.

In questo articolo ci preoccupiamo di configurare un progetto GXT usando Maven ed Eclipse come IDE. Per configurare Eclipse occorre scaricare la versione Juno (4.2) , installare il GWT plugin usando l’update site disponibile all’url http://dl.google.com/eclipse/plugin/4.2 e installare m2eclipse tramite l’update site disponibile all’url http://download.eclipse.org/technology/m2e/releases.

Configurato Eclipse realizziamo il nostro primo progetto avvalendoci di maven e dell’archetipo gwt-maven-plugin tramite la direttiva

mvn archetype:generate -DarchetypeGroupId=org.codehaus.mojo -DarchetypeArtifactId=gwt-maven-plugin -DarchetypeVersion=2.5.1 -DgroupId=it.finazzo -DartifactId=sencha -Dversion=1.0

1	mvn archetype:generate -DarchetypeGroupId=org.codehaus.mojo -DarchetypeArtifactId=gwt-maven-plugin -DarchetypeVersion=2.5.1 -DgroupId=it.finazzo -DartifactId=sencha -Dversion=1.0

Tramite questa direttiva maven crea un progetto che supporta l’alberatura di GWT. Durante l’esecuzione della direttiva specifichiamo il nome del modulo principale (nel mio caso Application), ovvero la classe che implementa l’entry point, il punto di accesso alla nostra applicazione.

A questo punto tramite la direttiva mvn gwt:eclipse possiamo generare i file necessari ad effettuare l’import in Eclipse.

Resta da aggiungere la dipendenza da GXT, agendo sul pom.xml e sul file xml associato al modulo entry point.

Aggiungiamo la versione di GXT da usare tramite il tag <gxt.version>3.0.1</gxt.version>

Specifichiamo il repository da cui scaricare i sorgenti di GXT

<repositories>
<repository>
<id>sencha-commercial-release</id>
<name>Sencha commercial releases</name>
<url>https://maven.sencha.com/repo/commercial-release/</url>
</repository>
</repositories>

<id>sencha-commercial-release</id>

<name>Sencha commercial releases</name>

<url>https://maven.sencha.com/repo/commercial-release/</url>

</repository>

</repositories>

E infine aggiungiamo la dipendenza da GXT tramite il blocco

<dependency>
<groupId>com.sencha.gxt</groupId>
<artifactId>gxt</artifactId>
<version>${gxt.version}</version>
</dependency>

<groupId>com.sencha.gxt</groupId>

<version>${gxt.version}</version>

</dependency>

Una volta aggiunta la dipendenza rendiamola attiva nel progetto eclipse tramite la direttiva mvn gwt:eclipse che si preoccuperà di scaricare le nuove librerie.

Resta da modificare il modulo Application.gwt.xml per rimuovere il tema di GWT e innestare l’eredità da GXT tramite il comando

<inherits name="com.sencha.gxt.ui.GXT" />

1	<inherits name="com.sencha.gxt.ui.GXT" />

e linkare il file reset.css nella pagina Application.html tramite la direttiva

<link rel="stylesheet" type="text/css" href="/joomla/Application/reset.css">

1	<link rel="stylesheet" type="text/css" href="/joomla/Application/reset.css">

Nel file Application.java sostituiamo il gwt-button con un oggetto sencha com.sencha.gxt.widget.core.client.button.TextButton e se abbiamo operato correttamente tramite la direttiva mvn gwt:run possiamo verificare che il progetto venga avviato correttamente.

XML

XML TUTORIAL – 6 – USARE XMLBEANS

18/06/2014 admin

Con l’articolo di oggi vediamo in dettaglio come sfruttare una delle librerie più note nella gestione dei file XML, ovvero XMLBEANS dell’Apache Software Foundation.

Questa libreria permette di generare a partire dallo schema XSD tutte le classi per la manipolazione di file xml che rispettino lo schema dato.

Per l’installazione rimando alla guida esauriente presente sul sito di XMLBEANS. Per l’utilizzo vediamo invece quali sono gli step da seguire.

Individuiamo uno schema XSD, da cui generare le nostre classi e scegliamo la struttura libro.

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.example.org/libro" xmlns:tns="http://www.example.org/libro" elementFormDefault="qualified">
<element name="libro" type="tns:LibroType"></element>
<complexType name="LibroType">
<sequence>
<element name="capitolo" type="tns:CapitoloType"
maxOccurs="unbounded" minOccurs="1">
</element>
<element name="autore" type="tns:AutoreType" maxOccurs="unbounded" minOccurs="1"></element>
</sequence>
<attribute name="titolo" type="string" use="required"></attribute>
</complexType>
<complexType name="CapitoloType">
<sequence>
<element name="contenuto" type="string" minOccurs="1" maxOccurs="1"></element>
</sequence>
<attribute name="titolo" type="string" use="required"></attribute>
</complexType>
<complexType name="AutoreType">
<attribute name="Cognome" type="string" use="required"></attribute>
<attribute name="Nome" type="string" use="required"></attribute>
</complexType>
</schema>

<?xml version="1.0" encoding="UTF-8"?>

<element name="capitolo" type="tns:CapitoloType"

maxOccurs="unbounded" minOccurs="1">

</element>

</sequence>

</complexType>

</sequence>

</complexType>

</complexType>

</schema>

Tramite la direttiva scomp posso generare la libreria contenente le classi per la manipolazione dei file.

scomp libro.xsd -out libro.jar -javasource 1.5

1	scomp libro.xsd -out libro.jar -javasource 1.5

Con questo comando dico a XmlBeans di generare un jar che libro.jar secondo gli standard di java 1.5

A questo punto importanto la libreria dentro un qualsiasi progetto posso creare file xml in accordo con lo schema definito o validare dei file xml esistenti.

Lettura File XML

File file = new File("libro.xml");
LibroDocument parse = Factory.parse(file);
LibroType libro = parse.getLibro();

File file = new File("libro.xml");

LibroDocument parse = Factory.parse(file);

LibroType libro = parse.getLibro();

In questo modo posso instanziare un oggetto libro ottenuto dalla lettura del file xml

Creazione File XML

LibroDocument newInstance = Factory.newInstance();
newInstance.addNewLibro();
newInstance.getLibro().setTitolo("titolo");
newInstance.save(new File("libro2.xml"));

LibroDocument newInstance = Factory.newInstance();

newInstance.addNewLibro();

newInstance.getLibro().setTitolo("titolo");

newInstance.save(new File("libro2.xml"));

In questo modo posso creare un file xml a partire dall’oggetto java.

Validazione File XML

Ultimo caso, ma non per questo meno interessante, prevede lo scenario in cui l’utente vuole verificare se il file da analizzare rispetta lo schema e in caso negativo in quali punti non è corretto.

Collection<XmlError> errors = new ArrayList<XmlError>();
XmlOptions options = new XmlOptions();
options.setErrorListener(errors);
newInstance.validate(options);

Collection<XmlError> errors = new ArrayList<XmlError>();

XmlOptions options = new XmlOptions();

options.setErrorListener(errors);

newInstance.validate(options);

www.valeriofinazzo.it

Tutti gli articoli di admin

SPRING WS – TUTORIAL 7 – GESTIRE LE ECCEZIONI

SPRING WS – TUTORIAL 6 – USARE GLI INTERCEPTOR

SPRING WS – TUTORIAL 5 – USARE IL MARSHALLING

SPRING WS – TUTORIAL 4 – MAPPING DEI SERVIZI

SPRING WS – TUTORIAL 3 – CREARE IL PROGETTO

SPRING WS – TUTORIAL 2 – CONOSCERE IL WSDL

SPRING WS – TUTORIAL 1 – PRIMA IL CONTRATTO

SPRING WS – INTRODUZIONE

TUTORIAL SENCHA GXT 1 – LAVORARE CON MAVEN

XML TUTORIAL – 6 – USARE XMLBEANS

Il sito dell'ingegnere Valerio Finazzo