Archivi tag: spring

TUTORIAL JHIPSTER – PRIMI PASSI

Durante la fase di scouting per valutare nuovi framework e nuove librerie mi sono imbattuto in JHIPSTER. Si tratta di una piattaforma di sviluppo che consente di generare una applicazione con quello che gli autori reputano il meglio che il panorama offre. Nel momento in cui scrivo la versione è la 4.14.0, che permette di realizzare una webapp basata su Spring Boot 1.5 e Angular 5, mentre la versione 5, già annunciata, promette il passaggio a Spring Boot 2 e l’introduzione di React  per il client e la rimozione di Angular JS. JHIPSTER ha vinto il Duke’s Choice Award 2017  e si è classificato terzo al JAX Innovation award nella categoria maggior innovazione per l’ecosistema JAVA.

Avvicinarsi a JHIPSTER ci da il vantaggio di vedere concentrato il top delle tecnologie a disposizione del mondo JAVA e ci da l’opportunità di assemblarle riducendo al minimo i tempi di creazione della applicazione. Partiamo subito e tiriamo su il nostro primo  progetto. Per usare JHIPSTER abbiamo sei approcci possibili:

  • JHipster Online è un tool online che ti guida nella creazione dell’app, va bene come prova ma allo stato attuale non consente di gestire modifiche successive
  • “Locale con YARN” è la modalità suggerita dagli autori. Si basa su YARN , che  è il package manager sviluppato da facebook basato su NPM.
  • “Locale con NPM” è identica alla precedente, ma usa NPM il package manager di Node.js.
  • “Installazione tramite package manager” è ancora in beta
  • “Box Vagrant” è disponibile una macchina virtuale che contiene tutti gli strumenti necessari.
  • Docker” è disponibile un container docker contenente gli strumenti necessari

Usiamo la modalità consigliata e seguiamo i seguenti passi:

  • Installiamo Java 8
  • Installiamo Node.js
  • Installiamo Yarn
  • installiamo Yeoman tramite il comando: yarn global add yo. Yeoman è un tool che consente di creare la struttura base di una app.
  • installiamo JHipster tramite il comando: yarn global add generator-jhipster

Seguendo questi step siamo in grado di creare la nostra app con front-end Angular, qualora volessimo usare AngularJS dobbiamo aggiungere altri due step:

  • Installare Bower: yarn global add bower. Bower è un package manager rimasto in maintenance, ormai sostituito da YARN e WEBPACK.
  • Installare Gulp: yarn global add gulp-cli. Gulp è un task manager.

A questo punto non resta che creare la nostra prima applicazione. Creiamo una directory e al suo interno lanciamo il comando: jhipster

E qui inizia il bello. Jhipster ci interroga sulle caratteristiche che vogliamo e il gioco è fatto, alla fine abbiamo una applicazione correttamente funzionante, da poter importare nel nostro editor preferito.

Per vederla funzionante lanciate il comando mvnw, che tirerà su il progetto su porta 8080.

SPRING WS – TUTORIAL 10 – USARE LA VERSIONE 2.0

La versione 2.0 di Spring-ws introduce la dipendenza da Spring 3.0 e spinge verso l’uso delle annotation, lasciando il supporto deprecato delle classi che abbiamo imparato a conoscere nei precedenti articoli-

In questo articolo vedremo le nuove feature introdotte da Spring-ws.

Partiamo dalla creazione del progetto, che si avvale dei nuovi archetipi rilasciati da spring-ws e vediamo come creare il solito webservice per la libreria.

Con la direttiva indicata Spring-ws crea la directory libreriaservice

Spostiamoci all’interno della cartella e creaiamo la struttura per il nostro IDE tramite la direttiva mvn eclipse:eclipse. A questo punto possiamo importare il progetto in Eclipse. Come si può notare nel file xml associato al dispatchet spring-servlet.xml è stata esplicitata la dipendenza dalle annotation, tramite il tag <sws:annotation-driven/>

Recuperiamo lo schema xsd che abbiamo creato nei precedenti articoli e lo copiamo sotto la cartella resources.

Definiamo  il bean che si occupa della generazione del wsdl tramite il seguente tag

A questo punto definiamo l’endpoint che si preoccupa di gestire il servizio di Ricerca Libro. Nella definizione degli endpoint si cambia approccio, mentre prima il mapping veniva gestito tramite file xml, adesso tutto è demandato alle annotation:

l’annotazione @Endpoint definisce che una classe è un endpoint

l’annotazione @Autowired definisce il costruttore della costruttore qualora sia necessario fare l’injection di alcuni parametri

