Università degli Studi di ROMA
Facoltà di Ingegneria
Corso di Laurea Triennale in Ingegneria Informatica
ANNO ACCADEMICO 2008 - 2009
TESI DI LAUREA:
Reingegnerizzazione di un applicativo web:
Monopoli on-line
RELATORE:
LAUREANDO:
Prof. Giuseppe Santucci
Andrea Mancini
Matricola: 796867
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
INDICE
Introduzione ......................................................................................................................................... 1
Scenario applicativo ......................................................................................................................... 2
Obiettivo dello stage ........................................................................................................................ 4
Motivazioni ...................................................................................................................................... 4
1
Le applicazioni e i Frameworks utilizzati .................................................................................... 5
2
Requisiti utente .......................................................................................................................... 17
2.1
Specifiche di portata........................................................................................................... 17
2.2
Specifiche di dettaglio ........................................................................................................ 17
2.3
Specifiche consegnate ........................................................................................................ 17
3
Modellazione del dominio ......................................................................................................... 18
3.1
Analisi del testo .................................................................................................................. 18
3.1.1
Actors ......................................................................................................................... 18
3.1.2
Dominio dei dati......................................................................................................... 18
3.1.3
Requisiti funzionali .................................................................................................... 18
3.2
Class Diagram di dominio.................................................................................................. 20
3.3
State Diagram ..................................................................................................................... 21
3.4
Use Case Diagram a basso livello ...................................................................................... 22
3.5
Descrizione Use Case Diagram.......................................................................................... 23
3.6
Use Case Diagram ad alto livello ....................................................................................... 23
4
Pianificazione ............................................................................................................................. 36
4.1
Pianificazione del progetto................................................................................................. 36
4.1.1
Function point ............................................................................................................ 36
4.1.2
La metodologia .......................................................................................................... 36
4.1.3
Pert ............................................................................................................................. 38
4.1.4
Gantt ........................................................................................................................... 39
5
Disegno del sistema ................................................................................................................... 40
5.1
Architettura Hardware........................................................................................................ 40
5.1.1
Server ......................................................................................................................... 40
5.1.2
Client .......................................................................................................................... 40
5.1.3
Piattaforma di sviluppo .............................................................................................. 41
5.2
Architettura Software ......................................................................................................... 42
5.3
Progetto della base di dati .................................................................................................. 43
5.3.1
Progettazione concettuale .......................................................................................... 43
5.3.1.1 Schema ER ............................................................................................................. 43
5.3.1.2 Scelte critiche effettuate nella fase di progettazione .............................................. 44
5.3.2
Progettazione logica ................................................................................................... 44
5.3.2.1 Ristrutturazione schema ER ................................................................................... 44
5.3.2.2 Schema ER ristrutturato ......................................................................................... 44
5.3.2.3 Schema logico ........................................................................................................ 45
5.3.2.4 Vincoli .................................................................................................................... 46
5.3.2.5 Politiche di cancellazione....................................................................................... 46
5.3.2.6 Viste ....................................................................................................................... 46
5.3.2.7 Creazione del DB con popolamento tabelle ........................................................... 47
5.4
Prototipazione .................................................................................................................... 56
5.4.1
Prototipo freddo ......................................................................................................... 56
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
i
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5.4.2
Schema di navigazione del sito tramite ADM (Araneus Data Model) ...................... 57
5.5
Design model ..................................................................................................................... 59
5.5.1
Implementation model ............................................................................................... 59
5.5.1.1 Component diagram ............................................................................................... 59
6
Implementazione ........................................................................................................................ 60
6.1
Introduzione ....................................................................................................................... 60
6.2
Pagine web ......................................................................................................................... 60
6.2.1
Template grafico ........................................................................................................ 60
6.2.2
Motivazioni delle scelte generali ............................................................................... 62
6.2.3
Stile ............................................................................................................................ 62
6.2.4
Sfondo ........................................................................................................................ 62
6.2.5
Immagini varie ........................................................................................................... 62
6.2.6
Scelte implementative ................................................................................................ 62
6.3
Problemi riscontrati ............................................................................................................ 63
6.3.1
Eclipse ........................................................................................................................ 63
7
Manuale d’installazione ............................................................................................................. 64
7.1
Operazioni preliminari ....................................................................................................... 64
7.1.1
Installazione Java Virtual Machine: JDK 1.6 ............................................................. 64
7.1.2
Installazione DBMS: MySQL 5 ................................................................................. 64
7.1.3
Installazione Web Server: Apache TomCat 6 ............................................................. 65
7.2
Installazione ....................................................................................................................... 66
7.2.1
Avvio del DBMS ........................................................................................................ 66
7.2.2
Creazione e popolamento del database ...................................................................... 66
7.2.3
Copia dei contenuti web ............................................................................................. 67
7.2.4
Avvio del Web Server ................................................................................................ 67
7.2.5
Lanciare applicazione ................................................................................................ 67
7.2.6
Primo accesso (Log-in / Registrazione) ..................................................................... 68
7.3
Utilizzo dell’applicazione .................................................................................................. 68
8
Commenti e ringraziamenti ........................................................................................................ 69
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
ii
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Introduzione
La reingegnerizzazione (“reengineering”) è un metodo utilizzato in campo manageriale per
sopperire a risultati insoddisfacenti. Ciò avviene ripensando l'azienda per processi orizzontali e
riprogettando gli stessi processi secondo precisi standard di efficienza. Le aziende riprogettando i
loro processi possono ottenere miglioramenti durevoli di costo, efficienza e qualità.
Nel nostro caso si tratta di reingegnerizzazione di un sito web.
Un sito web fa parte del patrimonio di una azienda: visitatori fidelizzati, applicazioni tagliate sulle
esigenze aziendali, investimenti già effettuati creano un valore che è necessario preservare nel
tempo.
Allo stesso tempo, però, il sito è uno strumento di business e deve condurre al raggiungimento di
risultati concreti: spesso siti web "obsoleti" hanno necessità di essere riprogettati.
Lo scopo è di mostrare come lo sviluppare in un linguaggio di programmazione (ad esempio Java)
possa cambiare nel corso del tempo.
Con l’intervento dell’ingegneria del software si è iniziato a dare delle regole, un determinato ordine
nel programmare, definendo vari paradigmi di sviluppo di un software, come ad esempio il modello
MVC (Model View Controller). Da tale approccio si sono poi aggiunti i cosiddetti Frameworks che
oltre a proporre il loro MVC aiutano i programmatori a scrivere del codice modulare rendendolo
riusabile anche in altri progetti (ad esempio nello sviluppo di applicazioni web) improntando così
uno scheletro solido per la struttura dell’applicazione.
In particolare noi andremo a vedere in dettaglio solo alcuni Frameworks che però andranno così a
toccare tutti gli aspetti contemplati nel MVC.
Per rendere la spiegazione più interessante e avvincente ho deciso di prendere come esempio un
mio progetto universitario che unisce due esami molto validi per la formazione di uno studente
verso il mondo del lavoro. Gli esami sono: il progetto di ingegneria del software e il progetto di basi
di dati.
Il progetto di ingegneria del software richiedeva di dover analizzare, progettare, sviluppare e testare
un applicativo orientato al web utilizzando il linguaggio Java come linguaggio di implementazione
e HTML per la visualizzazione.
Il progetto di basi di dati richiedeva di creare un applicazione Java che facesse uso di un database
SQL relazionale (MySql) per la memorizzazione, ricerca e modifica dei dati.
Per unire i due progetti ho deciso di creare un applicazione web che facesse uso del database.
L’applicazione scelta fu la realizzazione di un sito web che permetta di giocare on-line al celebre e
famosissimo gioco del Monopoli. Il sito web infatti permette di registrarsi per effettuare l’accesso,
una volta effettuato si può decidere se creare una partita o parteciparne ad una già creata (non
iniziata) e visualizzare la classifica dei punteggi, in partita si possono effettuare tutte le azioni che
prevede il regolamento del gioco, tra cui la trattativa per lo scambio e vendita dei territori tra due
giocatori ed in più il salvataggio di una partita in corso per poterla poi riprendere successivamente.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
1
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Scenario applicativo
Durante il ciclo di vita e l'uso di un applicativo software, le aspettative e le condizioni in cui esso
era stato sviluppato possono cambiare, determinando la necessità di una riqualificazione, nell'ottica
di un aumento delle prestazioni e della stabilità.
Supponendo di aver ricevuto la richiesta di manutenzione evolutiva dell’applicativo web
“Monopoli-OnLine”, utilizziamo lo schema del ciclo di vita a spirale come strumento di sviluppo.
Figura 1 : Modello a spirale
La spirale ha il pregio di considerare tutto il ciclo di vita; oltre ad arrivare alla consegna del
software, permette di strutturare e programmare anche l'attività successiva all'installazione. In
sostanza si occupa anche della manutenzione che molti altri modelli trascurano.
Con questo modello il software si evolve di pari passo con l'avanzare del processo così da
consentire allo sviluppatore e al cliente di valutare meglio i rischi e di reagire ad ogni stadio.
Dapprima si rende necessario l’analisi del vecchio progetto facendo riferimento ai requisiti richiesti,
individuando i punti di intervento.
Il vecchio progetto essendo basato sulla caratteristica del design pattern MVC (Model-ViewController), è già improntato con l’ottica ingegneristica di riusabilità, modularità e
disaccoppiamento, e questo ci permette di porre l’attenzione ai singoli moduli.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
2
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Controller
View
Model
Figura 2
Vediamo in fondo le 3 componenti basi che compongono il design pattern MVC:
Model:
View:
Controller:
Rappresenta gli oggetti dati. Il modello è ciò che viene rappresentato
e manipolato dall'utente.
Serve come rappresentazione del modello. È l'oggetto che presenta lo
stato corrente degli oggetti dati.
Definisce il modo con cui l'interfaccia utente reagisce all'input
dell'utente.
L'utilizzo del pattern MVC offre molteplici vantaggi tra i quali una separazione tra i livelli di
presentazione e di transazione; ciò permette di cambiare il look and feel di un'applicazione senza
ricompilare il codice del Modello o del Controller.
In secondo luogo il tempo di sviluppo può essere significativamente ridotto, perché i programmatori
possono pensare alle transazioni, mentre i View programmers (HTML e JSP) si concentrano
sull'interfaccia.
L'ultimo beneficio è la separazione della logica di presentazione da quella di business che rende più
facile mantenere e modificare un'applicazione Web basata a strati (o livelli).
A questo punto lo scenario si presenta nel seguente modo :
Model:
View:
Controller:
Sono rappresentate le classi Java “DAO/DAC” che interagiscono con
il database per recuperare e scrivere informazioni SQL.
Sono pagine HTML con incapsulato del codice Java per renderle
dinamiche.
Sono classi Java denominate Servlet che elaborano le azioni
dell’utente finale (J2EE).
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
3
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Obiettivo dello stage
Sperimentare nuove tecnologie (Frameworks) per lo sviluppo di applicativi web.
Individuazione dei punti di intervento.
Le aree d’intervento in questa reingegnerizzazione per completezza andranno a toccare tutte e tre le
componenti del design pattern MVC :
Model:
View:
Controller:
Mappatura delle classi JavaBeans in XML utilizzato da Hibernate per
la gestione del database.
Aggiunta di AJAX nelle pagine HTML/JSP per minimizzare
l’interazione con il server.
Modifica del codice in Java Struts 1.2.9 sostituendo le Servlets con
Action e ActionForm.
Motivazioni
Lavorando nel campo dell’informatica è indispensabile stare al passo con i tempi e conoscere pregi
e difetti di nuove soluzioni che potrebbero essere utili nell’implementazione di un qualunque genere
di software.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
4
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
1 Le applicazioni e i Frameworks utilizzati
Eclipse Galileo SR1
Descrizione: Eclipse è un progetto open source legato alla creazione e allo sviluppo di una
piattaforma di sviluppo ideata da un consorzio di grandi società quali Ericsson, HP, IBM,
Intel, MontaVista Software, QNX, SAP e Serena Software, chiamato Eclipse Foundation, e
creata da una comunità strutturata sullo stile dell'open source.
Pur essendo orientata allo sviluppo del progetto stesso, questo IDE (ambiente di sviluppo
integrato) è utilizzato anche per la produzione di software di vario genere. Si passa infatti da
un completo IDE per il linguaggio Java (JDT, "Java Development Tools") ad un ambiente di
sviluppo per il linguaggio C++ (CDT, "C/C++ Development Tools") e a plug-in che
permettono di gestire XML, PHP e persino di progettare graficamente una GUI per
un'applicazione JAVA (Eclipse VE, "Visual Editor"), rendendo di fatto Eclipse un ambiente
RAD.
Il programma è scritto in linguaggio Java, ma anziché basare la sua GUI su Swing, il toolkit
grafico di Sun Microsystems, si appoggia a SWT, librerie di nuova concezione che
conferiscono ad Eclipse un'elevata reattività.
La piattaforma di sviluppo è incentrata sull'uso di plug-in, delle componenti software ideate
per uno specifico scopo, per esempio la generazione di diagrammi UML, ed in effetti tutta la
piattaforma è un insieme di plug-in, versione base compresa, e chiunque può sviluppare e
modificare i vari plug-in. Nella versione base è possibile programmare in Java, usufruendo
di comode funzioni di aiuto quali: completamento automatico ("Code completion"),
suggerimento dei tipi di parametri dei metodi, possibilià di accesso diretto a CVS e
riscrittura automatica del codice (funzionalità questa detta di Refactoring) in caso di
cambiamenti nelle classi.
Essendo scritto in Java, Eclipse è disponibile per le piattaforme Linux, HP-UX, AIX, Mac
OS X e Windows.
Note positive: Programmazione assistita con strumenti di segnalazione e correzione di
errore, controllo sintattico su tutto il progetto, integrabile con molti plug-in. (Junit, Cactus,
...) e programmi (TomCat, MySQL, ...).
Note negative: L’IDE richiede un hardware non mediocre, risulta difficile la portabilità del
progetto da una macchina ad un’altra se non vengono seguiti dei piccoli accorgimenti, sono
stati riscontrati problemi nel associazione con TomCat 5.5/6.0 ed a volte avvisa errori
inesistenti sul codice HTML (ad esempio per il tag Form).
Apache Tomcat
Descrizione: Apache Tomcat (o semplicemente Tomcat) è un web container open source
sviluppato dalla Apache Software Foundation. Implementa le specifiche JSP e Servlet di Sun
Microsystems, fornendo quindi una piattaforma per l'esecuzione di applicazioni Web
sviluppate nel linguaggio Java. La sua distribuzione standard include anche le funzionalità di
web server tradizionale, che corrispondono al prodotto Apache. In passato, Tomcat era
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
5
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
gestito nel contesto del Jakarta Project, ed era pertanto identificato con il nome di Jakarta
Tomcat; attualmente è oggetto di un progetto indipendente. Tomcat è rilasciato sotto licenza
Apache Software License, ed è scritto interamente in Java; può quindi essere eseguito su
qualsiasi architettura su cui sia installata una JVM.
Note positive: Permette di provare la propria applicazione sulla propria macchina di
sviluppo generando un application server a tutti gli effetti. È possibile avviare e bloccare il
proprio application server locale a piacimento.
Note negative: Non è gestita la coda dei messaggi.
Struts 1.2.9
Descrizione: Apache Struts è un progetto open source sponsorizzato dalla Apache Software
Foundation ed è l'implementazione Java server-side del design pattern MVC (Model View
Controller).
Il progetto Struts è nato con l'intenzione di implementare un framework open-source per la
creazione di applicazioni web che permettesse la separazione del livello di presentazione e
che fosse, allo stesso tempo, astratto dai vari livelli di dato e dalle transizioni.
I componenti di Struts
Struts, come ogni application framework, è un insieme di classi e interfacce che
costituiscono lo scheletro per costruire le nostre Web application. I componenti base su cui si
appoggia sono:
ActionServlet: È la servlet di controllo che gestisce tutte le richieste dell'applicazione.
Come tutte le servlet estende la classe javax.servlet.http.HttppServlet e che quindi
implementa tutti i metodi di lifecycle, incluso init(), doGet(), doPost() ed il destroy.
struts-config.xml: È il cuore di tutta l'applicazione. In tale file XML si vanno a settare
ed a definire i vari elementi della nostra applicazione e le loro associazioni. Tale file
viene letto in fase di start-up dell'applicazione dalla ActionServlet.
Action: Le Action sono le classi alle quali le ActionServlet delegal'elaborazione della
richiesta.
ActionMapping: Contiene gli oggetti associati ad una Action nello struts-config come
ad esempio gli ActionForward.
ActionForm: Sono considerati dei veri contenitori di dati. Fanno riferimento ad uno
specifico form e vengono popolati automaticamente dal framework con i dati contenuti
nella request http.
ActionForward: Contengono i path ai quali la servlet di Struts inoltra il flusso in base
alla logica dell'applicazione. Custom-tags: Sono tag particolari forniti dal framework
Struts per assolvere a molti dei più comuni compiti delle pagine JSP.
In figura 3 è rappresentato il flusso elaborativo nella logica di Struts:
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
6
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Figura 3 : Flusso Elaborativo di Struts
Come si puó notare il Client invia una richiesta http (1), la quale viene ricevuta dalla servlet
di Struts, che provvede a popolare l'ActionForm associato alla richiesta con i dati della
request (2) e l'ActionMapping associata alla richiesta (4). Tutti i dati sono stati letti dallo
struts-config.xml in fase di start up. L' ActionServlet delega l'elaborazione dati alla relativa
Action (3) passandole in input request e response http e l'ActionForm e l'ActionMapping
precedentemente valorizzati. La Action si interfaccia con lo strato di business object. Al
termine dell'elaborazione restituisce alla ActionServlet un ActionForward (6) contenete il
path della vista da fornire all'utente. La Action esegue il forward alla vista specifica
nell'ActionForward (7).
Tale flusso di operazioni non è totalmente completo tuttavia fornisce un'indicazione di base
su come viene gestito il flusso di richieste e di elaborazione dati in un applicazione Struts.
Il Deployment descriptor dell'applicazione
Il file web.xml descrive tutti i componenti dell'applicazione Web. Le informazioni che
possono essere descritte nel seguente file sono:
Parametri ed inizializzazione ServletContext
Contenuto localizzato
Configurazione della sessione
Definizione Servlet/JSP
Mapping Servlet/JSP
Riferimenti a tag library
Mappature a tipi MIME
Lista di file di Welcome
Pagine di errore
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
7
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Hibernate
Descrizione: La programmazione orientata agli oggetti ci garantisce delle opportunità di
sviluppo peculiari di questo paradigma di programmazione. In particolare la possibilità di
astrarre dei concetti generali, ed applicarli a diversi contesti in maniera praticamente
automatizzata consente il rapido sviluppo basato su servizi già creati.
Esistono in commercio piattaforme evolute che estendono proprio i concetti di astrazione e
riusabilità portandoli a diventare basi portanti per progetti di più ampio respiro. è il caso di
Hibernate le cui peculiarità sono la base della piattaforma di middleware per la persistenza
forse più interessante in commercio (nonché la base dell'application server JBoss per la
persistenza degli entity java bean).
Hibernate è uno strato di middleware che consente allo sviluppatore di automatizzare le
procedure per le operazioni cosiddette CRUD (Create, Read, Update, Delete) dei database.
In ambito di sistemi informativi, in particolar modo applicati al web, questo tipo di
operazioni sono quelle che più di altre portano lavoro: di codifica, di test e di debug. In
particolare l'eterogeneità tra il linguaggio di programmazione utilizzato per la logica
applicativa (nel nostro caso Java, ma in generale anche gli altri linguaggi) e quello utilizzato
per interrogare le basi di dati relazionali (SQL, standard o dialetti derivati dalle
implementazioni del database) è all'origine della difficoltà di produrre in tempi brevi
prodotti affidabili.
Le pratiche di programmazione più comuni, hanno portato, nel tempo, a modelli di sviluppo
che prevedono l'utilizzo dei Javabean, in particolare in ambiente web application, come
oggetti contenitore di informazioni residenti su base di dati. Oggetti, che tra le altre cose ben
si prestano ad essere rappresentati in fase di visualizzazione grazie ai tag delle pagine JSP.
Il successivo passo è quindi quello di avere uno strato di programmazione che si interpone
tra la pagina JSP ed il database, occupandosi di popolare con le informazioni corrette proprio
i javabean.
Hibernate nasce con questo scopo e si evolve fino a diventare forse la più robusta
piattaforma di middleware per la persistenza attualmente presente. Il progetto, opensource
da sempre, è sotto l'elgida Red Hat, che qualche tempo fa ha acquisito il progetto JBoss (di
cui Hibernate è ormai colonna portante).
L'idea è quella di indicare al middleware in maniera dichiarativa (con dei descrittori testuali,
xml) l'associazione tra la classe del javabean e la tabella in cui risiedono i dati. Una volta
definite queste associazioni, l'infrastruttura che utilizzeremo si occuperà di recuperare
dinamicamente le informazioni associate (leggendo i descrittori) e creare automaticamente le
query necessarie (in base all'operazione che utilizzeremo).
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
8
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Figura 4 : Hibernate layer
A differenza degli entity java bean (che pure hanno una logica similare), qui dovremo
chiedere esplicitamente l'operazione da svolgere (salvataggio, update, cancellazione, ecc). In
realtà, la piattaforma consente di fare molto di più. Lo scopo di questo articolo è però quello
di illustrare i primi passi per poter utilizzare la tecnologia, quindi vediamo come poter
incominciare da subito ad utilizzare la piattaforma.
Installazione
Più che installazione, bisogna parlare di importazione delle librerie (jar) che contengono la
logica di middleware. Dal sito ufficiale potete raggiungere la pagina di download e scaricare
il materiale necessario ad iniziare. Come dicevo nel precedente paragrafo, la tecnologia è
particolarmente complessa (e interessante) nelle sue funzionalità avanzate e nel sito
troverete tutto il materiale di cui avrete bisogno per approfondimenti. Per iniziare è
sufficiente scaricare la tecnologia (core), arrivata, al momento in cui scrivo, alla versione
3.2.5.
Una volta scaricati i file, importate le librerie jar sotto il vostro progetto oppure rendetele
visibili al classpath. Tutte le classi necessarie le trovate nel package hibernate3.jar, quindi
sarà sufficiente importare quest'ultimo.
Un esempio pratico
Quello che vogliamo realizzare è la creazione di un'associazione tra una tabella di un
database e un Javabean attraverso il quale poter rappresentare i dati.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
9
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Prendiamo il caso della persistenza di informazioni di persone, presenti in un database.
Immaginiamo il database abbia diverse informazioni registrate tra cui un identificativo, il
nome e l'indirizzo email.
Iniziamo a sviluppare il Javabean associato, che chiameremo Persona. Ovviamente si tratta
di una classe con i suddetti attributi di istanza (privati), i metodi getter e setter pubblici ed il
costruttore di default (unici vincoli di un javabean).
Listato 1. Javabean che contiene informazioni su una persona
package it.html.hibernate;
public class Persona {
//Variabili di istanza
private int id;
private String nome;
private String email;
//Costruttore pubblico
public Persona(){}
public String getEmail() {
return email;
}
//Metodi getter / setter
public void setEmail(String email) {
this.email = email;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
Come potete vedere, non c'è niente di particolarmente rilevante: nessuna estensione o
implementazione, il che rende possibile fare evolvere la classe da altre e così via. Ma
procediamo con quello che è il ponte tra il javabean e Hibernate: il descrittore xml.
Il descrittore ha il compito di definire l'associazione tra l'oggetto appena scritto ed il
database. Immaginiamo che la tabella del database si chiami AnagraficaCliente e che
abbia una serie di campi tra cui: ANAG_ID, nome, cognome, CLI_EMAIL e CLI_TEL.
Listato 2. Descrittore
<?xml version="1.0"?>
<hibernate-mapping>
<class name="it.html.hibernate.Persona" table="AnagraficaCliente">
<id name="id" column="ANAG_ID">
<generator class="native"/>
</id>
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
10
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
<property name="email" column="CLI_EMAIL"/>
<property name="nome"/>
</class>
</hibernate-mapping>
Il descrittore, dovendo associare la classe alla tabella, si presenta molto semplicemente. Il
tag class, racchiude l'associazione vera e propria già nei sui due attributi name e table. Già
noi in questo modo associamo il javabean alla tabella.
Successivamente, sempre all'interno dello stesso tag definiamo le altre informazioni di
supporto (relative alle proprietà del bean). Il tag id definisce l'identificativo della tabella (la
chiave), mentre i tag property definiscono l'associazione tra la proprietà del javabean
(attributo name) e la colonna del database (attributo column). Quando l'attributo column
manca è implicito che il nome della colonna sarà quello definito dall'attributo name.
Questo file, per convenzione, viene inserito a livello del sorgente java e si chiamerà (sempre
per convenzione) Persona.hbm.xml.
A completare il quadro mancano però alcune componenti essenziali. Come sappiamo, per
poter interrogare una base di dati abbiamo bisogno dei bridge JDBC che sono dei driver
dipendenti dall'implementazione del DBMS usato. Dovremo infatti creare un altro file che
definisca le informazioni su database (indirizzo) e driver (classe da usare).
Listato 3. Definisce le informazioni per la connessione al DB
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
<property name="connection.url">jdbc:hsqldb:hsql://localhost</property>
<property name="connection.username">root</property>
<property name="connection.password">****</property>
<property name="connection.pool_size">1</property>
<property name="dialect">org.hibernate.dialect.HSQLDialect</property>
<property name="current_session_context_class">thread</property>
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<property name="show_sql">true</property>
<property name="hbm2ddl.auto">create</property>
<mapping resource="it/html/hibernate/Persona.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Il file di configurazione (hibernate.cfg.xml) indica i driver necessari alla connessione.
Per questo semplice esempio utilizzeremo un database HSQL (un DBMS realizzato in java).
Due sono le possibilità per definire la connessione al database: il file di configurazione
(xml) oppure un file proprietà. Rimaniamo concentrati sul listato sopra. Le proprietà
definiscono il driver da utilizzare (connection.driver_class) e l'url (connection.url) di
connessione al database più altri parametri opzionali. Utilizzando altri database bisogna fare
attenzione a portare i driver JDBC a livello di visibilità del classpath.
Altro parametro a cui bisogna fare attenzione è il tag mapping, nella cui proprietà resource
viene indicato il path dove recuperare lo schema di persistenza che avevamo scritto in
precedenza (più eventualmente altri presenti).
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
11
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Quello che ci rimane è creare il middleware vero e proprio. Si tratta di una classe di
controllo, che, una volta istanziata, si occuperà di effettuare le operazioni CRUD,
convertendole in operazioni SQL e quindi in operazioni di persistenza sulla base di dati.
Listato 4. Classe usata per testare la persistenza del javabean Persona
package it.html.hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class PersonaUnitTest {
public static void main(String[] args) {
System.out.println("Persona Unit Test");
// Recupero la sessione: attenzione, questa operazione
// può essere gestita come un Singleton lungo tutta l'applicazione
Session session =
new Configuration().configure().buildSessionFactory().getCurrentSession();
//Creo una nuova persona
Persona p=new Persona();
p.setId(101);
p.setNome("Pasquale Congiustì");
p.setEmail("[email protected]");
//Utilizziamo un modello transazionale dichiarativo
session.beginTransaction();
//Chiedo al middleware di salvare questo oggetto nel database
session.save(p);
//fine della transazione: salviamo tramite commit()
session.getTransaction().commit();
}
}
Il listato ci mostra una classe main. Nella realtà, probabilmente, codificheremo l'operazione
di controllo sul controllore (una servlet, nel paradigma MVC). L'oggetto che si occupa di
tutto è l'oggetto Session, il cui ciclo di vita può essere ottimizzato condividendo lo stesso
oggetto tra più richieste. L'operazione di salvataggio vera e propria è rappresentata dal
metodo save, che si aspetta come parametro un oggetto generico (nel nostro caso una
Persona).
Sarà quel metodo ad effettuare una richiesta SQL (una insert, presumibilmente) verso la base
di dati, recuperando le informazioni proprio dal descrittore e dal javabean.
Analogamente bisognerà fare con le operazioni load, update e delete. La conversione verrà
curata dal framework in tutto e per tutto.
Ajax
Descrizione: Si sente molto parlare di AJAX e non sempre in modo chiaro. L'esigenza di
avere una guida chiarificatrice sull'argomento è diventata sempre più reale al punto da far
nascere siti interamente dedicati, ma che partono il più delle volte dal presupposto che chi
legge sappia già molto di JavaScript o dello stesso AJAX.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
12
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Questa guida vorrebbe quindi far luce sulla questione, spiegando dettagliatamente
l'acronimo tanto mormorato e le sue potenzialità al fine di fornire ai meno aggiornati o meno
preparati su Javascript, le conoscenze per usare questa tecnica di sviluppo.
Cenni storici
L'acronimo AJAX, che significa esattamente Asynchronous JavaScript And XML
(JavaScript asincrono ed XML), è stato enunciato per la prima volta da Jesse Garrett, nel
18 Febbraio 2005, come titolo di un post all'interno del suo blog
(http://www.adaptivepath.com/publications/essays/archives/000385.php).
Non si tratta di una nuova tecnologia né di un'invenzione bensì di un concetto utilizzato per
sviluppare applicativi avanzati e particolari quali Gmail, Google Maps o Google Suggest. Il
concetto è in parte espresso nell'acronimo scelto, un utilizzo asincrono di Javascript che
attraverso l'interfacciamento con XML, può permettere ad un client di richiamare
informazioni lato server in modo veloce e trasparente, allargando gli orizzonti delle rich
internet applications.
Queste applicazioni fino a poco tempo fa erano legate principalmente alle tecnologie AdobeMacromedia Flash o Java (con le applet). Entrambe purtroppo non sempre interpretabili dai
client degli utenti e troppo spesso usate a sproposito con il solo scopo di stupire, discorso
che spesso e purtroppo vale anche oggi.
In alternativa a queste tecniche di interazione client/server, quando nel 1996 venne
introdotto l'iframe in Internet Explorer 3, molti sviluppatori sfruttarono quest' ultimo
modificando l'attributo sorgente (src) della pagina racchiusa e simulando così un refresh
trasparente di una parte di contenuti il che emulava, in modo abbastanza sporco,
un'interazione asincrona.
Nel 1998 Microsoft cominciò a sviluppare una tecnologia, chiamata Remote Scripting, con
lo scopo di creare una tecnica più elegante per richiamare contenuti differenti ed è in questo
periodo, seppur con nome differente, che AJAX venne utilizzato per la prima volta, per poi
evolversi in versioni più mature fino a diventare un oggetto vero e proprio, noto ora come
XMLHttpRequest.
Il motivo principale di tanto successo è che solo ultimamente il Remote Scripting ha
suscitato lo stupore degli addetti ai lavori nel vedere cosa Google fosse riuscita a fare
all'interno dei suoi applicativi senza necessità di Flash Player o Java Virtual Machine,
mantenendo comunque la compatibilità con molteplici browser di utenti che per diversi
motivi non potevano usufruire di Javascript.
Come spesso è accaduto negli ultimi anni, molti hanno preso spunto da Google ed il web,
noto per la sua immediatezza propositiva, è stato in grado in poco più di un anno di regalarci
numerosi esempi di applicativi basati su AJAX, esagerando in alcuni casi nell'utilizzo ma
considerando molto spesso e fin da subito, a differenza di quanto accadde per Flash ed
Applets anni prima, due delle problematiche più diffuse del web attuale: accessibilità ed
usabilità.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
13
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Descrizione tecnica e teorica
Se parliamo di AJAX, oggi, parliamo di un oggetto specifico: XMLHttpRequest. A seconda
del browser usato prende nomi differenti o viene richiamato in maniera differente.
Nel caso di Internet Explorer, ad esempio, questo oggetto è restituito da un ActiveXObject
mentre nei browsers alternativi più diffusi (Mozilla, Safari, FireFox, Netscape, Opera ed
altri) XMLHttpRequest è supportato nativamente, cosa che dovrebbe accadere anche per IE
dalla versione 7.
Questo oggetto permette di effettuare la richiesta di una risorsa (con HTTP) ad un server
web in modo indipendente dal browser. Nella richiesta è possibile inviare informazioni, ove
opportuno, sotto forma di variabili di tipo GET o di tipo POST in maniera simile all'invio
dati di un form.
La richiesta è asincrona, il che significa che non bisogna necessariamente attendere che sia
stata ultimata per effettuare altre operazioni, stravolgendo sotto diversi punti di vista il flusso
dati tipico di una pagina web.
Generalmente infatti il flusso è racchiuso in due passaggi alla volta, richiesta dell'utente
(link, form o refresh) e risposta da parte del server per poi passare, eventualmente, alla
nuova richiesta da parte dell' utente.
Figura 5. Rappresentazione di una richiesta ad un server con latenza e risposta
Il terzo ed inevitabile incomodo di questo ciclo è l'attesa che trascorre tra una richiesta dell'
utente e la risposta del server. Con l'aggiunta di AJAX si perde questa linearità e mentre
l'utente è all'interno della stessa pagina le richieste sul server possono essere numerose e
completamente indipendenti.
Nulla infatti vieta, teoricamente, di effettuare decine di richieste simultanee al server per
operazioni differenti con o senza controllo da parte del navigatore.
Figura 6. Rappresentazione di una richiesta ad un server con latenza e risposta
Ciò che resta del vecchio flusso, il tempo di attesa, passa spesso in secondo piano ed in
molti tipi di interazione è praticamente impercettibile. Ma attenzione poichè questo tempo è
anche uno dei maggiori problemi dell'utilizzo di AJAX, sia per gli sviluppatori sia per i
navigatori.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
14
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
I primi potrebbero trovarsi in difficoltà qualora l'operazione asincrona dovesse attendere
assolutamente una risposta al fine di completare una serie di operazioni più o meno sensibili
mentre i secondi potrebbero non avere idea di cosa stia accadendo alla pagina chiudendola
ignari di aver richiesto un'informazione.
A completare questa breve introduzione tecnica e teorica è il tipo di risposta che l'oggetto si
aspetta dopo una chiamata che non deve essere necessariamente di tipo XML o letta come
tale ma che può essere semplicemente testuale, in contro tendenza con l'acronimo stesso ma
non per questo inusuale.
MySQL
Descrizione: MySQL è un Relational database management system (RDBMS), composto da
un client con interfaccia a caratteri e un server, entrambi disponibili sia per sistemi Unix
come GNU/Linux che per Windows, anche se prevale un suo utilizzo in ambito Unix.
Dal 1996 supporta la maggior parte della sintassi SQL e si prevede in futuro il pieno rispetto
dello standard ANSI. Possiede delle interfacce per diversi linguaggi, compreso un driver
ODBC, due driver Java e un driver per Mono e .NET.
Il codice di MySQL viene sviluppato fin dal 1979 dalla ditta TcX ataconsult, adesso MySQL
AB, ma è solo dal 1996 che viene distribuita una versione che supporta SQL, prendendo
spunto da un altro prodotto: mSQL.
Il codice di MySQL è di proprietà della omonima società, viene però distribuito con la
licenza GNU GPL oltre che con una licenza commerciale. Fino alla versione 4.0, una buona
parte del codice del client era licenziato con la GNU LGPL e poteva dunque essere utilizzato
per applicazioni commerciali. Dalla versione 4.1 in poi, anche il codice dei client è
distribuito sotto GNU GPL. Esiste peraltro una clausola estensiva che consente l'utilizzo di
MySQL con una vasta gamma di licenze libere.
MySQL svolge il compito di DBMS nella piattaforma LAMP, una delle più usate e installate
su Internet per lo sviluppo di siti e applicazioni web dinamiche.
Nel luglio 2007 la società svedese MySQL AB ha 385 dipendenti in 265 paesi. I suoi
principali introiti provengono dal supporto agli utilizzatori di MySQL tramite il pacchetto
Enterprise, dalla vendita delle licenze commerciali e dall'utilizzo da parte di terzi del
marchio MySQL. Il 16 gennaio 2008 Sun Microsystems ha acquistato la società per un
miliardo di dollari, stimando il mercato del database in 15 miliardi di dollari. Il 20 aprile
2009 la stessa Sun Microsystems è stata acquistata da Oracle per 7,4 miliardi di dollari. Il
software MediaWiki, che gestisce i siti del progetto Wikipedia, è basato su database MySQL
Microsoft office 2007
Descrizione: Microsoft Office 2007 è l'attuale release di Office, creata per sostituire
Microsoft Office 2003. Microsoft Office 2007, formalmente conosciuto come Office 12, è
stato rilasciato nel Novembre 2006 in versione corporate e il 30 gennaio 2007 in versione
retail. Microsoft ha incluso diverse nuove caratteristiche e miglioramenti in Office 2007, fra
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
15
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
i quali una nuova interfaccia grafica, the Ribbon, che ha sostituto i menu, le toolbar e i
principali task panels.
Adobe Creative Suite CS4
Descrizione: Adobe Creative Suite è una raccolta di software per il disegno grafico, lo
sviluppo di pagine web e la realizzazione di contenuti audio e video.
La suite viene distribuita in quattro versioni differenti: Design (Standard e Premium), con
applicazioni finalizzate alla creazione di documenti creativi, immagini e grafica; Web
(Standard e Premium), con applicazioni finalizzate alla creazione di siti web; Production
Premium, con applicazioni per la creazione, la modifica e la gestione di file multimediali
come musica e filmati; Master Collection, comprendente tutte le applicazioni delle altre tre
edizioni. La sua ultima versione, la Adobe Creative Suite 4 (abbreviato CS4) fu annunciata il
23 settembre 2008; da novembre è disponibile anche il supporto multilingue (con
installazione in italiano)
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
16
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
2 Requisiti utente
2.1 Specifiche di portata
Effettuare manutenzione evolutiva dell’applicazione web Monopoli on-line.
Il progetto consiste nel permettere di giocare al famoso gioco da tavola “Monopoli” via Web,
permettendo ad amici o sconosciuti, lontani e vicini di giocare comodamente ognuno a casa propria
o ovunque si abbia una connessione ad internet.
L’applicazione dovrà mantenere le stesse funzionalità ma migliorare il servizio (prestazioni,
efficienza) e la qualità del prodotto (riusabilità).
2.2 Specifiche di dettaglio
L’architettura del sistema prevede un Web Server centrale che unisca le connessioni dei vari Clients
in partite di Monopoli, mantenendo i dati di ogni partita salvata e i vincitori di ogni partita conclusa
nel proprio database.
Pertanto l’analisi di base rimane la stessa definita in precedenza.
Le specifiche funzionali:
uso dei frameworks.
2.3 Specifiche consegnate
Mantenendo inalterato la “modellazione del dominio” (descritto successivamente) ci focalizzeremo
su l’utilizzo di tre frameworks per soddisfare le specifiche di portata.
Struts 1.2.9 per i controlli
Hibernate per l’interazione col database
Ajax per l’interfaccia utente e minimizzare l’interazione con il server.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
17
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
3 Modellazione del dominio
L’analisi del dominio è stata articolata in due livelli secondo ordini diversi di granularità. Lo scopo
è quello di individuare nel primo approccio le funzionalità di base del sistema in modo tale da dare
all’utente un’idea chiara sui servizi che gli vengono messi a disposizione, e nel passo successivo,
entrare nel dettaglio nella descrizione di funzioni e dati.
3.1 Analisi del testo
L’analisi del testo è un lavoro di ispezione, condotto sulla specifica di portata, per individuare gli
attori e le funzionalità di riferimento del sistema. Con queste informazioni inizia l’attività di
modellazione del dominio.
3.1.1 Actors
Utente:
L’utente è quel cliente che accede al sito web. Può solo registrarsi, loggarsi,
visualizzare le partite in attesa e salvate, e visualizzare la classifica generale.
Giocatore:
Il giocatore è quell’utente che è entrato in una partita e può utilizzare a pieno le
funzionalità del sito.
3.1.2 Dominio dei dati
Le principali strutture dati emerse dall’analisi che caratterizzano il dominio di applicazione sono:
Partita:
La partita è la struttura principale dell’applicazione e comprende il 90%
dell’utilizzo del sito
Sala d’attesa:
Mantiene traccia delle partite in attesa e delle partite salvate
3.1.3 Requisiti funzionali
Le principali funzionalità esportate dal sistema sono:
Crea/Partecipa/Ripristina partita: E’ la prima funzione importante che si incontra
nell’applicazione, permette di creare, partecipare e ripristinare una partita
Tira dadi:
E’ la funzione che permette di muovere la tua pedina sul tabellone
Trattativa:
E’ la funzione che permette di scambiare territori con gl avversari
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
18
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Territori:
E’ la funzione che permette di visualizzare i territori di una pedina
Salva:
E’ la funzione che permette di salvare la partita in corso per poi finirla in un
secondo tempo
Ritirati:
E’ la funzione che permette di ritirarti ed abbandonare la partita
Classifica generale:
E’ la funzione che permette di visualizzare i punteggi più alti ottenuti
dai vincitori delle partite già concluse
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
19
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
3.2 Class Diagram di dominio
Il Class Diagram è un diagramma strutturale della famiglia dei diagrammi UML, che modella la
rappresentazione e l’organizzazione degli elementi del dominio di analisi in termini di oggetti.
Il diagramma si concentra non tanto sulle singole istanze, quanto sulle classi di dominio, che
rappresentano insiemi di oggetti omogenei e sulle quali è possibile esprimere proprietà locali
attraverso gli attributi. Le proprietà che coinvolgono più di una classe sono invece modellate dalle
associazioni o relazioni che, a livello formale, rappresentano delle relazioni matematiche e sono
quindi sottoinsiemi del prodotto cartesiano tra le classi su cui insistono.
Di seguito viene presentato il class diagram di dominio:
Figura 7
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
20
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
3.3 State Diagram
Il diagramma degli stati e delle transizioni viene definito per una classe, ed intende descrivere
l’evoluzione di un generico oggetto di quella classe.
Il diagramma rappresenta le sequenze di stati, le risposte e le azioni, che un oggetto attraversa
durante la sua vita in risposta agli stimoli ricevuti.
Uno stato rappresenta una situazione in cui un oggetto ha un insieme di proprietà considerate
stabili.
Una transizione modella un cambiamento di stato.
Di seguito descriviamo lo state diagram della classe Contratto come esempio essendo l’unica classe
che subisce il cambiamento di stato
Figura 8
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
21
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
3.4 Use Case Diagram a basso livello
Il diagramma degli use case illustra le funzionalità fondamentali che il sistema deve realizzare, in
termini dei suoi scenari di utilizzo.
Uno use case rappresenta tipicamente una interazione tra l’utente ed il sistema.
Ogni use case è collegato agli utenti (actor) addetti all’utilizzo e ad eventuali altri casi d’uso con
cui è relazionato (generalization, extend, include). Il diagramma in sé è un ottimo strumento di
raccordo tra l’analista e il committente, ma di fatto non ci dice molto sulle caratteristiche del
sistema, se non un’idea di massima sui suoi servizi offerti e da chi sono fruibili. Il punto chiave del
diagramma sono le descrizioni degli use case. In queste vengono spiegate cosa fanno le operazioni
previste, come deve avvenire l’interazione tra l’utente e il sistema e quali sono le principali
eccezioni allo scenario principale.
Figura 9
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
22
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
3.5 Descrizione Use Case Diagram
Le descrizioni dei casi d’uso devono necessariamente restare in questa fase su un livello abbastanza
generico.
Questo significa descrizioni corpose nel campo “brief description”, un “main success scenario”
fitto di botta-risposta tra utente e sistema ma con degli input e degli output che ancora con riflettono
lo schema preciso di presentazione dei dati. Si è cercato poi di lavorare molto sul campo
“extensions” per cogliere almeno le più importanti tra le molte eccezioni allo scenario principale.
Lo scopo delle prossime fasi sarà proprio quello di entrare nel dettaglio delle descrizioni, snellire lo
scenario di successo e specializzare le interazioni tra utente e sistema.
3.6 Use Case Diagram ad alto livello
Siamo arrivati al massimo livello di granularità in cui tutti i casi d’uso sono completamente
spacchettati.
Il diagramma si ramifica andando da un livello astratto ad uno sempre più preciso fino ad avere
sulle foglie le funzionalità più elementari.
L’obiettivo è quello di impostare l’architettura del sistema con un approccio button-up, in cui le
funzionalità complesse vengono viste e trattate come una composizione di funzioni elementari in
modo da avere un basso accoppiamento ed una buona modularità.
La struttura aiuta poi la pianificazione del progetto ed il calcolo dei function point perché si evita
di avere a che fare con operazioni troppo corpose in cui è spesso difficile cogliere tutte le
microfunzionalità
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
23
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Figura 10
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
24
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
25
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
26
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
27
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
28
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
29
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
30
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
31
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
32
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
33
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
34
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
35
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
4 Pianificazione
4.1 Pianificazione del progetto
La pianificazione ha lo scopo di dare al progetto una stima di riferimento circa i tempi ed i costi di
realizzazione. Questa fase, che tipicamente occupa tra il 5% e il 7% dell’intera durata del progetto,
è fondamentale perché aiuta ad avere il controllo delle risorse coinvolte, migliora l’organizzazione
del team di sviluppo e permette di controllare l’evoluzione del lavoro nel tempo.
4.1.1 Function point
Il metodo dei Function point è correntemente lo standard più in voga per stimare la complessità di
sviluppo di un progetto software. Presentati in un articolo del 1984 (anche se le prime proposte
risalgono al 1975), hanno presto preso piede nel mondo delle software house grazie al fatto che
permettono di capire le dimensioni, quindi i costi e i tempi di sviluppo del progetto con una misura
empirica basata sulle sue funzionalità, andando di fatto a sostituire quello che fino ad allora era
lasciato al parere di un esperto.
Il loro problema, essendo abbastanza datati, è quello di essere stati modellati per un software
puramente transazionale e non cogliere quindi gli aspetti dinamici tipici delle applicazioni di oggi,
in particolare delle web application, tanto che ne esistono varie rivisitazioni che adattano i FP a
queste esigenze (OO-FP, Cosmic FP, UML-FP, WEB-FP).
Tuttavia risulta la metodologia standard per questo problema e sono, ad oggi, il più forte strumento
contrattuale nei rapporti tra l’azienda e il cliente. La versione usata nel nostro progetto e la IFPUG
4.2.
4.1.2 La metodologia
La tecnica generale è quella di cercare nei requisiti le funzionalità che caratterizzano il sistema e di
valutarle attraverso tre livelli di complessità: semplice, medio, alto. Gli elementi significativi da
valutare sono cinque e si distinguono in:
Dati
Internal Logical File (ILF): Gruppo di dati logico riconoscibile dall’utente, mantenuto e
aggiornato all’interno del confine dell’applicazione.
External Interface File (EIF): Gruppo di dati logico riconoscibile dall’utente, referenziato
dall’applicazione ma che non rientra nel dominio (è un ILF di un’altra applicazione). Gli
elementi che stabiliscono la complessità di queste funzioni sono il numero di:
o Data Element Type (DET): Campo unico che caratterizza un file, riconoscibile
dall’utente.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
36
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
o Record Element Type (RET): Campo corrispondente a un sottogruppo di dati che
caratterizzano un file, riconoscibile dall’utente.
Transazioni
External Input (EI): Funzione elementare atomica che acquisisce dati dall’esterno, li
elabora ed aggiorna uno o più ILF.
External Output (EO): Funzione elementare atomica che ha lo scopo di presentare dati
all’esterno. Un EO è da considerarsi tale solo nel caso in cui esegue almeno una delle
seguenti quattro operazioni:
1.
2.
3.
4.
Fa calcoli sui dati
Crea dati derivati
Altera il comportamento del sistema
Aggiorna uno o più ILF
External Query (EQ): Funzione elementare atomica che ha lo scopo di reperire e
presentare dati all’esterno. La differenza con l’EO è che l’EQ si specializza sul reperimento
dei dati e dunque non deve eseguire nessuna delle precedenti 4 operazioni. Gli elementi che
stabiliscono la complessità di queste funzioni sono il numero di:
o File Type Refered (FTR): file manipolato dalla transazione.
o Data Element Type (DET): Campo unico che caratterizza un file, riconoscibile
dall’utente (i det comuni ad input ed output vanno considerati una sola volta).
Dalla somma dei pesi associati alle varie funzionalità si ottengono gli Unadjusted Funcition Point
(UFP). Il secondo passo è proprio quello di calcolare il fattore di aggiustamento (F), un parametro
correttivo che tiene conto di come deve essere realizzata l’applicazione, delle caratteristiche del suo
ambiente di sviluppo e del contesto di lavoro, dal quale saranno poi calcolati gli Adjusted
Function Point (AFP). Questo parametro è ottenuto dalla somma di 14 fattori valutati con un
punteggio da 0 a 5 ed è in grado di far variare la stima degli UFP del 35%, secondo la seguente
formula:
AFP = UFP · (0,65 + 0,01 · F)
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
37
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
4.1.3 Pert
Il diagramma Pert (Program Evaluation and Review Tecnique), introdotto negli anni ‘50 per la
gestione del progetto Polaris della marina americana, è un grafo orientato che riporta la sequenza
delle attività coinvolte, le loro durate, e le interdipendenze tra di queste.
Ogni attività è rappresentata da un nodo mentre le dipendenza sono rappresentate da archi. Una
volta stesa la rete delle attività, è possibile individuare il cammino critico: sequenza di attività che
determina l’intera durata del progetto; le parallelizzazioni tra le mansioni, determinanti nel caso di
sviluppo concorrente, con i tempi di anticipo e di ritardo massimo su ogni attività.
Per il Pert di questo progetto, l’unico punto di riferimento sui tempi è la stima degli FP per fase,
quindi l’approccio è stato quello di individuare le attività più importanti di ogni fase, valutarle con
delle durate la cui somma rispetti la stima degli FP.
A
A
B
B
C
C
Figura 11
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
38
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
4.1.4 Gantt
Il diagramma Gantt (da Henry Gantt 1861-1919) è un diagramma temporale, da integrare al Pert,
che riporta sull’asse dei tempi tutte le attività rispettando eventuali vincoli temporali. Sul
diagramma vengono poi riportate le varie scadenze (milestones) ed i potenziali parallelismi.
Figura 12
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
39
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5 Disegno del sistema
5.1 Architettura Hardware
Il sistema è disegnato per un’architettura di tipo Client/Server.
Lo scenario tipico di impiego è la partita al gioco Monopoli attraverso internet.
Il server è composto da una o più macchine sulle quali risiede il Web Server, le Application server e
il DBMS.
Per la comunicazione la larghezza di banda suggerita è di 1 Mbit/sec notevolmente ridotta rispetto
ai 4 Mbit/sec della versione iniziale, per colpa della pesantezza della pagina del tabellone e del
contesto a lei associata.
5.1.1 Server
I requisiti minimi del server sono essenzialmente legati alla capacità di calcolo della macchina, al
sistema operativo e al DBMS installato.
Il DBMS utilizzato per lo sviluppo è MySQL 5.1; nella sua documentazione non sono indicati
particolari requisiti minimi ed è compatibile con tutti i più noti sistemi operativi.
La configurazione minima consigliata è la seguente:
Processore 2 Ghz
1024 MB di Ram
Hard Disk 200 GB
5.1.2 Client
Il client è un semplice calcolatore provvisto di una connessione ad internet.
La configurazione minima consigliata è la seguente:
Processore 1 Ghz
Ram 512 MB
Spazio libero di 200 MB
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
40
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5.1.3 Piattaforma di sviluppo
Notebook Packard Bell (XP)
Processore Intel Centrino 1.8 Ghz
1 GB di Ram
Hard Disk 80 GB
Notebook ASUS (XP)
Processore Intel Centrino Duo 1.66 Ghz
1 GB di Ram
Hard Disk 80 GB
Notebook IBM (XP)
Processore Intel Pentium III 900 MHz
256 MB di Ram
Hard Disk 20 GB
Notebook HP (XP)
Processore Intel Centrino 1.2 GHz
512 MB di Ram
Hard Disk 100 GB
Notebook IBM (XP)
Processore Intel Pentium 4 1.9 GHz
512 MB di Ram
Hard Disk 40 GB
Notebook HP (Vista / Linux-Ubuntu 10.7)
Processore AMD Turion 64x2 2.2 GHz
GB di Ram
Hard Disk 250 GB
Desktop Packard Bell (Vista)
Processore Intel Core2 Duo 2.13 GHz
GB di Ram
Hard Disk 500 GB
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
41
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5.2 Architettura Software
La struttura di base del software segue quella del pattern MVC (Model, View, Controller) in cui i
vari componenti dell’applicazione vengono separati in moduli che implementano funzionalità di
gestione sui dati (Model/Hibernate), moduli dedicati alla logica di controllo (Controller/Struts 1.2.9)
ed i moduli che implementano la logica di presentazione (View/Jsp-Ajax).
Questa soluzione è tra le più adottate nel mondo del software design perché risponde bene ai canoni
di modularità, flessibilità e manutenibilità delle applicazioni moderne anche se va detto che non
sempre viene utilizzata in maniera corretta.
Il codice è scritto in java 1.6 con l’impiego dei frameworks sopra descritti:
Servlet: Tecnologia java multithreading che estende le funzionalità del Web server
completamente portabile e indipendente dal protocollo di comunicazione, anche se, come
nel nostro caso, si utilizza Struts 1.2.9 e le servlet le denominiamo Action. Una servlet è in
grado di gestire lo stato degli utenti, leggere i dati inviati dal client, manipolarli e passarli ad
altri componenti.
Java Servlet Pages (JSP): Particolare tipo di servlet che immerge direttamente il codice
java all’interno di pagine web. Gli scriplet (statement java) vengono marcati con dei
particolari tag e la pagina jsp viene tradotta in una vera e propria servlet dal server al
momento dell’invocazione ma utilizzando il MVC cercheremo di lasciare la logica di
calcolo al modulo Controller.
La logica di accesso ai dati persistenti è stata implementata utilizzando il frameworks Hibernate che
oltre a mappare le classi di manipolazione dei dati (Java Bean) gestisce anche il pull di connessioni
verso il DB rendendo trasparente all’applicazione il tipo ti DB utilizzato.
Le pagine web sono scritte per lo più in HTML con l’aggiunta di qualche script di tipo Javascript
(e Ajax) per supportare la presentazione dei dati e per alleggerire un pò la logica di controllo lato
server.
Per le funzioni Application Server e Servlet Engine è stato utilizzato Apache Tomcat 6.0.28
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
42
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5.3 Progetto della base di dati
Nel nostro caso la base dati è già disponibile e solidamente testata, ma riportiamo le specifiche di
progettazione per completezza.
5.3.1 Progettazione concettuale
La progettazione concettuale serve a rappresentare i dati del dominio di interesse attraverso un
modello formale ad alto livello che prende il nome di scheda concettuale o schema ER (EntityRelationship). In questa fase siamo ancora fortemente orientati alla modellazione e l’unico aspetto
che interessa sono la correttezza nella rappresentazione dei dati.
5.3.1.1 Schema ER
Lo schema descrive la struttura del dominio a livello intenzionale ed ha moltissimi concetti analoghi
al Class Diagram UML tanto che l’uno può essere ottenuto dall’altro con un processo di traduzione
diretta. La differenza di fondo sta nel fatto che l’ER tratta i dati come entità e non come classi di
oggetti.
Degli altri costrutti utilizzati: relazioni, attributi, generalizzazioni se ne è già parlato nel Class
Diagram. È importante scegliere di un identificatore tra gli attributi di entità. Anche in questo caso,
gli aspetti sintattici che non vengono colti dal modello possono essere scritti in vincoli esterni.
Figura 13
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
43
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5.3.1.2 Scelte critiche effettuate nella fase di progettazione
E’ stato necessario aggiungere l’attributo “ora” come attributo identificativo alle classe Partita.
Questo ci ha consentito di poter gestire il salvataggio di un maggior numero di partite e dando così
agli utenti finali una maggiore libertà nella creazione delle stesse. Abbiamo così una terna (data,
ora, codice) che identifica l’oggetto partita.
5.3.2 Progettazione logica
Si passa ora dal modello relazionale allo schema logico della base dati. Vengono ora presi in
considerazione anche aspetti legati all’efficienza e alle prestazioni, per questo lo schema e gli
eventuali vincoli, devono essere corredati dalle informazioni rilevanti sul carico applicativo.
5.3.2.1 Ristrutturazione schema ER
Questa fase serve a rendere lo schema direttamente traducibile in schema logico, senza ulteriori
scelte progettuali. La ristrutturazione si concentra su quei costrutti che non possono essere colti
dalla struttura relazionale del database ed i punti che vengono trattati, nel nostro caso, sono:
5.3.2.2 Schema ER ristrutturato
Figura 14
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
44
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5.3.2.3 Schema logico
Utente (nome, cognome, dataNascita, nick, password, e-mail)
Giocatore(nome, cognome, dataNascita, nick, password, e-mail)
foreign key Giocatore [nick] ≤ Utente [nick]
foreign key Giocatore [nick] ≤ Utilizza [nickU]
foreign key Giocatore [nick] ≤ Sosta [nickS]
inclusion Giocatore [nick] ≤ Partecipa [nickP]
Utilizza (nickU, codiceU, dataU, oraU, pedina)
foreign key Utilizza [nickU] ≤ Giocatore [nick]
foreign key Utilizza [codiceU, dataU, oraU] ≤ Partita [codice, data, ora]
inclusion Utilizza [pedina] ≤ Pedina [immagine]
Pedina (immagine)
inclusion Pedina [immagine] ≤ Utilizza [pedina]
Sosta (nickS, codiceS, dataS, oraS, casella)
foreign key Sosta [nickS] ≤ Giocatore [nick]
foreign key Sosta [codiceS, dataS, oraS] ≤ Partita [codice, data, ora]
inclusion Sosta [casella] ≤ Caselle [NumCasella]
Partecipa (nickP, codiceP, data, ora, soldi)
foreign key Partecipa[nickP] ≤ Giocatore [nick]
foreign key Partecipa [codiceP, dataP, oraP] ≤ Partita [codice, data, ora]
Partita (data, codice, data, ora)
foreign key Partita[codice, data, ora] ≤ Possiede [codicePO, dataPO, oraPO]
foreign key Partita[codice, data, ora] ≤ Ha [codiceH, dataPO, oraPO]
inclusion Partita[codice, data, ora] ≤ Partecipa [codiceP, dataP, oraP]
foreign key Partita[codice, data, ora] ≤ Vincitore [codiceV, dataV, oraV]
foreign key Partita[codice, data, ora] ≤ Utilizza [codiceU, dataU, oraU]
foreign key Partita[codice, data, ora] ≤ Sosta [codiceS, dataS, oraS]
Vincitore (Saldofinale, nickV, codiceV, dataV, oraV)
foreign key Vincitore[codiceV, dataV, oraV] ≤ Partita[codice, data, ora]
foreign key Vincitore [nickV] ≤ Giocatore [nick]
Possiede (codicePO, nickPO, contratto)
foreign key Possiede [nickPO] ≤ Giocatore [nick]
foreign key Possiede [codicePO, dataPO, oraPO] ≤ Partita [codice, data, ora]
foreign key Possiede [contratto] ≤ Contratto [nome]
Contratto (pedaggio, nome, prezzo, ipoteca)
foreign key Contratto [nome] ≤ Possiede [contratto]
foreign key Contratto [nome]≤ Associato [nomeC]
Associato (nomeA, coloreA)
Foreign key Associato [nomeA] ≤ Contratto [nome]
Foreign key Associato [coloreA] ≤ Territorio [colore]
Edificabile (valoreCasa, nomeE)
foreign key Edificabile [nomeE] ≤ Contratto [nome]
inclusion Edificabile [nomeE] ≤ Ha [nomeH]
Ha (numeroCase, nickH, codiceH, dataH, oraH, nomeH)
foreign key Ha [nickH] ≤ Giocatore [nick]
foreign key Ha [codiceH, dataH, oraH] ≤ Partita [codice, data, ora]
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
45
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
foreign key Ha [nomeH] ≤ Edificabile [nomeC]
NonEdificabile (nomeNE)
foreign key NonEdificabile [nomeC] ≤ Contratto [nome]
Caselle (numCasella, nomeC)
inclusion key Caselle [numCasella] ≤ Sosta [casella]
Speciali (soldi, testo, numCasellaS)
foreign key [numCasellaS] ≤ casella [numCasella]
Territori (colore, numCasellaT)
foreign key Territori [numCasellaT] ≤ Caselle [numCasella]
foreign key Territori [colore] ≤ Associato [coloreA]
Carte (numId, testo, importo)
Imprevisti (numIdI)
foreign key Imprevisti [numIdI] ≤ Carte [numId]
Probabilità (numIdP)
foreign key Probabilità [numIdP] ≤ Carte [numId]
5.3.2.4 Vincoli
Vincoli esterni:
La terna Giocatore G, Partita P, Edificabile E della relazione “possiede” deve essere uguale alla
terna presente nella relazione “Ha”
5.3.2.5 Politiche di cancellazione
Per quanto riguarda le politiche di cancellazione, abbiamo scelto di eliminare i dati all’interno della
base dopo l’operazione di ripristino perché in caso della terminazione della partita non abbiamo più
bisogno di memorizzare i dati avendo così un risparmio eliminando così la fase di update. Tutto
funziona alla perfezione con solo le due fasi di inserimento e cancellazione.
I dati della partita restano disponibili a runtime e in caso di interruzione, si ha la fase di salvataggio
(insert) che va a memorizzare tutti i dati sulla base, mentre in caso di terminazione gli unici dati
salvati sono quelli relativi alla classifica generale (Vincitore, Partita e Saldo finale).
5.3.2.6 Viste
Non sono state necessarie viste per il progetto.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
46
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5.3.2.7 Creazione del DB con popolamento tabelle
drop database monopoli;
create database monopoli;
use monopoli;
drop table Utente;
Create table Utente (
nome character (30) not null,
cognome character (30) not null,
dataNascita character (10) not null,
nick character (30) primary key,
password character (30) not null,
e_mail character (62) not null,
unique (nome, cognome, dataNascita)
);
drop table Partita;
Create table Partita (
codice character (30) not null,
data character (10) not null,
ora character (10) not null,
unique (codice, data, ora)
);
drop table Pedina;
create table Pedina (
immagine character (8) primary key
);
drop table Sosta;
Create table Sosta(
nickS character (30) not null,
codiceS character (30) not null,
dataS character (10) not null,
oraS character (10) not null,
casella integer not null,
primary key (nickS, codiceS, dataS, oraS, casella),
foreign key (nickS) references Utente (nick) ON DELETE CASCADE ON
UPDATE CASCADE,
foreign key (codiceS, dataS, oraS) references Partita (codice, data,
ora) ON DELETE CASCADE ON UPDATE CASCADE
);
drop table Partecipa;
Create table Partecipa(
ordine int (1) not null,
soldi int (10) not null,
nickP character (30) not null,
codiceP character (30) not null,
dataP character (10) not null,
oraP character (10) not null,
primary key (nickP, codiceP, dataP, oraP),
foreign key (nickP) references Utente (nick) ON DELETE CASCADE ON
UPDATE CASCADE,
foreign key (codiceP, dataP, oraP) references Partita (codice, data,
ora) ON DELETE CASCADE ON UPDATE CASCADE
);
drop table Contratto;
create table Contratto(
pedaggio integer (4) not null,
nome character (30) primary key,
prezzo integer (4) not null,
ipoteca integer (4) not null
);
drop table Possiede;
Create table Possiede(
nickP character (30) not null,
codiceP character (30) not null,
dataP character (10) not null,
oraP character (10) not null,
contratto character (30) not null,
ipoteca bit not null,
primary key (nickP, codiceP, dataP, oraP, contratto),
foreign key (codiceP, dataP, oraP) references Partita (codice, data,
ora) ON DELETE CASCADE ON UPDATE CASCADE,
foreign key (nickP) references Utente (nick) ON DELETE CASCADE ON
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
47
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
UPDATE CASCADE,
foreign key (contratto) references Contratto (nome) ON DELETE
CASCADE ON UPDATE CASCADE
);
drop table Edificabile;
Create table Edificabile(
valoreCasa integer (4) not null,
nomeE character (30) not null,
unique (valoreCasa, nomeE),
foreign key (nomeE) references Contratto (nome)ON DELETE CASCADE ON
UPDATE CASCADE
);
drop table Ha;
Create table Ha(
numeroCase integer (4) not null,
nickH character (30) not null,
codiceH character (30) not null,
dataH character (10) not null,
oraH character (10) not null,
nomeH character (30) not null,
primary key (nickH, codiceH, dataH, oraH, nomeH),
foreign key (nickH) references Utente (nick)ON DELETE CASCADE ON
UPDATE CASCADE,
foreign key (codiceH, dataH, oraH) references Partita (codice, data,
ora)ON DELETE CASCADE ON UPDATE CASCADE,
foreign key (nomeH) references Edificabile (nomeE)ON DELETE CASCADE
ON UPDATE CASCADE
);
drop table Caselle;
Create table Caselle(
numCasella integer (2) primary key,
nome character (30) not null
);
drop table Speciali;
Create table Speciali(
soldi integer (4) default 0,
testo varchar (300) not null,
numCaselleS integer (2) primary key,
foreign key (numCaselleS) references Caselle (numCasella)ON DELETE
CASCADE ON UPDATE CASCADE
);
drop table Territori;
Create table Territori(
colore character (30) not null,
numCasellaT integer (2) primary key,
foreign key (numCasellaT) references Caselle (numCasella)ON DELETE
CASCADE ON UPDATE CASCADE
);
drop table Carte;
Create table Carte(
numId integer (2) primary key,
testo varchar (300) not null,
importo integer (4) default '0'
);
drop table Imprevisti;
Create table Imprevisti(
numIdI integer (2) primary key references carte (numId),
foreign key (numIdI) references Carte (numId)ON DELETE CASCADE ON
UPDATE CASCADE
);
drop table Probabilita;
Create table Probabilita(
numIdP integer (2) primary key,
foreign key (numIdP) references Carte (numId)ON DELETE CASCADE ON
UPDATE CASCADE
);
drop table Utilizza;
Create table Utilizza (
nickU character (30) not null,
codiceU character (30) not null,
dataU character (10) not null,
oraU character (10) not null,
pedina character (8) not null,
primary key (nickU, codiceU,dataU, oraU, pedina),
foreign key (nickU) references Utente (nick)ON DELETE CASCADE ON
UPDATE CASCADE,
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
48
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
foreign key (codiceU, dataU, oraU) references Partita (codice, data,
ora)ON DELETE CASCADE ON UPDATE CASCADE,
foreign key (pedina) references Pedina (immagine)ON DELETE CASCADE
ON UPDATE CASCADE
);
drop table Associato;
create table Associato(
nomeA character (30) primary key,
numcasellaA integer (2) not null,
foreign key (nomeA) references Contratto (nome)ON DELETE CASCADE ON
UPDATE CASCADE,
foreign key (numcasellaA) references Territori (NumcasellaT)ON
DELETE CASCADE ON UPDATE CASCADE
);
drop table CaseAlberghi;
create table CaseAlberghi(
nomeCA character (30) not null,
numero integer (2) not null,
costo integer (5) not null,
unique (nomeCA, numero, costo),
foreign key (nomeCA) references Contratto (nome)ON DELETE CASCADE ON
UPDATE CASCADE
);
insert into Contratto values (60,'Stazione Nord', 480, 250);
insert into Contratto values (60, 'Stazione Sud', 480, 250);
insert into Contratto values (60, 'Stazione Est', 480, 250);
insert into Contratto values (60, 'Stazione Ovest', 480, 250);
insert into Contratto values (5, 'Vicolo Corto', 150, 75);
insert into Contratto values (10, 'Vicolo Stretto', 150, 75);
insert into Contratto values (15, 'Bastioni Gran Sasso', 250, 125);
insert into Contratto values (15, 'Viale Monterosa', 250, 125);
insert into Contratto values (20, 'Viale Vesuvio', 300, 150);
insert into Contratto values (25, 'Via Accademia', 350, 175);
insert into Contratto values (25, 'Corso Ateneo', 350, 175);
insert into Contratto values (30, 'Piazza Universita', 400, 200);
insert into Contratto values (35, 'Via Verdi', 450, 225);
insert into Contratto values (35, 'Corso Raffaello', 450, 225);
insert into Contratto values (40, 'Piazza Dante', 500, 250);
insert into Contratto values (45, 'Via Marco Polo', 550, 275);
insert into Contratto values (45, 'Corso Magellano', 550, 275);
insert into Contratto values (50, 'Largo Colombo', 600, 300);
insert into Contratto values (55, 'Viale Costantino', 650, 325);
insert into Contratto values (55, 'Viale Traiano', 650, 325);
insert into Contratto values (60, 'Piazza Giulio Cesare', 700, 350);
insert into Contratto values (65, 'Via Roma', 750, 375);
insert into Contratto values (65, 'Corso Impero', 750, 375);
insert into Contratto values (70, 'Largo Augusto', 800, 400);
insert into Contratto values (90, 'Viale dei Giardini', 900, 450);
insert into Contratto values (125, 'Parco della Vittoria', 1000, 500);
insert into Contratto values (50, 'Societa Elettrica', 380, 190);
insert into Contratto values (50, 'Societa Acqua Potabile', 380, 190);
insert into Edificabile values (125, 'Vicolo Corto');
insert into Edificabile values (125, 'Vicolo Stretto');
insert into Edificabile values (125, 'Bastioni Gran Sasso');
insert into Edificabile values (125, 'Viale Monterosa');
insert into Edificabile values (125, 'Viale Vesuvio');
insert into Edificabile values (250, 'Via Accademia');
insert into Edificabile values (250, 'Corso Ateneo');
insert into Edificabile values (250, 'Piazza Universita');
insert into Edificabile values (250, 'Via Verdi');
insert into Edificabile values (250, 'Corso Raffaello');
insert into Edificabile values (250, 'Piazza Dante');
insert into Edificabile values (375, 'Via Marco Polo');
insert into Edificabile values (375, 'Corso Magellano');
insert into Edificabile values (375, 'Largo Colombo');
insert into Edificabile values (375, 'Viale Costantino');
insert into Edificabile values (375, 'Viale Traiano');
insert into Edificabile values (375, 'Piazza Giulio Cesare');
insert into Edificabile values (500, 'Via Roma');
insert into Edificabile values (500, 'Corso Impero');
insert into Edificabile values (500, 'Largo Augusto');
insert into Edificabile values (500, 'Viale dei Giardini');
insert into Edificabile values (500, 'Parco della Vittoria');
insert into Caselle values ( 01,'Vicolo Corto');
insert into Caselle values ( 02,'Probabilita');
insert into Caselle values ( 03,'Vicolo Stretto');
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
49
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
insert into Caselle values ( 04,'Tassa Patrimoniale');
insert into Caselle values ( 05,'Stazione Sud');
insert into Caselle values ( 06,'Bastioni Gran Sasso');
insert into Caselle values ( 07,'Imprevisti');
insert into Caselle values ( 08,'Viale Monterosa');
insert into Caselle values ( 09,'Viale Vesuvio');
insert into Caselle values ( 10,'Prigione - Transito');
insert into Caselle values ( 11,'Via Accademia');
insert into Caselle values ( 12,'Societa Elettrica');
insert into Caselle values ( 13,'Corso Ateneo');
insert into Caselle values ( 14,'Piazza Universita');
insert into Caselle values ( 15,'Stazione Ovest');
insert into Caselle values ( 16,'Via Verdi');
insert into Caselle values ( 17,'Probabilita');
insert into Caselle values ( 18,'Corso Raffaello');
insert into Caselle values ( 19,'Piazza Dante');
insert into Caselle values ( 20,'Parcheggio Gratuito');
insert into Caselle values ( 21,'Via Marco Polo');
insert into Caselle values ( 22,'Imprevisti');
insert into Caselle values ( 23,'Corso Magellano');
insert into Caselle values ( 24,'Largo Colombo');
insert into Caselle values ( 25,'Stazione Nord');
insert into Caselle values ( 26,'Viale Costantino');
insert into Caselle values ( 27,'Viale Traiano');
insert into Caselle values ( 28,'Societa Acqua Potabile');
insert into Caselle values ( 29,'Piazza Giulio Cesare');
insert into Caselle values ( 30,'Prigione');
insert into Caselle values ( 31,'Via Roma');
insert into Caselle values ( 32,'Corso Impero');
insert into Caselle values ( 33,'Probabilita');
insert into Caselle values ( 34,'Largo Augusto');
insert into Caselle values ( 35,'Stazione Est');
insert into Caselle values ( 36,'Imprevisti');
insert into Caselle values ( 37,'Viale dei Giardini');
insert into Caselle values ( 38,'Tassa di Lusso');
insert into Caselle values ( 39,'Parco della Vittoria');
insert into Caselle values ( 40, 'Via');
insert into Territori values ('Rosa',01);
insert into Territori values ('Rosa', 03);
insert into Territori values ('Stazione', 05);
insert into Territori values ('Celeste', 06);
insert into Territori values ('Celeste', 08);
insert into Territori values ('Celeste', 09);
insert into Territori values ('Arancione',11);
insert into Territori values ('Societa', 12);
insert into Territori values ('Arancione', 13);
insert into Territori values ('Arancione', 14);
insert into Territori values ('Stazione', 15);
insert into Territori values ('Marrone',16);
insert into Territori values ('Marrone', 18);
insert into Territori values ('Marrone',19);
insert into Territori values ('Rosso', 21);
insert into Territori values ('Rosso', 23);
insert into Territori values ('Rosso', 24);
insert into Territori values ('Stazione', 25);
insert into Territori values ('Giallo', 26);
insert into Territori values ('Giallo', 27);
insert into Territori values ('Societa', 28);
insert into Territori values ('Giallo',29);
insert into Territori values ( 'Verde',31);
insert into Territori values ('Verde', 32);
insert into Territori values ('Verde', 34);
insert into Territori values ('Stazione', 35);
insert into Territori values ('Viola', 37);
insert into Territori values ('Viola', 39);
insert into Carte values (01, 'Maturano le cedole delle vostre cartelle di
rendita, ritirate 375 Euro', 375);
insert into Carte values (02, 'Matrimonio in famiglia spese impreviste 375
Euro',375);
insert into Carte values (03, 'Andate fino al Parco della Vittoria', 0);
insert into Carte values (04, 'Andate avanti fino al VIA', 0);
insert into Carte values (05, 'Andate sino a Via Accademia: se passate dal
<<Via!>> ritirate 500 Euro', 500);
insert into Carte values (06, 'Fate tre passi indietro (con tanti auguri!)', 0);
insert into Carte values (07, 'Cena fuori con la tua metà, pagate 50 Euro', 50);
insert into Carte values (08, 'Andate in prigione direttamente e senza passare
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
50
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
dal <<Via!>>', 0);
insert into Carte values (09, 'Avete tutti i vostri stabili da riparare: pagare
60 Euro per ogni casa e 250 Euro per ogni albergo', 0);
insert into Carte values (10, 'Andate sino al Largo Colombo se passate dal
<<Via!>> ritirate 500 Euro', 500);
insert into Carte values (11, 'Dovete pagare un contributo di miglioria
stradale, 100 Euro per ogni casa e 250 Euro per ogni albergo che possedete', 0);
insert into Carte values (12, 'Avete vinto un terno al lotto: ritirate 250
Euro', 250);
insert into Carte values (13, 'Versate 50 Euro per beneficenza', 50);
insert into Carte values (14, 'Andate alla Stazione NORD: se passate dal
<<Via!>> ritirate 500 Euro', 500);
insert into Carte values (15, 'La banca vi paga gli interessi del vostro conto
corrente, ritirate 125 Euro', 125);
insert into Carte values (16, 'Multa di 40 Euro per aver guidato senza patente',
40);
insert into Carte values (17, 'Andate fino al <<Via!>>', 0);
insert into Carte values (18, 'Andate in prigione direttamente e senza passare
dal <<Via!>>', 0);
insert into Carte values (19, 'Cena fuori con la tua metà, pagate 50 Euro', 50);
insert into Carte values (20, 'Complimenti S maturata la cedola delle vostre
azioni ritirate 60 Euro', 60);
insert into Carte values (21, 'Pagate una multa di 25 Euro', 25);
insert into Carte values (22, 'Avete vinto il secondo premio in un concorso di
bellezza: ritirate 25 Euro', 25);
insert into Carte values (23, 'Ritornate al Vicolo Corto', 0);
insert into Carte values (24, 'Scade il vostro premio di assicrazione pagate 125
Euro', 125);
insert into Carte values (25, 'Avete perso una causa: pagate 250 Euro', 250);
insert into Carte values (26, 'Ereditate da un lontano parente 250 Euro', 250);
insert into Carte values (27, 'Pagate il conto del Dottore: 125 Euro', 125);
insert into Carte values (28, 'Rimborso tassa sul reddito: ritirate 50 Euro
dalla Banca', 50);
insert into Carte values (29, 'Auguri!!! il vostro compleanno: ogni giocatore vi
regala 25 Euro', 25);
insert into Carte values (30, 'Avete venduto delle azioni ricavate 125 Euro',
125);
insert into Carte values (31, 'Siete creditori verso la Banca di 500 Euro:
ritirateli', 500);
insert into Carte values (32, 'Avete vinto un premio di consolazione alla
Lotteria di Merano: ritirate 250 Euro', 250);
insert into Imprevisti values (01);
insert into Imprevisti values (02);
insert into Imprevisti values (03);
insert into Imprevisti values (04);
insert into Imprevisti values (05);
insert into Imprevisti values (06);
insert into Imprevisti values (07);
insert into Imprevisti values (08);
insert into Imprevisti values (09);
insert into Imprevisti values (10);
insert into Imprevisti values (11);
insert into Imprevisti values (12);
insert into Imprevisti values (13);
insert into Imprevisti values (14);
insert into Imprevisti values (15);
insert into Imprevisti values (16);
insert into Probabilita values (17);
insert into Probabilita values (18);
insert into Probabilita values (19);
insert into Probabilita values (20);
insert into Probabilita values (21);
insert into Probabilita values (22);
insert into Probabilita values (23);
insert into Probabilita values (24);
insert into Probabilita values (25);
insert into Probabilita values (26);
insert into Probabilita values (27);
insert into Probabilita values (28);
insert into Probabilita values (29);
insert into Probabilita values (30);
insert into Probabilita values (31);
insert into Probabilita values (32);
insert into Associato values ('Bastioni Gran Sasso', 06);
insert into Associato values ('Corso Ateneo', 13);
insert into Associato values ('Corso Impero', 32);
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
51
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
into
Associato values ('Corso Magellano', 23);
Associato values ('Corso Raffaello', 18);
Associato values ('Largo Augusto', 24);
Associato values ('Largo Colombo', 34);
Associato values ('Parco della Vittoria', 39);
Associato values ('Piazza Dante', 19);
Associato values ('Piazza Giulio Cesare', 29);
Associato values ('Piazza Universita', 14);
Associato values ('Societa Acqua Potabile', 28);
Associato values ('Societa Elettrica', 12);
Associato values ('Stazione Est', 35);
Associato values ('Stazione Nord', 25);
Associato values ('Stazione Ovest', 15);
Associato values ('Stazione Sud', 05);
Associato values ('Via Accademia', 11);
Associato values ('Via Marco Polo', 21);
Associato values ('Via Roma', 31);
Associato values ('Via Verdi', 16);
Associato values ('Viale Costantino', 26);
Associato values ('Viale dei Giardini', 37);
Associato values ('Viale Monterosa', 08);
Associato values ('Viale Traiano', 27);
Associato values ('Viale Vesuvio', 09);
Associato values ('Vicolo Corto', 01);
Associato values ('Vicolo Stretto', 03);
Pedina values ('Fiasco');
Pedina values ('Fungo');
Pedina values ('Candela');
Pedina values ('Pianta');
Pedina values ('Pera');
Pedina values ('Mela');
CaseAlberghi values ('Vicolo Corto', 01, 25);
CaseAlberghi values ('Vicolo Corto', 02, 75);
CaseAlberghi values ('Vicolo Corto', 03, 225);
CaseAlberghi values ('Vicolo Corto', 04, 400);
CaseAlberghi values ('Vicolo Corto', 05, 625);
CaseAlberghi values ('Vicolo Stretto', 01, 50);
CaseAlberghi values ('Vicolo Stretto', 02, 150);
CaseAlberghi values ('Vicolo Stretto', 03, 450);
CaseAlberghi values ('Vicolo Stretto', 04, 800);
CaseAlberghi values ('Vicolo Stretto', 05, 1125);
CaseAlberghi values ('Bastioni Gran Sasso', 01,75);
CaseAlberghi values ('Bastioni Gran Sasso', 02,225);
CaseAlberghi values ('Bastioni Gran Sasso', 03,675);
CaseAlberghi values ('Bastioni Gran Sasso', 04,1000);
CaseAlberghi values ('Bastioni Gran Sasso', 05,1375);
CaseAlberghi values ('Viale Monterosa', 01, 75);
CaseAlberghi values ('Viale Monterosa', 02, 225);
CaseAlberghi values ('Viale Monterosa', 03, 675);
CaseAlberghi values ('Viale Monterosa', 04, 1000);
CaseAlberghi values ('Viale Monterosa', 05, 1375);
CaseAlberghi values ('Viale Vesuvio', 01, 100);
CaseAlberghi values ('Viale Vesuvio', 02, 250);
CaseAlberghi values ('Viale Vesuvio', 03, 750);
CaseAlberghi values ('Viale Vesuvio', 04, 1125);
CaseAlberghi values ('Viale Vesuvio', 05, 1500);
CaseAlberghi values ('Via Accademia', 01, 125);
CaseAlberghi values ('Via Accademia', 02, 375);
CaseAlberghi values ('Via Accademia', 03, 1125);
CaseAlberghi values ('Via Accademia', 04, 1550);
CaseAlberghi values ('Via Accademia', 05, 1875);
CaseAlberghi values ('Corso Ateneo', 01, 125);
CaseAlberghi values ('Corso Ateneo', 02, 175);
CaseAlberghi values ('Corso Ateneo', 03, 1125);
CaseAlberghi values ('Corso Ateneo', 04, 1550);
CaseAlberghi values ('Corso Ateneo', 05, 1875);
CaseAlberghi values ('Piazza Universita', 01, 150);
CaseAlberghi values ('Piazza Universita', 02, 450);
CaseAlberghi values ('Piazza Universita', 03, 1250);
CaseAlberghi values ('Piazza Universita', 04, 1750);
CaseAlberghi values ('Piazza Universita', 05, 2250);
CaseAlberghi values ('Via Verdi', 01, 175);
CaseAlberghi values ('Via Verdi', 02, 500);
CaseAlberghi values ('Via Verdi', 03, 1375);
CaseAlberghi values ('Via Verdi', 04, 1875);
CaseAlberghi values ('Via Verdi', 05, 2375);
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
52
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
insert into CaseAlberghi values ('Corso Raffaello', 01, 175);
insert into CaseAlberghi values ('Corso Raffaello', 02, 500);
insert into CaseAlberghi values ('Corso Raffaello', 03, 1375);
insert into CaseAlberghi values ('Corso Raffaello', 04, 1875);
insert into CaseAlberghi values ('Corso Raffaello', 05, 2375);
insert into CaseAlberghi values ('Piazza Dante', 01, 200);
insert into CaseAlberghi values ('Piazza Dante', 02, 550);
insert into CaseAlberghi values ('Piazza Dante', 03, 1500);
insert into CaseAlberghi values ('Piazza Dante', 04, 2000);
insert into CaseAlberghi values ('Piazza Dante', 05, 2500);
insert into CaseAlberghi values ('Via Marco Polo', 01, 225);
insert into CaseAlberghi values ('Via Marco Polo', 02, 625);
insert into CaseAlberghi values ('Via Marco Polo', 03, 1750);
insert into CaseAlberghi values ('Via Marco Polo', 04, 2200);
insert into CaseAlberghi values ('Via Marco Polo', 05, 2625);
insert into CaseAlberghi values ('Corso Magellano', 01, 225);
insert into CaseAlberghi values ('Corso Magellano', 02, 625);
insert into CaseAlberghi values ('Corso Magellano', 03, 1750);
insert into CaseAlberghi values ('Corso Magellano', 04, 2200);
insert into CaseAlberghi values ('Corso Magellano', 05, 2625);
insert into CaseAlberghi values ('Largo Colombo', 01, 250);
insert into CaseAlberghi values ('Largo Colombo', 02, 750);
insert into CaseAlberghi values ('Largo Colombo', 03, 1875);
insert into CaseAlberghi values ('Largo Colombo', 04, 2250);
insert into CaseAlberghi values ('Largo Colombo', 05, 2750);
insert into CaseAlberghi values ('Viale Costantino', 01, 275);
insert into CaseAlberghi values ('Viale Costantino', 02, 825);
insert into CaseAlberghi values ('Viale Costantino', 03, 2000);
insert into CaseAlberghi values ('Viale Costantino', 04, 2500);
insert into CaseAlberghi values ('Viale Costantino', 05, 3000);
insert into CaseAlberghi values ('Viale Traiano', 01, 275);
insert into CaseAlberghi values ('Viale Traiano', 02, 825);
insert into CaseAlberghi values ('Viale Traiano', 03, 2000);
insert into CaseAlberghi values ('Viale Traiano', 04, 2500);
insert into CaseAlberghi values ('Viale Traiano', 05, 3000);
insert into CaseAlberghi values ('Piazza Giulio Cesare', 01, 300);
insert into CaseAlberghi values ('Piazza Giulio Cesare', 02, 900);
insert into CaseAlberghi values ('Piazza Giulio Cesare', 03, 2125);
insert into CaseAlberghi values ('Piazza Giulio Cesare', 04, 2625);
insert into CaseAlberghi values ('Piazza Giulio Cesare', 05, 3125);
insert into CaseAlberghi values ('Via Roma', 01, 325);
insert into CaseAlberghi values ('Via Roma', 02, 1000);
insert into CaseAlberghi values ('Via Roma', 03, 2250);
insert into CaseAlberghi values ('Via Roma', 04, 2750);
insert into CaseAlberghi values ('Via Roma', 05, 3250);
insert into CaseAlberghi values ('Corso Impero', 01, 325);
insert into CaseAlberghi values ('Corso Impero', 02, 1000);
insert into CaseAlberghi values ('Corso Impero', 03, 2250);
insert into CaseAlberghi values ('Corso Impero', 04, 2750);
insert into CaseAlberghi values ('Corso Impero', 05, 3250);
insert into CaseAlberghi values ('Largo Augusto', 01, 375);
insert into CaseAlberghi values ('Largo Augusto', 02, 1125);
insert into CaseAlberghi values ('Largo Augusto', 03, 2500);
insert into CaseAlberghi values ('Largo Augusto', 04, 3000);
insert into CaseAlberghi values ('Largo Augusto', 05, 3500);
insert into CaseAlberghi values ('Viale dei Giardini', 01, 500);
insert into CaseAlberghi values ('Viale dei Giardini', 02, 1250);
insert into CaseAlberghi values ('Viale dei Giardini', 03, 2750);
insert into CaseAlberghi values ('Viale dei Giardini', 04, 3000);
insert into CaseAlberghi values ('Viale dei Giardini', 05, 3500);
insert into CaseAlberghi values ('Parco della Vittoria', 01, 500);
insert into CaseAlberghi values ('Parco della Vittoria', 02, 1500);
insert into CaseAlberghi values ('Parco della Vittoria', 03, 3500);
insert into CaseAlberghi values ('Parco della Vittoria', 04, 4250);
insert into CaseAlberghi values ('Parco della Vittoria', 05, 5000);
drop table Turno;
create table Turno(
nickT character (30) not null,
codiceT character (30) not null,
dataT character (10) not null,
oraT character (10) not null,
primary key (nickT, codiceT,dataT, oraT),
foreign key (nickT) references Utente (nick) ON DELETE CASCADE ON
UPDATE CASCADE
);
drop table Vincitore;
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
53
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Create table Vincitore(
saldofinale int (10) not null,
nickV character (30) not null,
codiceV character (30) not null,
dataV character (10) not null,
oraV character (10) not null,
primary key (codiceV, dataV, oraV)
);
drop table URL;
Create table URL (
Nome character (30) not null,
Url character (100) primary key,
unique (Nome, Url)
);
insert into Url values ('Vicolo Stretto',
'prototipofreddo5Territori_files/VicoloStretto.jpg');
insert into Url values ('Vicolo StrettoR',
'prototipofreddo5Territori_files/VicoloStretto_retro.jpg');
insert into Url values ('Vicolo Corto',
'prototipofreddo5Territori_files/VicoloCorto.jpg');
insert into Url values ('Vicolo CortoR',
'prototipofreddo5Territori_files/VicoloCorto_retro.jpg');
insert into Url values ('Viale Vesuvio',
'prototipofreddo5Territori_files/VialeVesuvio.jpg');
insert into Url values ('Viale VesuvioR',
'prototipofreddo5Territori_files/VialeVesuvio_retro.jpg');
insert into Url values ('Viale Traiano',
'prototipofreddo5Territori_files/VialeTraiano.jpg');
insert into Url values ('Viale TraianoR',
'prototipofreddo5Territori_files/VialeTraiano_retro.jpg');
insert into Url values ('Viale Monterosa',
'prototipofreddo5Territori_files/VialeMonterosa.jpg');
insert into Url values ('Viale MonterosaR',
'prototipofreddo5Territori_files/VialeMonterosa_retro.jpg');
insert into Url values ('Viale dei Giardini',
'prototipofreddo5Territori_files/VialeDeiGiardini.jpg');
insert into Url values ('Viale dei GiardiniR',
'prototipofreddo5Territori_files/VialeDeiGiardini_retro.jpg');
insert into Url values ('Viale Costantino',
'prototipofreddo5Territori_files/VialeCostantino.jpg');
insert into Url values ('Viale CostantinoR',
'prototipofreddo5Territori_files/VialeCostantino_retro.jpg');
insert into Url values ('Via Verdi',
'prototipofreddo5Territori_files/ViaVerdi.jpg');
insert into Url values ('Via VerdiR',
'prototipofreddo5Territori_files/ViaVerdi_retro.jpg');
insert into Url values ('Via Roma',
'prototipofreddo5Territori_files/ViaRoma.jpg');
insert into Url values ('Via RomaR',
'prototipofreddo5Territori_files/ViaRoma_retro.jpg');
insert into Url values ('Via Marco Polo',
'prototipofreddo5Territori_files/ViaMarcoPolo.jpg');
insert into Url values ('Via Marco PoloR',
'prototipofreddo5Territori_files/ViaMarcoPolo_retro.jpg');
insert into Url values ('Via Accademia',
'prototipofreddo5Territori_files/ViaAccademia.jpg');
insert into Url values ('Via AccademiaR',
'prototipofreddo5Territori_files/ViaAccademia_retro.jpg');
insert into Url values ('Stazione Sud',
'prototipofreddo5Territori_files/StazioneSud.jpg');
insert into Url values ('Stazione SudR',
'prototipofreddo5Territori_files/StazioneSud_retro.jpg');
insert into Url values ('Stazione Ovest',
'prototipofreddo5Territori_files/StazioneOvest.jpg');
insert into Url values ('Stazione OvestR',
'prototipofreddo5Territori_files/StazioneOvest_retro.jpg');
insert into Url values ('Stazione Nord',
'prototipofreddo5Territori_files/StazioneNord.jpg');
insert into Url values ('Stazione NordR',
'prototipofreddo5Territori_files/StazioneNord_retro.jpg');
insert into Url values ('Stazione Est',
'prototipofreddo5Territori_files/StazioneEst.jpg');
insert into Url values ('Stazione EstR',
'prototipofreddo5Territori_files/StazioneEst_retro.jpg');
insert into Url values ('Societa Elettrica',
'prototipofreddo5Territori_files/SocietaElettrica.jpg');
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
54
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
insert into Url values ('Societa ElettricaR',
'prototipofreddo5Territori_files/SocietaElettrica_retro.jpg');
insert into Url values ('Societa Acqua Potabile',
'prototipofreddo5Territori_files/SocietaAcquaPotabile.jpg');
insert into Url values ('Societa Acqua PotabileR',
'prototipofreddo5Territori_files/SocietaAcquaPotabile_retro.jpg');
insert into Url values ('Piazza Universita',
'prototipofreddo5Territori_files/PiazzaUniversita.jpg');
insert into Url values ('Piazza UniversitaR',
'prototipofreddo5Territori_files/PiazzaUniversita_retro.jpg');
insert into Url values ('Piazza Giulio Cesare',
'prototipofreddo5Territori_files/PiazzaGiulioCesare.jpg');
insert into Url values ('Piazza Giulio CesareR',
'prototipofreddo5Territori_files/PiazzaGiulioCesare_retro.jpg');
insert into Url values ('Piazza Dante',
'prototipofreddo5Territori_files/PiazzaDante.jpg');
insert into Url values ('Piazza DanteR',
'prototipofreddo5Territori_files/PiazzaDante_retro.jpg');
insert into Url values ('Parco della Vittoria',
'prototipofreddo5Territori_files/ParcoDellaVittoria.jpg');
insert into Url values ('Parco della VittoriaR',
'prototipofreddo5Territori_files/ParcoDellaVittoria_retro.jpg');
insert into Url values ('Largo Colombo',
'prototipofreddo5Territori_files/LargoColombo.jpg');
insert into Url values ('Largo ColomboR',
'prototipofreddo5Territori_files/LargoColombo_retro.jpg');
insert into Url values ('Largo Augusto',
'prototipofreddo5Territori_files/LargoAugusto.jpg');
insert into Url values ('Largo AugustoR',
'prototipofreddo5Territori_files/LargoAugusto_retro.jpg');
insert into Url values ('Corso Raffaello',
'prototipofreddo5Territori_files/CorsoRaffaello.jpg');
insert into Url values ('Corso RaffaelloR',
'prototipofreddo5Territori_files/CorsoRaffaello_retro.jpg');
insert into Url values ('Corso Magellano',
'prototipofreddo5Territori_files/CorsoMagellano.jpg');
insert into Url values ('Corso MagellanoR',
'prototipofreddo5Territori_files/CorsoMagellano_retro.jpg');
insert into Url values ('Corso Impero',
'prototipofreddo5Territori_files/CorsoImpero.jpg');
insert into Url values ('Corso ImperoR',
'prototipofreddo5Territori_files/CorsoImpero_retro.jpg');
insert into Url values ('Corso Ateneo',
'prototipofreddo5Territori_files/CorsoAteneo.jpg');
insert into Url values ('Corso AteneoR',
'prototipofreddo5Territori_files/CorsoAteneo_retro.jpg');
insert into Url values ('Bastioni Gran Sasso',
'prototipofreddo5Territori_files/BastioniGranSasso.jpg');
insert into Url values ('Bastioni Gran SassoR',
'prototipofreddo5Territori_files/BastioniGranSasso_retro.jpg');
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
55
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5.4 Prototipazione
L’obiettivo della prototipazione è quello di fornire in tempi rapidi un documento a scopo
dimostrativo che presenti il prodotto. Il fine è quello di dare un’idea di massima al cliente della
struttura dell’applicazione e coinvolgerlo fin da subito nello sviluppo, ma serve anche e soprattutto
a chiarire le idee sui requisiti del sistema e sulle conseguenti scelte progettuali.
Nel nostro caso viene fornito un prototipo freddo che implementa le funzionalità più importanti del
sistema per ciascun utente.
5.4.1 Prototipo freddo
Il prototipo freddo è realizzato in pagine HTML e JavaScript.
Il JavaScript è utilizzato per controllare il riempimento e la coerenza dei dati inseriti nei campi
form. I collegamenti tra le pagine sono realizzati attraverso link statici inseriti come collegamento
ipertestuale o come “action” della form; non vi è dunque alcuna manipolazione sui dati inseriti ma
tutto viene simulato a scopo dimostrativo.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
56
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5.4.2 Schema di navigazione del sito tramite ADM (Araneus Data Model)
Araneus Data Model è un formalismo logico utilizzato nella progettazione di siti web per modellare
pagine ipertestuali. Gli schemi ADM descrivono la struttura delle pagine (page scheme) e come
queste sono collegate tra di loro. I tipi previsti da ADM sono:
Figura 15
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
57
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
In questo progetto ADM è stato utilizzato per documentare il prototipo freddo e questi sono gli
schemi relativi alle tre aree dell’applicazione:
Figura 16
* Per migliore visualizzazione e chiarezza del diagramma, essendo Trattativa e TrattativaBis
nell’ADM sono state visualizzate come unica pagina web avendo l’interfaccia molto simile.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
58
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
5.5 Design model
Questa fase rappresenta il cuore della progettazione. È qui che vanno a definirsi tutte le scelte
progettuali che caratterizzeranno il sistema in ogni suo dettaglio. È importante dunque lavorare bene
su questa parte, cercando di mantenere una buona coerenza nella modellazione, in modo da
prepararsi al meglio per la stesura del codice. Tuttavia, proprio per la difficoltà di queste attività (ed
anche per la nostra inesperienza), sarà necessario un intenso lavoro di raffinamento parallelo
all’implementazione.
5.5.1 Implementation model
L’Implementation model è un insieme di diagrammi UML che descrive come è strutturato il
software dell’applicazione anche rispetto alle risorse Hardware.
5.5.1.1 Component diagram
Il Component diagram si specializza sui componenti software e su come questi sono relazionati tra
loro.
Figura 17 : Design model
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
59
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
6 Implementazione
6.1 Introduzione
Questo docunento spiega sinteticamente i punti principali che caratterizzano la realizzazione
dell’applicazione. Le informazioni che riguardano più da vicino il codice sono state commentate
nelle varie classi e sono disponibili nelle API (Application Program Interface) (/doc/index.htm).
Lo scopo principale del documento è quello di trattare le tecniche utilizzate ed i problemi critici che
abbiamo incontrato.
6.2 Pagine web
Come già anticipato nelle fasi precedenti, in questa sede è stata completamente rivista la veste
grafica. Le pagine statiche e dinamiche dell’applicazione sono state ridisegnate utilizzando un
nuovo template grafico.
6.2.1 Template grafico
A titolo di esempio, riportiamo le prime pagine del sito:
Figura 18 : Homepage
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
60
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Figura 19 : Registrazione
Figura 20 : Sala d’attesa
Rimanendo vicino al prototipo freddo abbiamo creato le pagine del sito in modo da somigliare il più
possibile al gioco reale del Monopoli.
Abbiamo scelto di non sovraccaricare la pagina del tabellone con l’immagine di sfondo anche per
rendere più snello il continuo aggiornamento di essa.
Implementazione del template grafico
L’implementazione anche se non è effettivamente difficoltosa, ha richiesto molto tempo per
l’implementazione dei molteplici controlli di validazione, visibilità e stabilità della pagina.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
61
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
6.2.2 Motivazioni delle scelte generali
Abbiamo voluto riportare il Monopoli così comè, da gioco da tavolo ad interattivo cambiando il
meno possibile.
6.2.3 Stile
Lo stile utilizzato è uno stile chiaro che non risalti fastidioso agli occhi e quindi sono stati utilizzati
colori VERDE e CELESTINO.
6.2.4 Sfondo
E’ stato scelto uno sfondo che ha lo stesso colore del tabellone del gioco
6.2.5 Immagini varie
Le immagini sono state prese direttamente tramite scanner dal gioco o trovate su internet
6.2.6 Scelte implementative
Data
Si è scelto di utilizzare per la rappresentazione delle date in concatenazioni di stringhe invece che
utilizzare gli oggetti delle librerie java a causa della difficoltà della loro manipolazione e per
renderle sicuaramente più pobili in caso di cambio della piattaforma del DB.
Contesto
A causa del carattere interattivo del progetto si è reso necessario l’utilizzo del servletContext
(contesto), per permettere il passaggio di informazioni tra i vari utenti. Per l’utilizzo del contesto,
avendo la necessità, di rendere univoche le chiavi che permettevano l’accesso a vari attributi, sono
stati implementati, nella classe servleUtil.java, una serie di metodi (riconoscibili dal prefisso
“codifica” nel loro nome) che generavano il tag dell’attributo concatenando tra di loro un carattere
speciale, identificativo di un tipo di attributo, con delle stringhe.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
62
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
6.3 Problemi riscontrati
6.3.1 Eclipse
Scarsa portabilità di un progetto da una macchina ad un’altra con riconfigurazione totale dell’IDE.
Rilevazione di falsi errori persistenti, di tag del codice HTML, a volte anche in Java ma risolti con
un Clean and Build (pulisci e compila).
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
63
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
7 Manuale d’installazione
7.1 Operazioni preliminari
Prima di procedere all’installazione dell’applicazione occorre installare tutti i componenti necessari.
7.1.1 Installazione Java Virtual Machine: JDK 1.6
L’applicazione è sviluppata in Java 1.6 dunque la macchina deve essere provvista della console java
aggiornata. Qualora non fosse così, è possibile scaricare la versione per il proprio sistema operativo
dal sito:
http://java.sun.com/javase/downloads/index.jsp.
È comunque possibile trovare la versione per Windows nella directory installazione nel file:
jdk-6u2-windows-i586-p.exe.
Lanciare il file e seguire la procedura di installazione lasciando le scelte di default.
7.1.2 Installazione DBMS: MySQL 5
Il file che si trova all’interno della directory installazione riguarda la versione di MySQL per
ambiente Windows dal nome: mysql-essential-5.0.41-win32.msi. Per altri sistemi operativi scaricare
la versione dal sito www.mysql.com. Scegliere la modalità d’installazione “tipica” e nel wizard di
configurazione scegliere standard configuration. Nella seguente schermata lasciare le seguenti
impostazioni. Si consiglia di impostare lo start del server all’avvio.
Figura 21
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
64
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Fare attenzione all’eventuale password immessa come utente di root, per non mettere password
deselezionare l’opzione Modify Security Settings:
Figura 22
Per le prime applicazioni si consiglia di non la password. Tutte le altre impostazioni possono essere
lasciate di default.
7.1.3 Installazione Web Server: Apache TomCat 6
Lanciare il file apache-tomcat-6.0.20.exe che trovate nella directory installazione. Anche in questo
caso porre attenzione alla password di accesso che viene chiesta di inserire:
Figura 23
Si consiglia di non mettere password per le prime applicazioni. Tutte le altre inpostazioni possono
essere lasciate di default.
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
65
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
7.2 Installazione
7.2.1 Avvio del DBMS
Digitare dal prompt di comandi il comando:
> mysqld --user root
Il DBMS può essere avviato anche manualmente come servizio esterno che, in ambiente windows si
trova in pannello di controllo → strumenti di amministrazione → servizi → mysql.
Per spegnerlo si può procedere nello stesso modo oppure digitando da prompt dei comanti:
> mysqladmin --user root shutdown
7.2.2 Creazione e popolamento del database
Una volta avviato il DBMS, digitare dal prompt dei comandi:
> mysql –u root (senza password)
> mysql –u root –p (con password)
Inserire la password di root (soltanto se prevista durante l’installazione). In questo modo accederete
a MySQL come utente root e verrà visualizzata la schermata:
Figura 24
Da qui inserire il comando:
> source C:/Monopoli/Creazione_DataBase.sql (inserire la lettera del proprio
drive)
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
66
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
Vengono così create e popolate con alcuni dati, tutte le tabelle del database e l’utente di lavoro:
Figura 25
A questo punto il database è correttamente settato per l’utilizzo.
7.2.3 Copia dei contenuti web
Copiare il file di progetto “Monopoli.war” dentro la cartella webapps di TomCat (ricordarsi dove
l’avete installato, normalmente si trova in C:\Programmi\Apache Software Foundation\TomCat 6).
7.2.4 Avvio del Web Server
TomCat può essere avviato lanciando il file tomcat6.exe all’interno della cartella bin di TomCat
oppure, in ambiente Windows, lanciare Monitor Tomcat che trovate in Start → Programmi →
Apache TomCat 6 ed apparirà un’icona in basso a destra. Da questa, nel caso sia di colore rosso,
cliccare con il tasto destro, selezionare start service e diventerà di colore verde. Eseguire questa
operazione soltanto dopo aver copiato i cotenuti web.
7.2.5 Lanciare applicazione
Dopo aver seguito tutti i passi precedenti, utilizzare un qualsiasi browser (alcuni diversi da Internet
Explorer potrebbero dare problemi sullo stile grafico) e inserire l’indirizzo:
http://localhost:8080/Monopoli-WebApplication/
Si accede così alla pagina iniziale “index.html” dove si può entrare nella HomePage del gioco,
leggere le regole dl gioco o consultare la documentazione
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
67
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
7.2.6 Primo accesso (Log-in / Registrazione)
Se non avete un vostro account clicca su registrati, compila la form, e poi effettua il Log-in dalla
Home-Page
Nick : *****
Password: ********
Da ora potrai divertirti con la nuova versione del Monopoli On-Line!
7.3 Utilizzo dell’applicazione
Una volta effettuato il Log-in ti troverai nella “sala d’attesa”, qui puoi fare diverse azioni:
Creare una partita.
Per creare una partita bisognerà inserire il nome della partita, selezionare “crea” dal
menù “modalità”, scegliere la pedina con cui giocare e selezionare il numero di
giocatori che parteciperanno alla partita, poi premere “ok”.
Partecipare ad una partita già creata.
Per partecipare ad una partita bisognerà inserire il nome della partita (scelto tra quelli
dell’elenco partite in attesa), selezionare “partecipa” dal menù “modalità”, inserire la
data e l’ora della partita, scegliere la pedina con cui giocare e premere “ok”.
Ripristinare una partita salvata in precedenza.
Per ripristinare una partita salvata bisognerà inserire il nome della partita (scelto tra
quelli dell’elenco partite salvate), selezionare “ripristina” dal menù “modalità”,
inserire la data e l’ora della partita, premere “ok”.
Visualizzare la classifica geneale.
Semplice click sul tasto per visualizzare l’elenco dei punteggi ottenuti dai vincitori
delle partite concluse.
Effettuare il Log-out.
Semplice click per uscire dal gioco
Nella partita o pagina chiamata “Tabellone”:
Tira dadi
Visualizzare i territori di un giocatore
Effettuare una trattativa con un giocatore
Comprare o vendere case
Ipotecare o disipotecare un territorio
Salvare la partita corrente
Ritirarsi dalla partita corrente
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
68
Reingegnerizzazione di un applicativo web:
Monopoli on-line
____________________________________________________________________________________________________________
8 Commenti e ringraziamenti
Commenti
La scelta di avere un’architettura a più livelli mi ha sicuramente aiutato nel ridefinire le classi java
di ogni livello e l’inserimento dei frameworks è stato facilitato perché non esisteva la possibilità di
compromettere la totalità della struttura dell’applicazione. Certamente si è rivelato efficace
l’utilizzo dei frameworks che hanno ridotto notevolmente il tempo di stesura del codice. Ad
esempio struts dà la possibilità utilizzare delle classi pre-create, quindi si parte da uno scheletro già
definito.
Ringraziamenti
E’ sempre difficile trovare parole giuste per ringraziare tutti coloro che hanno creduto in me, che mi
hanno incitato e convinto a prendere il cosiddetto “Pezzo di carta”. Ma visto che ora
FINALMENTE ci sono riuscito e per vostra sfortuna dovrete aggiungere Dott. o Ing. davanti al mio
nome farò un piccolo sforzo per riuscire a ringraziare tutti voi.
GRAZIE! GRAZIE! GRAZIE!
a Emanuela,
ai miei genitori e a tutta la mia famiglia,
alla famiglia di Emanuela,
ai miei amici,
ai colleghi INPS e CSC
e tutti coloro che ci hanno creduto!
ancora
GRAZIE!
Andrea
____________________________________________________________________________________________________________
Università di Roma “La Sapienza”
Tesi di Laurea in Ingegneria Informatica
69
