1. 1
Universit degli Studi dellAquila
Master in Web Technology
TECNOLOGIE XML E
SERVICE ORIENTED ARCHITECTURES
A.A. 2013/14
Docente: Giuseppe Della Penna
Studente Matricola Email
SilvioDOrazio 234422 silvio.dorazio@gmail.com
SoniaBarbieri barbieri.sonia@gmail.com
AlessandraPonis 234457 alessadra.ponis@gmail.com
2. 2
Indice
Tecnologie XML...................................................................................................................................... 3
Specifiche dellapplicazione................................................................................................................. 3
Parte I: ePubPackager........................................................................................................................ 3
Parte II:ePub Biblio............................................................................................................................. 5
La persistenza dati di ePUB Manager ................................................................................................... 6
Limiti dellapplicazione........................................................................................................................ 6
Architettura dellapplicazione.............................................................................................................. 6
Service Oriented Architectures................................................................................................................ 7
Adattamento di ePUB Manager ad unarchitettura SOA ........................................................................ 7
Il servizio web di alto livello................................................................................................................. 8
La descrizione formale del WSDL...................................................................................................... 8
Il servizio web di basso livello .............................................................................................................16
3. 3
Progetto ePUB Manager
Tecnologie XML
Specifiche dellapplicazione
Il sitoePUB Managercostituisce uninterfaccia web per la gestione di file ePub, abbrevazione che sta per
electronic publication, ovvero un formato file molto noto basato su uno standard aperto per la
pubblicazione degli ebook.
Ogni file .epub costituisce un file compresso che contiene svariati file e directory, ciascuno dei quali ha
caratteristiche specifiche, che permettono il funzionamento di una pubblicazione.
Linterfaccia utente permette di accedere tramite un men湛 globale alle due funzionalit principali
dellapplicazione: l impacchettatore di ePub e il micro gestore di una sorta di biblioteca per ePub.
Il progettosi divide,infatti, indue parti principali:
- la prima parte 竪 incentrata sulla realizzazione e il funzionamento di un piccolo sistema di
impacchettamentoperePub.Si trattadi un processodi creazione dellePubche parte dallupload
dei file che costituiranno i contenuti della pubblicazione e termina con la generazione dei file
necessari alla costruzione di un file con estensione .epub completo.
- La seconda parte 竪, invece, incentrata sulla realizzazione di una mini biblioteca per ePub gestita
tramite lapplicazione e salvata su File System. Tale sistema, al contrario di quello descritto nel
puntoprecedente, si basa sul processo contrario partendo da un file gi compresso che viene poi
decompresso per essere analizzato da parte del sistema.
Qualsiasi utente pu嘆 accedere alle funzionalit del sito, indistintamente.
Parte I: ePub Packager
Di seguitovengono elencate le funzionalit della prima parte del sito:
- Accedendoallinterfacciautentedel Packagerper ePub, lutente pu嘆 inserire i metadati principali
relativi allePub che verr successivamente creato e che serviranno per la creazione del file
4. 4
content.opf.Tali metadativengonovalidati perverificare se aderiscono alle specifiche e salvati sul
database relazionale;
- Una volta aver inserito i metadati, allutente viene richiesto di caricare dal File System: i file che
costituiranno i capitoli dellePub(si trattadi file con estensione .html o .xhtml che prima di essere
resi persistentiallinternodel DBvengonoopportunamente validati), i file .css per le impostazioni
sullo stile e le immagini. Tali file vengono salvati sia nel database che nel File System per poter
essere utilizzati in seguito;
- Una voltaaver inseritoi file necessari, lutente viene rimandato verso una pagina che contiene la
listadei file xhtml (perciascunfile vengonoriportati:lid,il nome,il path,lindice perlordinamento
e il tipo),lalistadei fogli di stile e delle immagini caricate (nel caso dei csse delle immagini vengono
riportati soltanto:lid,il nome e il pathpoich辿 lagestione dellordinamentoviene fattasoltanto per
i file con estensione .xhtml). Tali file possono essere, tramite questa interfaccia, modificati o
eliminati nel caso in cui lutente voglia cambiare i contenuti dellePub prima della creazione
definitiva. E, inoltre, possibile tramite la stessa interfaccia aggiungere nuovi file;
- Nel caso in cui lutente cerca di aggiungere nuovi file xhtml, il sistema applica sia un controllo di
validit che un controllo per verificare se il file era stato gi inserito in precedenza per evitare di
farlo uploadare nuovamente;
- Se nel passo precedente lutente ha cliccato su Modifica, nel caso di un file xhtml, viene
rimandato verso una form dove poter eventualmente modificare il nome del file, lindice (per
gestire lordinamento trai capitoli) e il tipo(il tipodeve,per嘆,essere necessariamente unodi quelli
accettati dalle specifiche standard per la corretta costruzione della guide, per questo linterfaccia
suggerisce allutentequal 竪 lalistadei tipi conformi alle specifiche); i file csse le immagini vengono
modificati allo stesso modo ad eccezione per lordinamento.
Se invece lutente ha cliccato su Elimina, viene reindirizzato verso una form che permette di
eliminare definitivamente il file;
- Cliccando su crea EPUB, vengono creati i file e le cartelle che costituiscono le componenti
dellePub (la cartella META-INF con allinterno il file container.xml, il file toc.ncx e il file
content.opf), viene creato il file finale compresso e lo stesso viene salvato sul File System
dellutente;
- Allafine del processo,lutente viene rimandatosuuna nuova vista dove gli sar possibile scaricare
sul proprio computer il file compresso precedentemente creato.
5. 5
Parte II: ePub Biblio
Di seguitosono elencatele funzionalitdellasecondaparte del progetto:
- Tramite linterfaccia utente 竪 possibile uploadare uno o pi湛 file .epub contemporaneamente, il
quale/i quali vengonosalvatiinunappositorepository sul File Systemdellutente; nella fattispecie,
ad ogni upload il programma genera una cartella chiamata con lid dellePub contenente i relativi
file dopoche lostesso竪 stato decompresso edinserisce il filezippato allinternodi una cartella che
raccoglie gli ePub uploadati;
- Una voltache ciascunePub竪 statoinseritoininput,ne viene estrapolata una serie di informazioni
dai metadati contenuti allinterno del file content.opf, tra cui: titolo, lingua, isbn, autore, editore,
formato,origine, tipo, data, collaboratore, relazione, diritti dautore, destinazione, descrizione e
soggetto;oltre a questi dati,vieneinseritoanche il percorsodel file .epub presente allinterno del
File System dellutente. Tali informazioni vengono registrate allinterno di un file xml chiamato
EPubBiblio.xml, che viene creato dal programma una volta che il primo ePub viene inserito
allinterno della biblioteca e che conterr i metadati relativi a tutti gli ePub presenti nella stessa;
- Il file appenadescritto,oltre araccogliere i metadati dei file, riporta anche le statistiche relative al
numero di capitoli in ciascun ePub, al numero di parole presenti in tali capitoli, al numero di
immagini contenute allinterno del file .epub e alle statistiche riguardanti la frequenza di ciascun
autore registrato allinterno della biblioteca;
- Dallinterfaccia utente dellapplicazione 竪 possibile visualizzare lelenco degli ePub presenti
allinterno della biblioteca organizzati allinterno di una tabella, sincronizzata con il file
EPubBiblio.xml, che riportale informazioni principalidegli stessi, quali: id, titolo, autore, lingua ed
editore;
- Tramite la tabella竪 possibile inoltre effettuare, per ciascun ePub, due azioni: il download del file
registratoallinternodel repositorynel FileSystemdellutente e leliminazione del file ePub dalla
biblioteca (tale eliminazione 竪 stata implementata tramite la definizione di un algoritmo
abbastanza complesso che gestisce non solo la rimozione di un file e dei relativi file dopo la
decompressione quanto anche la rimozione del nodo dellePub dal file ePubBiblio e
laggiornamento delle statistiche sugli autori);
- Infine, dallinterfaccia utente 竪 possibile accedere ad una pagina che costituisce loutput della
trasformazione XSLT del file xml ePubBiblio in un file con estensione .xsl.
Tale paginariporta lelencodegliebooksottoformatabellare (titolo, autore, lingua, numero delle
immagini, delle parole e dei capitoli presenti allinterno di ciascun file .epub nonch辿 il percorso
dello stesso) pi湛 una tabella delle statistiche che presenta il numero di ePub registrati nella
biblioteca pi湛 il nome dellautore che 竪 presente con maggior frequenza.
6. 6
La persistenza dati di ePUB Manager
La prima parte dellapplicazione gestisce la persistenza dei dati facendo affidamento sul database
relazionale MySql, aspetto che ha reso la definizione dellarchitettura orientata ai servizi (SOA)
posteriormente realizzata sulla base di questo stesso progetto altamente flessibile. La connessione al
database viene fornitadal driverJDBCconfiguratoallinternodelprogettotramite il tag <Context>presente
nel file content.xml:
<?xml version="1.0" encoding="UTF-8"?>
<Context antiJARLocking="true" path="/EPUBManager">
<Resource driverClassName="com.mysql.jdbc.Driver"
factory="org.apache.tomcat.jdbc.pool.DataSourceFactory" logAbandoned="true" maxActive="100"
maxIdle="30" maxWait="50000" name="jdbc/EPUBManager" password="" removeAbandoned="true"
removeAbandonedTimeout="90" scope="Container" testWhileIdle="true"
timeBetweenEvictionRunsMillis="50000" type="javax.sql.DataSource"
url="jdbc:mysql://localhost:3306/epubmanager" username="root" validationQuery="select 1"/>
</Context>
Limiti dellapplicazione
- La prima parte del progetto gestisce la creazione di ePub conformi alla specifica 2.0.1 mentre la
seconda parte del progetto consente di gestire entrambe le versioni 2.0.1 e 3.0.1. Questultima
costituisce la versione attuale dello standard per la pubblicazione dei libri digitali;
- La seconda parte del progetto gestisce la persistenza dei dati su File System piuttosto che su un
database relazionale;
Architettura dellapplicazione
Lapplicazione 竪 stata implementata in base al pattern architetturale MVC e con laiuto del framework
Spring nella versione 3.2.8 il quale, tramite luso delle annotazioni, 竪 stato di fondamentale importanza
poich辿 ha permesso di gestire con estrema facilit le richieste web e di costruire un sistema altamente
flessibile.
Allafine di ogni processodi gestionedelle richieste http, loutput viene renderizzato allutente tramite la
tecnologia per implementare le view nota come JavaServerPages.
In realt la costruzione della vista, e dunque delle jsp, viene delegata ad Apache Tiles: un framework di
templating atto ad assemblare frammenti di una pagina e a costruire la pagina stessa a tempo di
esecuzione.
7. 7
Service Oriented Architectures
Adattamento di ePUB Manager ad unarchitettura SOA
LapplicazioneePUBManagercreataperil corso di Tecnologie XML 竪 stata successivamente riadattata per
il corso di SOA, Service Oriented Architectures. Per architettura orientata ai servizi si intende una tipologia
di sistemadistribuito basatosul protocollohttpe sullainterconnessione di agenti software che fornisconoe
usanouna serie di servizi. Il fatto che si stabilisca una comunicazione tra le varie componenti implica uno
scambio di messaggi e conseguentemente la presenza di una serie di meccanismi di comunicazione che
permettono lo scambio di tali messaggi.
Per realizzare una SOA di alto livello, ovvero caratterizzata da SOAP come formalismo per il trasporto dei
dati,竪 stata inizialmente realizzata una descrizione standard in WSDL per definire la struttura del servizio
webfacendousodel tool SOAEditor,il quale hapermessodi generare il codice in automatico.
Una voltadefinitoil WSDL, 竪 stato possibile realizzare il relativoserviziowebutilizzandolatecnologiaSundi
JAX-WS, laquale hacompilatoil file .wsdl incorporato allinterno del progetto e si 竪 creata delle strutture
dati java che corrispondono ai tipi dichiarati programmaticamente allinterno della descrizione della
strutturadel servizio.JAX-WS竪 unostrumentomoltoefficace che hapermesso di facilitare ampiamente la
programmazione del servizio web.
Dopo averconfigurato laparte server,ovveroquella che espone allesternoi metodidellalogicadi business
tramite uninterfaccia,竪 statodefinitounclientstand-alone persimulare le chiamate alla business logic. Il
client 竪 costituito da uninterfaccia proxy che permette di invocare i metodi remoti.
Durante la creazione del client, 竪 stato necessario specificare lindirizzo del WSDL generato da JAX-WS ed
esposto dal servizio al quale lapplicazione stand-alone si 竪 potuta connettere.
E stato,inoltre, opzionalmente realizzatouna sorta di servizio web RESTful di modo da simulare anche un
servizio di bassissimo livello (al contrario di quello di massimo livello realizzato con JAX-WS).
8. 8
Il servizio web di alto livello
La descrizioneformaledel WSDL
E stato gi precedentemente accennato uno degli standard fondanti dei servizi web basato su XML: il
WSDL (Web Services Definition Language). Di seguito viene riportato il contenuto del file ePub.wsdl per
mostrare come tale specifica竪 statautilizzataperdefinire formalmente il servizio web dellePUB Manager:
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions
name="ePub"
targetNamespace="http://www.univaq.it/mwt/soa/ePub.wsdl"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:tns="http://www.univaq.it/mwt/soa/ePub.wsdl"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsd1="http://www.univaq.it/mwt/soa/ePub.xsd1"
xmlns:xsd2="http://www.univaq.it/mwt/soa/ePub.xsd2">
<wsdl:documentation xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">SOA: WSLD del progetto
ePubManager</wsdl:documentation>
<wsdl:types>
<xsd:schema
targetNamespace="http://www.univaq.it/mwt/soa/ePub.xsd2"
xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsd2="http://www.univaq.it/mwt/soa/ePub.xsd2">
<xsd:complexType name="tMetadata">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="1" name="identifier"
type="xsd:string"/>
<xsd:element maxOccurs="1" minOccurs="1" name="title" type="xsd:string"/>
<xsd:element maxOccurs="1" minOccurs="1" name="language" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="tEpubCss">
<xsd:sequence>
<xsd:element maxOccurs="1" minOccurs="1" name="id" type="xsd:string"/>
16. 16
</wsdl:service>
</wsdl:definitions>
Le operazioni di base definite nel WSDLsono:
- startEpub;
- addXhtml;
- addStylesheet;
- addImage;
- finalizeEpub;
- removeXhtml;
- removeStylesheet;
- removeImage;
Il servizio web di basso livello
Come gi accennatoinprecedenza,lapplicazione 竪 stataimplementata con lausilio del framework Spring
che ha consentito,trale altre cose,di simulare un servizioweb RESTful che pubblicai metodi della logica di
businesse permette di effettuare delleoperazionisui dati del sistema tramite una semplice gestione delle
url; ciascuna url (composta da vari path che identificano le risorse) corrisponde ad un metodo particolare
del servizio.
Essendoil RepresentationalStateTransferProtocolil modobase di comunicare offerto dal protocollo http,
ciascunarichiestaviene gestita utilizzandounodei metodi di base per operare sui dati del protocollo: GET,
POST e DELETE.
Di seguitovieneriportatalaclasse annotata tramite lannotazione @Controller che permette di gestire le
richieste http provenienti dal browser:
@Controller
@RequestMapping("/rest")
public class RESTController {
@Autowired
private EPubService service;
17. 17
@RequestMapping(value="/epubs",method={RequestMethod.POST})
@ResponseBody
public String startEpub (Metadata metadata) {
long result = service.startEpub(metadata);
return Long.toString(result);
}
@RequestMapping(value="/epubs/{token}",method={RequestMethod.GET})
@ResponseBody
public void finalizeEpub (@PathVariable("token") String epub) {
long token = Long.parseLong(epub);
service.finalizeEpub(token);
}
@RequestMapping(value="/epubs/{token}/texts",method={RequestMethod.POST})
@ResponseBody
public int insertXhtml (@PathVariable("token") String epub, @RequestBody EpubXhtml epubXhtml) {
long token = Long.parseLong(epub);
int xhtml = service.addXHTML(token, epubXhtml);
return xhtml;
}
@RequestMapping(value="/epubs/{token}/texts/{id}",method={RequestMethod.GET})
@ResponseBody
public EpubXhtml getXhtml (@PathVariable("id") String id) {
// long token = Long.parseLong(epub);
EpubXhtml xhtml = service.getEpubXhtmlByPk(id);
if (xhtml == null) {
throw new NotFoundException();
}
return xhtml;
}
18. 18
@RequestMapping(value="/epubs/{token}/texts/{id}",method={RequestMethod.DELETE})
@ResponseBody
public void deleteXhtml (@PathVariable("token") String epub, @PathVariable("id") String id) {
// long token = Long.parseLong(epub);
EpubXhtml xhtml = service.getEpubXhtmlByPk(id);
if (xhtml == null) {
throw new NotFoundException();
}
service.deleteEpubXhtml(xhtml);
}
@RequestMapping(value="/epubs/{token}/images",method={RequestMethod.POST})
@ResponseBody
public int insertImage (@PathVariable("token") String epub, @RequestBody EpubImage epubImage) {
long token = Long.parseLong(epub);
int image = service.addImage(token, epubImage);
return image;
}
@RequestMapping(value="/epubs/{token}/images/{id}",method={RequestMethod.GET})
@ResponseBody
public EpubImage getImage (@PathVariable("id") String id) {
// long token = Long.parseLong(epub);
EpubImage image = service.getEpubImageByPk(id);
if (image == null) {
throw new NotFoundException();
}
return image;
}
@RequestMapping(value="/epubs/{token}/images/{id}",method={RequestMethod.DELETE})
@ResponseBody
public voiddeleteImage (@PathVariable("token") String epub, @PathVariable("id") String id, EpubImage epubImage) {
19. 19
// long token = Long.parseLong(epub);
if (epubImage == null) {
throw new NotFoundException();
}
service.deleteEpubImage(epubImage);
}
@RequestMapping(value="/epubs/{token}/stylesheets",method={RequestMethod.POST})
@ResponseBody
public int insertCss (@PathVariable("token") String epub, @RequestBody EpubCss epubCss) {
long token = Long.parseLong(epub);
int css = service.addStylesheet(token, epubCss);
return css;
}
@RequestMapping(value="/epubs/{token}/stylesheets/{id}",method={RequestMethod.GET})
@ResponseBody
public EpubCss getCss (@PathVariable("id") String id) {
// long token = Long.parseLong(epub);
EpubCss css = service.getEpubCssByPk(id);
if (css == null) {
throw new NotFoundException();
}
return css;
}
@RequestMapping(value="/epubs/{token}/stylesheets/{id}",method={RequestMethod.DELETE})
@ResponseBody
public void deleteCss (@PathVariable("token") String epub, @PathVariable("id") String id, EpubCss epubCss) {
// long token = Long.parseLong(epub);
if (epubCss == null) {
throw new NotFoundException();
}