l’annotazione @PayloadRoot(localPart = “RicercaLibroRequest”, namespace = “http://finazzo.it/libreria/schema”) definisce la regola di mapping dell’endpoint

Una volta definiti gli endpoint passiamo alla definizione del mapping degli endpoint, tramite la classe PayloadRootAnnotationMethodEndpointMapping

Questa è la classe responsabile di instradare i messaggi verso l’opportuno endpoint in base all’analisi del messaggi soap ricevuti e le regole definite di attivazione definite tramite annotation.

Qui trovate l’archetipo estratto dal progetto appena descritto, in modo da poter provare di persona quanto fatto.

SPRING WS – TUTORIAL 9 – GESTIONE CLIENT

Nell’articolo di oggi vedremo le API che Spring-Ws mette a disposizione per la realizzazione di un client.
Alla base di tutto vi è la classe WebServiceTemplate che offre i metodi per l’invio e la ricezione dei messagi.I messaggi possono essere inviati e ricevuti come puro stream oppure possono essere soggetti al processo di marshalling e unmarshalling.

Occorre prima di tutto definire il nostro client nei file di configurazione di Spring, tramite la solita definizione di bean.

La property defautUrl indica la URL dei servizi da invocare, mentre la messageFactory individua la classe responsabile della generazione dei messaggi da inviare.

Come factory Spring mette a disposizione 2 implementazioni:

  • SaajSoapMessageFactory basata su SAAJ
  • AxiomSoapMessageFactory basata su Axiom

In assenza del valore Spring userà di default l’implementazione basata su SAAJ.

Nei file xml di Spring-Ws setteremo la factory desiderata come

A questo possiamo sfruttare il nostro client per invocare il servizio e gestirne il risultato.

In source è disponibile il messaggio nel formato atteso dal servizio remoto e nella System.out verrà riversato la risposta del server.

Invocazione coclusa con minimo sforzo. A questo punto andrebbe analizzata la risposta per gestire le nuove azioni da intraprendere.

Come ulteriore aiuto Spring-Ws ci da la possibilità di sfruttare le tecniche di marshalling e unmarshalling per ottenere degli oggetti già pronti per l’uso.

Per fare cià occorre valorizzare il marshaller e l’unmarshallere all’interno del nostro client.

Per la defizione del marshaller si rimanda all’articolo dedicato.

Definito il marshaller e l’unmarshaller verrà usato il seguente metodo che restituisce un oggetto valorizzato

dove requestPayload è il bean che descrive la richiesta del sistema opportunamente valorizzata.

Nel caso in cui dobbiate gestire gli header SOAP dovete definire una classe che implementi l’interfacciaWebServiceMessageCallback.

Tale interfaccia definisce il metodo public void doWithMessage(WebServiceMessage message) che consente di modificare il messaggio prima del suo invio al server.

In questo caso invocherete il metodo

SPRING WS – TUTORIAL 8 – AUTENTICAZIONE

Una volta creati i nostri servizi ci preoccuperemo di applicare delle policy di sicurezza al fine impedirne l’utilizzo a utenti non autorizzati

Le policy di sicurezza si basano su 3 aspetti:

  • l’autenticazione
  • la firma
  • la crittografia

Implementando meccanismi di autenticazione si limita l’accesso ad utenti conosciuti dal sistema, con l’utilizzo della firma si certifica un contenuto e con la crittografia si trasforma il flusso di dati in un flusso impossibile da leggere senza l’opportuna chiave.

Nell’articolo di oggi vedremo gli strumenti che offre Spring-ws per gestire l’autenticazione.

Spring-ws mette a disposizione 2 implementazioni dell’interfaccia Interceptor:

  • XwsSecurityInterceptor basato sull’implementazione della SUN XWSS Xml and Web Service Security
  • Wss4jSecurityInterceptor basato sull’implementazione di Apache WSS4J
Per iniziare vedremo il caso di autenticazione più semplice, ovvero quello che prevede di inviare come header della soap un tag chiamato UsernameToken che prevede 2 attributi in chiaro contenenti username e password.
E’ un meccanismo molto semplice da usare che va abbinato ad altre tecniche come la crittografia, visto che l’invio in chiaro dei dati di accesso non è cosa bella.
Scegliamo di usare l’implementazione XwsSecurityInterceptor, che prevede la definizione di un file contenente le policy di sicurezza.
All’interno del file definiamo la regola di sicurezza

Stiamo dicendo al nostro modulo che ogni richiesta per essere accettata deve contenere il token UsernameToken, che la password non deve essere crittografata e che non è richiesto il nonce. Per maggiori dettagli sugli attributi del token Username rimando alle specifiche di SUN. Per informazioni sul Nonce ripassate concetti di crittografia.

A questo punto definiamo l’interceptor e le sue regole

Il nostro interceptor carica le regole da applicare dal file di policy definito precedentemente, mentre con il bean passwordValidationHandler definiamo gli utenti che possono accedere ai nostri servizi, in questo caso username/password Valerio/Finazzo

Qualora nella nostra richiesta non sia presente il token usernameToken il server genera un FAULT specificando l’errore.
Per testare quanto fatto consiglio SoapUi con cui potete creare agevolmente le request e aggiungere gli header per la sicurezza, ottenendo qualcosa del genere

Nel prossimo articolo vedremo tecniche più avanzate per gestire l’autenticazione.

SPRING WS – TUTORIAL 7 – GESTIRE LE ECCEZIONI

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.

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.

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

e aggiungendo tra i bean di Spring l’opportuna implementazione

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 – TUTORIAL 6 – USARE GLI INTERCEPTOR

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.

SPRING WS – TUTORIAL 5 – USARE IL MARSHALLING

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

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


e definire le resources


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:

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

SPRING WS – TUTORIAL 4 – MAPPING DEI SERVIZI

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:

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

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

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

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 – TUTORIAL 3 – CREARE IL PROGETTO

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

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.

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 – TUTORIAL 2 – CONOSCERE IL WSDL

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

  • 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

 

  • 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.