Introdotto oltre 15 anni fa con lo sviluppo di Windows 95, Microsoft avrebbe così, anche se ancora non è confermato ufficialmente, deciso di rimuovere quello che è stato uno dei marchi distintivi del sistema operativo. A mostrarlo sarebbero gli screenshot della versione Consumer Preview (build 8220) emersi negli ultimi giorni e che mostrano chiaramente una barra delle applicazioni priva del caratteristico pulsante start. Questo pulsante era già stato appiattito e annerito, per diventare quanto più simile alla nuova interfaccia metro, nelle build di test di Windows 8 distribuite nei mesi passati.

ORA-01034: Oracle not available
ORA-27101: shared memory realm does not exist
SVR4 Error: 2: No such file or directory

Questo errore può verificarsi se il database, o meglio alcuni servizi non sono stati avviati correttamente, nonostante tra i servizi windows ci sia scritto “Avviato”.

La risoluzione è molto semplice, occorre aprire una sessione DOS o SHELL e digitare i seguenti comandi:

1. sqlplus /nolog
2. connect / as sysdba
3. startup

Il risultato dovrà essere il seguente:

Istanza ORACLE avviata.

Total System Global Area 210837208 bytes
Fixed Size 454360 bytes
Variable Size 159383552 bytes
Database Buffers 50331648 bytes
Redo Buffers 667648 bytes
Database montato.
Database aperto.

Io per primo ho avuto la necessità di sviluppare su Firefox 9, e quindi dopo qualche ora di lavoro, ecco qui pronto “GWT Developer Plugin per Firefox 9″.

Il plugin è testato e funzionante su tutte le piattaforme e sistemi operativi sia a 32bit che a 64bit. 

Ecco il link per il download: [get_link_pwd]

Hello, I just finished creating GWT Developer Plugin for Firefox 9.

The plugin is tested and running on all platforms.

Here is the link for download:  [get_link_pwd]

L’informazione territoriale può essere codificata in un sistema informativo geografico attraverso due tipologie principali di dato: il dato vettoriale e il dato raster.

I dati vettoriali sono costituiti da elementi semplici quali punti, linee e poligoni, codificati e memorizzati sulla base delle loro coordinate. Un punto viene individuato in un sistema informativo geografico attraverso le sue coordinate reali (x1, y1); una linea o un poligono attraverso la posizione dei suoi nodi (x1, y1; x2, y2; …). A ciascun elemento è associato un record del database informativo che contiene tutti gli attributi dell’oggetto rappresentato.

Il dato raster permette di rappresentare il mondo reale attraverso una matrice di celle, generalmente di forma quadrata o rettangolare, dette pixel. A ciascun pixel sono associate le informazione relative a ciò che esso rappresenta sul territorio. La dimensione del pixel (detta anche pixel size), generalmente espressa nell’unità di misura della carta (metri, chilometri etc.), è strettamente relazionata alla precisione del dato.

I dati vettoriali e i dati raster si adattano ad usi diversi. La cartografia vettoriale è particolarmente adatta alla rappresentazione di dati che variano in modo discreto (ad esempio l’ubicazione dei cassonetti dei rifiuti di una città o la rappresentazione delle strade o una carta dell’uso del suolo), la cartografia raster è più adatta alla rappresentazione di dati con variabilità continua (ad esempio un modello digitale di elevazione o una carta di acclività del versante).

Uno dei formati più utilizzati per la memorizzazione di dati vettoriali è lo shapefile ESRI. Il formato è stato sviluppato e regolato da ESRI ed emesso come open standard, allo scopo di accrescere l’interoperabilità fra i sistemi ESRI e altri GIS. Di fatto è diventato uno standard per il dato vettoriale spaziale, e viene usato da una grande varietà di sistemi GIS.

Con “shapefile” si indica di norma un insieme di file con estensione .shp, .dbf, .shx, altre che hanno in comune il prefisso dei nomi (per es. “laghi.*”). Spesso con shapefile si indica però solo i file “.shp”. Tuttavia questo file da solo è incompleto poiché interpretazione ed utilizzo dipendono dagli altri file.

Gli shapefile descrivono spazialmente punti, poligoni, polilinee utilizzabili, ad es., per rappresentare stagni, laghi e fiumi, rispettivamente. A ciascun elemento possono essere associati ulteriori attributi che descrivono le voci (ad es. nome o temperatura).

Uno shapefile è considerato come un unico insieme, ma in realtà è l’insieme di più file. Tre file sono obbligatori, senza di essi uno shapefile non è tale; ad essi si possono aggiungere altri 9 file che conservano indici e dati accessori. Tutti i file di uno Shapefile sono allocati nella stessa cartella:

File obbligatori:

• .shp – il file che conserva le geometrie;
• .shx – il file che conserva l’indice delle geometrie;
• .dbf – il database degli attributi.

File opzionali:

• .sbn e .sbx – indici spaziali;
• .fbn e .fbx – indici spaziali delle feature in sola lettura;
• .ain e .aih – indici attributari dei campi della tabella;
• .prj – il file che conserva l’informazione sul sistema di coordinate, espresso in Well-Known Text;
• .shp.xml – metadato dello shapefile;
• .atx – indice attributario della tabella (file .dbf) nella forma <nome_shapefile>.<nome_colonna>.atx (ArcGIS 8 e superiori).

Una descrizione dettagliata del formato viene fornita nel seguente file pdf tratto dal sito della ESRI:

http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf

Possiamo reperire degli shapefile di esempio dalle seguenti URL:

http://www.mappinghacks.com/data/

http://udig.refractions.net/docs/data.zip

Dal sito dell’Istat è possibile inoltre scaricare gli shapefile delle Regioni, Province e Comuni di Italia raggruppati per anno (2001, 2008 e 2010):

http://www.istat.it/ambiente/cartografia/

Vediamo ora come poter realizzare uno strumento che ci permetti di visualizzare dei dati georeferenziati in formato shapefile. A questo scopo utilizziamo il toolkit GeoTools che possiamo scaricare dal sito Sourceforge:

http://sourceforge.net/projects/geotools/files/

scegliamo l’ultima release e la versione già compilata (geotools-version-milestone-bin.zip), la quale include una serie di librerie .jar. In alternativa è possibile scaricarne i sorgenti e compilarli utilizzando Maven.

Creiamo a questo punto un Progetto Java all’interno del nostro Editor Eclipse, cliccando su File -> New -> Java Project. Il pacchetto che abbiamo scaricato contiene una pletora di librerie, per il nostro esempio possiamo includere solo quelle qui di seguito elencate:

• commons-pool-1.5.4.jar;
• geoapi-2.3-M1.jar;
• geoapi-pending-2.1-M1.jar;
• gt-api-version-milestone.jar;
• gt-coverage-version-milestone.jar;
• gt-data-version-milestone.jar;
• gt-epsg-extension-version-milestone.jar;
• gt-grid-version-milestone.jar;
• gt-main-version-milestone.jar;
• gt-metadata-version-milestone.jar;
• gt-referencing-version-milestone.jar;
• gt-render-version-milestone.jar;
• gt-shapefile-version-milestone.jar: questa è la libreria che ci consente di leggere i file che compongono lo shapefile;
• gt-shapefile-renderer–version-milestone.jar;
• gt-swing-version-milestone.jar;
• jdom-1.0.jar;
• jsr-275-1.0-beta-2.jar;
• jts-1.11.jar;
• miglayout-3.7-swing.jar.
• vecmath-1.3.2.jar.

Una volta copiati questi jar in una cartella del nostro progetto (ad esempio lib), dobbiamo aggiungerli al Build Path.

Possiamo ora provare il toolkit utilizzando questo semplice codice:

Lanciamo il nostro progetto e ci verrà presentato a video un pannello attraverso cui scegliere dal nostro FileSystem il file .shp:

Carichiamo il nostro file .shp

in questo esempio sto caricando lo shapefile dei comuni italiani del 2010.

Terminata la fase di caricamento e rendering ci verrà mostrato un pannello che visualizza le informazioni geografiche dei comuni italiani con degli strumenti di zoom e di selezione:

La mappa dei comuni italiani con i relativi confini

Utilizzando la quarta icona (procedendo da sinistra)  sulla barra degli strumenti in alto, possiamo ottenere il dettaglio di un particolare punto sulla mappa:

Cliccando sul comune di roma vengono visualizzate alcune informazioni del comune

in particolare vengono visualizzare le coordinate (x,y) del punto in cui si è cliccato.

L’applicazione ha un problema di performance in quanto ad ogni refresh dell’immagine, ad esempio quando viene zoomata, viene riletto lo shapefile dal disco, per evitare ciò possiamo caricarlo in memoria utilizzando un meccanismo di caching implementto dalla classe CachingFeatureSource. Possiamo dunque reimplementare il nostro metodo in questo modo:

Il nostro esempio è funzionante, ma sulla consolle viene visualizzata la seguente avvertenza:

17-dic-2010 16.33.55 org.geotools.factory.FactoryRegistry scanForPlugins

AVVERTENZA: Can’t load a service for category “MathTransformProvider”. Cause is “NoClassDefFoundError: javax/media/jai/WarpAffine”.

Per eliminare tale avvertenza dobbiamo scaricare la libreria Java Advanced Imaging (JAI) dal seguente indirizzo:

https://jai.dev.java.net/binary-builds.html

per i nostri scopi possiamo scegliere quella senza accelerazione nativa (jai-1_1_3-lib.zip), e la aggiungiamo al nostro Build-Path.

A cosa serve questa trasformazione? Ebbene lo sviluppo di applicazioni RIA (Rich Internet Application), attualissimo nel panorama odierno dello sviluppo web oriented, è ormai incentrato sull’utilizzo massivo di JavaScript per la costruzione di interfacce grafiche (GUI) sempre più piacevoli e flessibili e sul paradigma Ajax che permette lo scambio “leggero” (cioè senza ricorrere al refresh del browser) tra Client e Server.

Ed è proprio in questa interazione che entra in gioco JSON, il quale è ormai considerato lo standard de facto (a scapito del prolisso XML) per lo scambio di dati tra Client (JavaScript? e Server (che può utilizzare le tecnologie più disparate (Java, PHP, .NET, etc…).

JSON[1] è un formato di testo completamente indipendente dal linguaggio di programmazione, ma utilizza convenzioni conosciute dai programmatori di linguaggi della famiglia del C, come C, C++, C#, Java, JavaScript, Perl, Python, e molti altri. Questa caratteristica fa di JSON un linguaggio ideale per lo scambio di dati.

JSON è basato su due strutture:

• Un insieme di coppie nome/valore. In diversi linguaggi, questo è realizzato come un oggetto, un record, uno struct, un dizionario, una tabella hash, un elenco di chiavi o un array associativo.
• Un elenco ordinato di valori. Nella maggior parte dei linguaggi questo si realizza con un array, un vettore, un elenco o una sequenza.

In JSON le due strutture assumono queste forme:

Un oggetto è una serie non ordinata di nomi/valori. Un oggetto inizia con { (parentesi graffa sinistra) e finisce con } (parentesi graffa destra). Ogni nome è seguito da : (due punti) e la coppia di nome/valore sono separati dalla , (virgola).

Un array è una raccolta ordinata di valori. Un array comincia con [ (parentesi quadra sinistra) e finisce con ] (parentesi quadra destra). I valori sono separati dalla , (virgola).

Un valore può essere una stringa tra virgolette, o un numero, o vero o falso o nullo, o un oggetto o un array. Queste strutture possono essere annidate.

Una stringa è una raccolta di zero o più caratteri Unicode, tra virgolette; per le sequenze di escape utilizza la barra rovesciata. Un singolo carattere è rappresentato come una stringa di caratteri di lunghezza uno. Una stringa è molto simile ad una stringa C o Java.

Un numero è molto simile ad un numero C o Java, a parte il fatto che i formati ottali e esadecimali non sono utilizzati.

I caratteri di spaziatura possono essere inseriti in mezzo a qualsiasi coppia di token.

Dopo questa panoramica sul linguaggio JSON, vediamo come poter “tradurre” dei dati in formato Java (Stringhe, array, oggetti, etc…) in formato JSON, e viceversa, utilizzando la libreria Json-lib, che permette di ottenere questa trasformazione automaticamente ed in maniera molto semplice.

Scarichiamo la libreria dal sito: http://sourceforge.net/projects/json-lib/files/json-lib/

Inoltre dobbiamo scaricare le relative librerie da cui dipende, che sono:

• jakarta commons-lang
• jakarta commons-beanutils
• jakarta commons-collections
• jakarta commons-logging
• ezmorph
• xom (opzionale)

Ora possiamo creare un progetto nel nostro IDE Eclipse ed importare queste librerie, creiamo un progetto Web Dinamico così potremo vedere anche quale sarà l’output in una ipotetica JSP che gira su di un Application Server (nel nostro caso Tomcat).

Dalla barra dei menu di Eclipse clicchiamo su File -> New -> Project…, nel wizard per il New Project, selezioniamo Web -> Dynamic Web Project:

Clicchiamo su Next si aprirà questo pannello:

Diamo un nome al nostro progetto, scegliamo in Configuration lasciamo Default e clicchiamo su Next fino ad arrivare al tasto Finish (non dobbiamo includere alcuna libreria jar o Runtime particolare).

Includiamo ora nel Build Path le librerie che abbiamo scaricato precedentemente. Per farlo possiamo copiare la libreria direttamente nel folder /WebContent/WEB-INF/lib tramite drag and drop dalla cartella in cui l’abbiamo scaricata, così facendo ritroveremo la libreria sotto Web App Libraries:

Le librerie compariranno sotto il folder Web App Libraries

A questo punto creiamo una classe di Test (TestJson.java) e proviamo il comportamento della libreria:

Otterremo questo output a video:

[true,false,true]
["primo","secondo"]

Coerentemente a quanto previsto dallo standard JSON per array di boolean e di tipo stringa.

Proviamo ora a convertire un oggetto di una nostra classe preesistente in formato JSON. Definiamo un oggetto di tipo OggettoGenerico (o qualsiasi nome di fantasia) con delle proprietà che possono essere variabili di tipo booleano, Stringhe o Array:

Nell’esempio abbiamo istanziato un tipo particolare di nome JSONFunction, il quale rappresenta una funzione JavaScript (ovviamente non rappresentabile direttamente in Java ma presente nel linguaggio JSON, in altre parole possiamo trasferire dal Server al Client delle funzioni JavaScript). Oltre ai tipi standard presenti nel linguaggio Java la libreria ci fornisce dunque altri tipi che sono presenti nel linguaggio JSON e sono:

• JSONFunction
• JSONArray
• JSONObject

Per convertire l’oggetto Java in JSON utilizziamo la funzione fromObject() della classe JSONObject in questo modo:

che produrrà questo output :

{“caratteri”:["a","f"],”func”:function(i){ return this.options[i]; },”funzione”:function(i){ return this.options[i]; },”id”:1,”nome”:”aappuntisoftware”}

dove le coppie sono ordinate alfabeticamente in base al nome della coppia nome/valore (ordine che non ha alcuna ripercussione sulle applicazioni JavaScript che utilizzano l’oggetto, in quanto l’ordine dei dati non conta!).

Vediamo ora come poter utilizzare la libreria all’interno di una JSP:

Otterremo lo stesso output dell’esempio precedente ma in esecuzione su un Application Server (vedremo in un prossimo articolo come utilizzare questi dati).

Riferimenti

[1] Tratto dal sito web di riferimento dello standard: http://json.org

Come formato di scambio dei dati utilizzeremo il protocollo JSON che è supportato nativamente da Ext JS, mentre per Java utilizzeremo la libreria Json-lib che consente di convertire i tipi di dati Java in tipi di dati JavaScript.

La prima cosa da fare è scaricare la libreria .jar e relative dipendenze (si veda questo articolo) di Json-lib a questo indirizzo:

http://sourceforge.net/projects/json-lib/files/json-lib/

Se abbiamo già seguito l’articolo su Ext JS, possiamo saltare la fase seguente di download di Ext JS e configurazione del progetto Eclipse e cominciare da qui.

Altrimenti bisogna ottenere il framework Ext JS (giunta alla versione 4) da questo indirizzo:

http://www.sencha.com/products/extjs/download/ext-js-4/173

Per i nostri esempio utilizzeremo come di consueto l’IDE Eclipse, di conseguenza la prima cosa dare è creare un progetto di tipo Web Dinamico.

Dalla barra dei menu di Eclipse clicchiamo su File -> New -> Project…, nel wizard per il New Project, selezioniamo Web -> Dynamic Web Project:

Clicchiamo su Next si aprirà questo pannello:

Inseriamo in nome del nostro progetto e lasciamo il resto da Default

Diamo un nome al nostro progetto, scegliamo in Configuration lasciamo Default e clicchiamo su Next fino ad arrivare al tasto Finish (non dobbiamo includere alcuna libreria jar o Runtime particolare).

Creiamo una cartella js all’interno di WebContent e vi copiamo i file ext-all.js, ext-all-debug.js e bootstrap.js che sono presenti nel pacchetto ext-4.0.0-gpl.zip che abbiamo scaricato in precedenza.

Copiamo poi la cartella resources all’interno di WebContent, possiamo copiarci anche la cartella locale (che contiene le stringhe per la localizzazione) anche se al momento non la usiamo.

Otteniamo queste cartelle nel notro progetto:

La struttura del nostro progetto

Includiamo ora nel Build Path le librerie che abbiamo scaricato precedentemente. Per farlo possiamo copiare la libreria direttamente nel folder /WebContent/WEB-INF/lib tramite drag and drop dalla cartella in cui l’abbiamo scaricata, così facendo ritroveremo la libreria sotto Web App Libraries:

Le librerie compariranno sotto il folder Web App Libraries

Creiamo ora una pagina HTML5 nel nostro progetto, cliccando col tasto destro sulla cartella WebContent dello stesso e scegliendo poi New -> Other…, nella categoria Web selezioniamo HTML File e clicchiamo Next. Digitiamo ora il nome della pagina e continuiamo con Next, nella prossima schermata, tra i vari template, scegliamo New HTML5 Page.

La pagina viene ora aperta all’interno del nostro editor e mostra il seguente codice:

creiamo al suo interno un pannello di tipo form utilizzando Ext JS, lo popoliamo con due campi ti testo semplici e due pulsanti, uno  di invio del form ed uno che azzeri i campi:

Dettagliamo meglio il codice scritto: come si vede esso è posizionato tutto all’interno della funzione onReady per essere sicuri che tutti gli elementi DOM siano caricati; dopo creiamo un form di tipo Ext.form.panel assegnandogli un titolo con l’attributo title, come posizione il tag html body, utilizzando Ext.getBody(), il padding e le dimensioni.
L’attributo url specifica l’indirizzo a cui verrà inoltrata la richiesta Ajax, nel nostro caso essa sarà diretta alla pagina jsp testAjax.jsp, supponendo che stiamo lavorando su localhost, l’indirizzo completo è il seguente:

http://localhost:8080/nomeprogetto/testAjax.jsp

Posizioniamo all’interno del pannello un layout di tipo vbox, così facendo i campi che aggiungiamo verranno disposti verticalmente occupando tutta la larghezza (attributo stretch).

Inseriamo i due field che saranno di tipo textfield (settando xtype: ‘textfield’) aggiungiamo anche un controllo sulla lunghezza (i dati inseriti devono essere lunghi almeno 5 caratteri e senza caratteri blank).

Infine vi sono i due pulsanti di invio e di reset. Quest’ultimo ha come handler una funzione che resetta tutti i campi nel momento in cui si clicca sul pulsante.

Il pulsante Invia ha invece una funzione handler la quale recupera il form e se è valido (i campi sono corretti) lo invia all’url che abbiamo specificato sopra.

In caso di successo viene recuperata la variabile msg dal risultato ottenuto e stampata a video, altrimenti viene richiamato l’handler failure e viene stampato a video la condizione di errore in base al codice ritornato.

Durante le operazioni di scambio messaggi, viene visualizzato un pannellino di attesa.

La risposta attesa dal form in formato JSON è di questo tipo:

se la richiesta non è stata accettata, altrimenti:

Creiamo ora una pagina jsp che con l’ausilio della libreria Json-lib, possa fornire una risposta JSON in quel formato:

Recuperiamo i parametri nome e cognome dalla request (inviateci dal form) e costruiamo una risposta di tipo JSON utilizzando la classe JSONObject fornita dalla libreria.

Proviamo ora la nostra applicazione dovremmo ottenere il seguente risultato a video:

Clicchiamo sul tasto Invia del form ed il server dovrebbe ritornarci la risposta corretta

Se sostituiamo il valore true con il valore false, nella variabile JSON success(risposta.put(“success”, false);), verrà richiamata la funzione failure dopo il submit e verrà ritornato un codice SERVER_INVALID di conseguenza otterremo questo risultato:

Con la variabile success settata a false, viene ritornato un errore SERVER_INVALID

Il motivo che ci può condurre a questa scelta sono essenzialmente due:

• per maggior flessibilità, possiamo far girare Apache HTTP Server su di una macchina e Apache Tomcat su di un’altra, aggiungendo anche maggior sicurezza ad esempio posizionando il server su cui gira Tomcat dietro ad un firewall accessibile solo da Apche HTTP Server;
• per maggior stabilità, Apache HTTP è notoriamente più stabile e veloce di Tomcat ed inoltre un eventuale crash di Tomcat renderebbe solo le jsp e le Servelt non raggiungibili.

Per poter perseguire i nostri scopi illustreremo due metodi possibili:

1. utilizzando un Reverse Proxy (più lento ma semplice da configurare);
2. utilizzando il connettore jk (più efficiente ma leggermente più laborioso da configurare).

Iniziamo col vedere come impostare un proxy di tipo reverse verso Tomcat, bisogna scegliere quale protocollo utilizzare:  HTTP o AJP; AJP offre migliori performance in quanto è un protocollo binario al contrario di HTTP che è un formato testuale (http://wiki.apache.org/tomcat/FAQ/Connectors#Q2), HTTP potrebbe però essere l’unica scelta se i due Server (Apache e Tomcat) comunicano attraverso un Firewall per questioni di sicurezza come abbiamo spiegato in precedenza. Detto ciò forniremo un esempio per ognuno dei due casi. Un altro limite di AJP è che il formato dei pacchetti scambiati non può superare la dimensione di 8 KB.

Supponiamo di voler usare un proxy di tipo http, bisogna innanzitutto caricare i moduli mod_proxy.so e mod_proxy_http.so che sono già inclusi nella cartella modules di Apache:

poi dobbiamo  inserire questa direttiva all’interno del file http.conf di Apache:

nel nostro esempio sia Apche che Tomcat si trovano sulla stessa macchina (di conseguenza possiamo usare localhost invece dell’ip della macchina) e Tomcat è in ascolto sulla porta 8080 (la porta di default), mentre supponiamo che Apache giri su porta 80. La porzione di url /esempi/  contenuta in Location indica che le nostre richieste per l’url http://localhost/esempi/vengano girate al context path examples che si trova nella cartella webapps (cartella di deploy di default di Tomcat) .

Se vogliamo usare il protocollo AJP dobbiamo includere questi moduli:

e cambiare la direttiva in questo modo:

le modalità di redirecting restano le stesse.

Vediamo ora come usare il connettore mod_jk, che è l’evoluzione recente del precedente mod_jserv. I vantaggi rispetto ai moduli proxy sono una migliorata gestione del load balancing, del controllo degli errori ed un supporto per pacchetti AJP più grandi di 8 KB, di contro il modulo non è integrato nella distribuzione di Apache HTTP Server e potrebbe essere necessario effettuarne il build (compilazione) per uno specifico S.O. se esso non è disponibile.

Dunque per provare questo modulo bisogna scaricarlo dal sito Apache, lo facciamo andando a questa url e scegliendo quello giusto per il nostro Sistema Operativo:

http://www.apache.org/dist/tomcat/tomcat-connectors/jk/binaries/

la versione che uso in questo articolo è la 1.2.31 del Novembre 2010 (versione Windows a 32 bit).

Scaricato il modulo lo rinominiamo mod_jk.so e lo posizioniamo nella cartella modules, a questo punto possiamo includerlo nel nostro file httpd.conf in questo modo:

inseriamo poi questa direttiva

Abbiamo indicato il path del file workers.properties e del file di log, inoltre abbiamo specificato delle opzioni del modulo JK, in particolare con JKMount abbiamo specificato che alla richiesta dell’url /esempi/  questa venga girata da Apache a Tomcat.

Dobbiamo ora creare un file worker.properties e lo posizioniamo nella cartella /conf di Apache:

alcune di queste proprietà sono deprecate e quindi possiamo anche eliminarle (cachesize e cache_timeout). Un worker Tomcat è una istanza di Tomcat che è in attesa per eseguire una Servlet o una pagina JSP, per cui abbiamo Apache HTTP Server che invia tramite forward una Servlet o una JSP ad un processo Tomcat (il worker dunque). Tramite il file di properties abbiamo specificato alcune proprietà del worker (lo abbiamo chiamato worker1), possiamo definirne degli altri semplicemente aggiungendo una lista separata da virgole dopo la entryworker.list (ad esempio worker.list= worker1, worker2, etc…). La proprietà type è l’unica obbligatoria e definisce il protocollo utilizzato (AJP versione 1.3) mentre host sarà l’indirizzo di Tomcat (nel nostro caso gira sulla stessa macchina di Apache) e port 8009 è la porta di default del protocollo AJP13. La lista completa di proprietà è a questo indirizzo :http://tomcat.apache.org/connectors-doc/reference/workers.html.

La lista completa dei sotto progetti include:

• Core: un’implementazione delle specifiche e dei componenti JSF 1.1, JSF 1.2, JSF 2.0 e JSF 2.1 come specificato dalle JSR 127, JSR 252 and JSR 314 rispettivamente;
• Portlet Bridge: un’implementazione delle specifiche JSF Portlet Bridge come specificato dalla JSR 301;
• Tomahawk: un set di componenti JSF components creati dal team di sviluppo MyFaces prima che passasse sotto l’egida Apache;
• Trinidad: un set di componenti JSF donati a MyFaces da Oracle, prima conosciuti come ADF Faces;
• Tobago: un set di componenti JSF sviluppati per MyFaces da Atanion GmbH;
• Orchestra: un framework utilizzato per gestire la persistenza delle sessioni attraverso scope diversi;
• Extensions Validator: un framework per la validazione JSF centrica, basato sulle annotazioni;
• Others: sotto progetti più piccoli quali ad esempio MyFaces Commons e MyFaces Shared.

Come si può notare esiste un componente Core per ogni specifica versione di JSF, dalla 1.1 alla 2.1 che è la versione più recente disponibile e che andremo ad usare nei nostri esempi. La versione JSF 2.1 richiede come requisito la JVM 1.5 o successiva, e le implementazioni JSP 2.1, JSTL 1.2 e Java Servlet 2.5.

Il componente Core si divide poi in due sottomoduli:

• MyFaces API: implementa tutte le classi che sono definite nella spefica JSF;
• MyFaces Impl: fornisce classi di supporto (invisibili) che il codice di uno sviluppatore non invoca direttamente, ma che sono necessarie per il funzionamento del framework. Ad esempio le classi di rendering per i componenti JSF.

Iniziamo andando a  scaricare le librerie Core, che troviamo a questo indirizzo:

http://myfaces.apache.org/download.html

la versione più recente al momento in cui scriviamo è la 2.1.1.

Nella stessa pagina in basso troviamo i link ai download per gli altri sotto progetti, in particolare se andiamo sul link di MyFaces Tomahawk (http://myfaces.apache.org/tomahawk/download.html) possiamo recuperare un file .war di esempi che ci permettono di visionare tutti i componenti a disposizione.

Vediamo ora come creare un esempio funzionante utilizzando l’IDE Eclipse.

Dalla barra dei menu di Eclipse clicchiamo su File -> New -> Project…, nel wizard per il New Project, selezioniamo Web -> Dynamic Web Project:

Creiamo un nuovo Progetto Web Dinamico

Clicchiamo su Next si aprirà questo pannello:

Inseriamo il nome del Progetto (TestMyFaces), il runtime Target (abbiamo scelto Tomcat v7.0) e per Configuration selezioniamo dalla tendina il valore JavaServer Faces v2.0.

Clicchiamo su Next finchè non arriviamo alla finestra JSF Capabilities:

Elenco delle librerie JSF presenti in Eclipse

Dobbiamo ora includere le librerie Core e Impl di MyFaces, lo facciamo cliccando su Manage Libraries:

clicchiamo su Manage libraries…

Clicchiamo poi su New… e come User Library Name inseriamo MyFaces-2.1.1:

Indichiamo il path delle nostre librerie MyFaces

Ora possiamo includere la libreria MyFaces ed infine clicchiamo su Finish:

Spuntiamo la casella di MyFaces-2.1.1

Dobbiamo ora includere le librerie prerequisito di MyFaces Core che sono:

• commons-beanutils-1.8.3.jar;
• commons-codec-1.3.jar;
• commons-collections-3.2.jar;
• commons-digester-1.8.jar;
• commons-logging-1.1.1.jar.

queste librerie le troviamo all’interno del pacchetto zip o tar.gz che contiene le librerie Core.

Abbiamo inoltre bisogno delle librerie da cui dipende MyFaces Tomahawk, che troviamo nel pacchetto zip o tar.gz che contiene gli esempi (http://myfaces.apache.org/tomahawk/download.html)):

• batik-awt-util-1.6-1.jar;
• batik-ext-1.6-1.jar;
• batik-gui-util-1.6-1.jar;
• batik-util-1.6-1.jar;
• commons-el-1.0.jar;
• commons-fileupload-1.2.1.jar;
• commons-io-1.3.2.jar;
• commons-lang-2.4.jar;
• commons-validator-1.3.1.jar;
• jstl-1.2.jar;
• oro-2.0.8.jar;
• standard-1.1.2.jar;
• tomahawk-1.1.10.jar;
• xml-apis-1.0.b2.jar;
• xmlParserAPIs-2.0.2.jar.

Tutte queste librerie le inseriamo nella cartella WEB-INF/lib come mostrato in figura:

Inseriamo le librerie nella cartella WebContent/WEB-INF/lib

inserendole in quella cartella, le librerie saranno caricate automaticamente all’interno del Build Path del progetto, sotto la voce Web App libraries:

Ritroviamo le librerie sotto la voce Web App libraries

Dobbiamo ora configurare la Web Application andando a modificare il file web.xml. Lo apriamo in Eclipse e lo rendiamo uguale al seguente:

Il parametro fondamentale da definire è il nome del Filtro extensionFilter mappato sulla classe org.apache.myfaces.webapp.filter.ExtensionsFilter è questa il cuore del framework che intercetta le chiamate durante il ciclo di vita della JSF. All’interno del web.xml  possono essere specificate dei parametri iniziali che sono definiti nella classe MyFacesConfig, tali parametri possono essere omessi e di conseguenza vengono settati al valore di default.

Creiamo ora una pagina di index della nostra applicazione che non farà altro che un redirect verso una pagina JSF (in formato xhtml):

Creiamo ora una pagina JSP, facendo click col tasto destro su WebContent -> New -> Other -> Web -> JSP File, inseriamo un nome ad esempio MyFacesPage ed infine scegliamo il template come mostrato in figura:

Scegliamo dai template disponibili quello JSF con sintassi xhtml e default view setup

Inseriamo il namespace dei tag Tomahawk (xmlns:t=”http://myfaces.apache.org/tomahawk”), e proviamo alcuni tag Tomahawk come ad esempio le label (t:outputLabel), gli input (t:inputText) ed un componente avanzato quale un Captcha (t:captcha):

Ora dobbiamo definire un Bean Java che mappi e conservi i valori degli attributi value dei componenti JSF ed implementi la action invocata dal commandButton, per fare questo basta creare una classe Java nella cartella src del nostro progetto ed inserire questo codice:

Infine bisogna inserire nel faces-config.xml il Bean che abbiamo creato in questo modo esso sarà istanziato automaticamente a runtime dal VariableResolver (ritorna un oggetto e lo crea se questo è referenziato per la prima volta), inoltre dobbiamo specificare lo scope del Bean che nel nostro caso sarà di tipo request:

A questo punto la nostra applicazione è completa, non ci resta che lanciarla sul nostro Application Server Tomcat e provarla. Se inseriamo il corretto valore del Captcha che ci viene presentato allora riceviamo come risposta il valore Corretto!, in caso contrario otteniamo il risultato Sbagliato:

La nostra applicazione di esempio

Questa manipolazione del codice è ottenuta durante la fase di caricamento della classe oggetto di modifica (load time) grazie ad un Class Loader fornito con la libreria.

Javassist può essere utile nei seguenti casi:

• per compilare a runtime delle porzioni di codice sorgente, ad esempio fornito come input di un programma;
• per l’Aspect Oriented Programming (AOP), introducendo dei nuovi metodi in una classe e per inserire advice di tipo before/after/around;
• per la runtime reflection, introducendo un meta-oggetto che controlli le chiamate ai metodi.

Il bytecode Java è conservato in un file binario chiamato class file (e con estensione .class), ogni class file contiene esattamente una classe Java o una interfaccia. La classeJavassist.CtClass (abbreviazione di Compile Time Class) è una rappresentazione astratta di un class file. Un oggetto di tale classe ci permette di manipolare un class file. Per poter ottenere un oggetto CtClass dobbiamo prima istanziare un oggetto ClassPool che rappresenta appunto un contenitore di oggetti CtClass, tramite il metodo get() di ClassPool possiamo ottenere un riferimento ad un oggetto CtClass e assegnarlo ad una variabile per poterlo modificare, facciamo un esempio:

con questo codice otteniamo dal ClassPool un riferimento al class file “it.aapuntisoftware.Rettangolo”, lo modifichiamo assegnandogli come superclasse la classe “it.appuntisoftware.Punto” e lo salviamo di nuovo su file.

Il metodo statico ClassPool.getDefault() fa in modo che il ClassPool cerchi le classi nel medesimo classpath che ha la JVM, di conseguenza per le Web Application tale metodo non va utilizzato, ma bensì va fatta la chiamata al metodo insertClassPath():

questo statement registra come classpath quello che è stato usato per il loading dell’oggetto a cui la keyword this si riferisce.

Possiamo anche creare delle classi ex-novo utilizzando il metodo makeClass() di ClassPool:

utilizzando poi il metodo writeFile() scriviamo la classe su file, non possiamo però modificare classi di cui già abbiamo fatto la write a meno di non chiamare il metodo defrost():

Proviamo ora a fare qualche esempio più complesso e completo. Iniziamo scaricando la libreria dall’URL (la versione più recente che usiamo nel nostro articolo è la 3.11.0 GA):

http://www.jboss.org/javassist/downloads

Per i nostri esempi utilizziamo Eclipse: creiamo un nuovo Progetto Java (File -> New -> Java Project), creiamo una cartella lib e vi copiamo la libreria javassist.jar, non dimentichiamoci poi di includerla nel Build Path del nostro progetto: click col tasto destro -> Build Path -> Configure Build Path):

Aggiungiamo la libreria javassist al Build Path del progetto

 

Creiamo poi le seguenti classi all’interno del package it.appuntisoftware:

Somma.java

1	package it.appuntisoftware;

2	public class Somma {

3	public int aggiungi(int i) {

4	int result = i + 1;

5	System.out.println("Classe: " +this.getClass());

6	System.out.println("Sottoclasse di: " +this.getClass().getSuperclass());

7	System.out.println("Risultato: " + result);

8	return result;

9

}

10

}

Moltiplicazione.java

1	package it.appuntisoftware;

2	public class Moltiplicazione {

3	public int moltiplica(int i) {

4	int result = i * 2;

5	System.out.println("Classe: " +this.getClass());

6	System.out.println("Sottoclasse di: " +this.getClass().getSuperclass());

7	System.out.println("Risultato: " + result);

8	return result;

9

}

10

}

TestJavassist.java

1	package it.appuntisoftware;

2

3	import java.lang.reflect.Method;

4	import javassist.ClassPool;

5	import javassist.CtClass;

6	import javassist.CtMethod;

7	import javassist.CtNewMethod;

8	public class TestJavassist {

9	public static void main(String[] args) throws Exception {

10	ClassPool pool = ClassPool.getDefault();

11	CtClass sum = pool.get("it.appuntisoftware.Somma");

12	CtClass mol = pool.get("it.appuntisoftware.Moltiplicazione");

13	CtClass oper = pool.makeClass("it.appuntisoftware.Operazioni");

14	CtMethod sMetodo = sum.getDeclaredMethod("aggiungi");

15	CtMethod oMetodo = CtNewMethod.copy(sMetodo, "aggiungiUno", oper,null);

16	oper.addMethod(oMetodo);

17	oper.setSuperclass(mol);

18	oper.writeFile();   // scrivo il file su File System

19	System.out.println("Ho scritto il file Operazioni!");

20	Class<?> operClass =oper.toClass();

21	Object operObject =operClass.newInstance();

22	Method methods=operClass.getMethod("aggiungiUno",new Class[]{Integer.TYPE} );

23	methods.invoke(operObject, 2);

24	methods=operClass.getMethod("moltiplica",new Class[]{Integer.TYPE} );

25	methods.invoke(operObject, 2);

26

}

27

28

}

L’output del programma sarà:

Ho scritto il file Operazioni!
Classe: class it.appuntisoftware.Operazioni
Sottoclasse di: class it.appuntisoftware.Moltiplicazione
Risultato: 3
Classe: class it.appuntisoftware.Operazioni
Sottoclasse di: class it.appuntisoftware.Moltiplicazione
Risultato: 4

Nel nostro programma TestJavassist.java abbiamo utilizzato solo le classi fornite da Javassist e quelle già disponibili per la Reflection in Java. Abbiamo creato a runtime una classe Operazioni a cui abbiamo aggiunto un metodo preso dalla classe Somma (aggiungi) e ridenominato aggiungiUno, poi l’abbiamo fatta estendere dalla classe Moltiplicazione (di conseguenza ha ereditato il metodo moltiplica. Dopo fatto ciò abbiamo scritto il class file su FileSystem, ritroviamo il file nella cartella del nostro progetto Eclipse.

A questo punto abbiamo invocato i due metodi della classe Operazioni utilizzando la Reflection tramite le API del package Reflect di Java.

Utilizzando un decompilatore,ad esempio Java Decompiler che abbiamo esaminato in questoarticolo, possiamo vedere il codice generato per la classe Operazioni:

1	package it.appuntisoftware;

2

3	import java.io.PrintStream;

4	public class Operazioni extends Moltiplicazione

5

{

6	public int aggiungiUno(int i)

7

{

8	int result = i + 1;

9	System.out.println("Classe: " + getClass());

10	System.out.println("Sottoclasse di: " + getClass().getSuperclass());

11	System.out.println("Risultato: " + result);

12	return result;

13

}

14

}

oppure possiamo utilizzare il comando javap (incluso nella distribuzione Java) che disassembla il bytecode e ci mostra la struttura della classe e le firme dei metodi e dei costruttori (solo quelli con modificatore di accesso public, protected o package), ad esempio dando il comando:

javap it.appuntisoftware.Operazioni

otteniamo questo output:

Output del comando javap

Le versioni in cui è distribuito DB2 attualmente sono:

• DB2 Enterprise Server Edition: include librerie capaci di gestire i carichi di lavoro più esigenti;
• DB2 Workgroup Server Edition: ideale per le piccole e medie aziende;
• DB2 Express: è il livello base di RDBMS ed è l’ideale per il piccolo mercato;
• DB2 Express-C: è la versione gratuita dell’IBM, l’ideale per piccole aziende, compagnie multi-branch, sviluppatori.

Il concetto fondamentale su cui si sviluppa un database DB2 è quello di istanza (instance, chiamata anche database manager), la quale è un ambiente logico dove sono organizzati e configurati i diversi database. E’ possibile creare e mantenere attive più istanze su di un server fisico in modo da avere un ambiente configurato diversamente per ognuna di esse. L’utilizzo di istanze multiple è ad esempio utile in questi casi:

• utilizzare un’istanza per l’ambiente di sviluppo e di un’altra istanza per quello di produzione;
• effettuare il tuning di un’istanza per un particolare ambiente di lavoro;
• limitare l’accesso ad una particolare istanza;
• ottimizzare il database manager per ogni particolare istanza;
• limitare l’impatto di una failure di un’istanza su di un’altra.

Di contro istanze multiple richiedono maggiori risorse di sistema (in particolare di occupazione su disco e memoria virtuale) ed il dover gestire più configurazioni.

Organizzazione di un database Db2

La directory dell’istanza (instance directory) contiene tutte le informazioni riguardanti i database presenti in essa. La locazione della directory non può essere cambiata una volta che è stata creata, essa contiene:

• i file di configurazione del database manager;
• le directory dei database;
• il directory del nodo;
• la configurazione del nodo (db2nodes.cfg che definisce le partizioni dei database e l’IP del server per le comunicazioni tra le varie partizioni).

Questa directory si trova per sistemi Linux / Unix al percorso INSTHOME/sqllib, dove INSTHOME è la directory home del proprietario dell’istanza (l’utente db2inst1 di default), per Windows si trova al path /sqllib nella directory dove è stato installato DB2.

Dopo questa breve introduzione, vediamo come installare e configurare un DBMS DB2.

Per le nostre prove utilizzeremo la versione Express-C v9.7 (l’ultima disponibile nel momento in cui scriviamo) che è possibile scaricare gratuitamente dall’url:

http://www-01.ibm.com/software/data/db2/express/download.html

qui possiamo scegliere tra le varie Piattaforme (Windows, Linux, Solaris e Mac) sia a 32 che a 64 bit. La versione Express-C gira su qualsiasi tipo di hardware, ma si limita ad usare un massimo di due Core (indipendentemente dal numero di processori installati) ed un massimo di 2 GB di ram, sottoscrivendo una particolare licenza denominata Fixed Term License o FTL si potranno utilizzare 4 Core e fino a 4 GB di ram.

E’ inoltre possibile scaricare un libro-guida Getting Started with DB2 Express-C (disponibile in varie lingue, la versione 9.5 anche in italiano) all’indirizzo:

http://www.ibm.com/developerworks/wikis/display/DB2/FREE+Book-+Getting+Started+with+DB2+Express-C

Per installare il database basta lanciare il programma setup.exe per Windows oppure dando il comando ./db2setup per Linux e Unix. Completata l’installazione ritroveremo i file DB2 sotto le directory C:\Programmi\IBM\SQLLIB\BIN\ per Windows e /opt/ibm/db2/V9.7 per Linux e /opt/IBM/db2/V9.1 per Unix.

Durante il processo di installazione verranno creati 3 nuovi utenti e 3 nuovi gruppi in ambiente Linux:

• l’utente proprietario delll’istanza DB2 (owner), denominato db2inst1 (la quale viene creata nella sua home directory nella cartella sqllib), questi controlla tutti i processi db2 ed è il proprietario di tutti i file ed i device usati dai database contenuti nella istanza, ci sono tanti utenti owner quante le istanze installate (il nome di questi saranno progressivi: db2inst2, db2inst3, etc…). Il suo gruppo di default è db2iadm1;
• l’utente fenced (letteralmente recintato), denominato db2fenc1, questi è utilizzato per eseguire le funzioni definite dall’utente (le cosiddette user defined functions, UDF) e le stored procedure al di fuori dello spazio di indirizzamento usato da un database db2. Il gruppo di default è db2fadm1;
• l’utente amministratore del db2, denominato dasusr1, questi è utilizzato per le operazioni di amministrazione dul server db2, da notare che esiste un solo amministratore e quindi utente per macchina anche se ci sono più istanze. Il gruppo di default è dasadm1.

Possiamo amministrare i nostri database e gestire le varie utilities offerte da DB2 utilizzando una comoda GUI offerta dal DB2 Control Center. Per poter accedere a questo tool in Windows basta cliccare sull’icona Centro di Controllo presente al percorso Tutti i Programmi -> IBM DB2 -> DB2COPY -> Strumenti di gestione generale, in Linux dobbiamo essere loggati o con l’utente amministratore dasusr1 o l’utente owner db2inst1 ed aver avviato il server X, dopodichè avviamo una sessione di terminale e diamo il comando db2cc:

La schermata principale del Control Center

Possiamo anche operare in modalità totalmente testuale utilizzando la  DB2 Command Line Processor CLP dalla quale possiamo dare i nostri comandi DB2 ed istruzioni SQL. In Windows la lanciamo andando in Tutti i Programmi -> IBM DB2 -> DB2COPY -> Strumenti riga di comando e clicchiamo su CLP (la quale lancia il comando db2cmd.exe), in Linux una volta collegati con l’utente dasusr1 o db2inst1, diamo il comando db2, apparirà questa schermata:

La CLP in ambiente Windows

Creiamo ad esempio un database con il seguente comando SQL:

create database esempio

il sistema risponderà con un messaggio di successo, ricordiamo che per DB2 i nomi di database possono al massimo essere lunghi 8 caratteri.

Prima di poter eseguire un’istruzione SQL sul database appena creato, dobbiamo collegarci ad esso:

Per collegarci a un database scriviamo il comando:

db2 CONNECT TO database USER userID USING password

Per collegarci a un database in modo che DB2 ci richieda una password, scriviamo il comando:

db2 CONNECT TO database USER userID

Per collegarci a un database usando l’ID dell’utente predefinito, scriviamo il comando:

db2 CONNECT TO database

Di seguito elenchiamo alcuni comandi utili per recuperare delle informazioni e per configurare la istanza Db2 appena installata.

Per avere un elenco dei parametri su cui è configurata la istanza DB2 (database manager)  apriamo un terminale DB2 (dando il comando db2 da consolle) e diamo il comando:

get database manager configuration

oppure possiamo usare la forma abbreviata:

get dbm cfg

se invece vogliamo sapere i parametri di configurazione del singolo database, dobbiamo prima connetterci a questo (col comando connect to nomedatabase) e poi dare il comando:

get database configuration

oppure possiamo usare la forma abbreviata:

get db cfg

il comando per modificare una entry della configurazione è il seguente:

update database manager configuration  using <parameter-name> <parameter-value>

oppure

update dbm cfg using <parameter-name> <parameter-value>

e per i database:

update database configuration (oppure update dbm cfg) using <parameter-name> <parameter-value>

oppure

update db cfg using <parameter-name> <parameter-value>

Per conoscere il numero di  porta di connessione DB2 su Linux/unix:

1. Aprire un terminale DB2 e verificare che si è sulla istanza corretta dando il comando:

   get instance

2. dare il seguente comando per verificare il nome del servizio della nostra istanza:

get dbm cfg | grep SVCE

1. verrà generato un output del tipo:

TCP/IP Service name          (SVCENAME) = db2cdb2inst24

1. digitare sulla console linux il comando:

   grep service_name /etc/services

   ci saranno le informazioni riguardanti la porta del servizio, ad esempio:

   service_name   50012/tcp   # Connection port for DB2 instance instance

Per conoscere il nome delle istanze DB2 presenti sul sistema dare il comando:

db2ilist

di default avremo il nome DB2 per sistemi Windows e db2inst1 per Linux/Unix.

Per stoppare il DB2 se il comando db2stop non funziona e ritorna come errore:

SQL1025N  The database manager was not stopped because databases are still active.

Utilizziamo :

db2 force application all

db2stop force

dove force application <command> disconnette tutti gli utenti remoti e locali per permettere la manutenzione del server.

Per visualizzare tutte le applicazioni e gli utenti connessi al DB possiamo utilizzare il comando:

db2 list applications (è valido anche usando application)

Per conoscere la versione di DB2 che abbiamo installato e la licenza registrata diamo il comando:

db2licm -l

dove il parametro -l sta ad indicare di visualizzare i dettagli dell’installazione.

Per conoscere invece quali fix packs sono stati installati diamo il comando:

db2level

tra le informazioni visualizzate possiamo anche sapere se è una versione a 32 bit o a 64.

Per configurare la manutenzione automatica del DB2 (automatic maintenance) è possibile agire dal relativo menù cliccando col tasto desto sul database da manutenere e scegliendo l’opzioneConfigura manutenzione Automatica… in alternativa è possibile farlo da linea di comando.

Per conoscere tutte gli schemi o le tabelle presenti in un determinato database,  bisogna interrogare rispettivamente la tabella SYSTABLES e SYSSCHEMATA presenti nello schema SYSIBM, o in alternativa interrogare le viste SCHEMATA e TABLES presenti nello schema SYSCAT, dunque per conoscere gli schema utilizziamo la seguente query SQL:

select * from sysibm.sysschemata

oppure

select * from syscat.schemata

mentre per conoscere tutte le tabelle:

select * from sysibm.systables

oppure

select * from syscat.tables

E’ possibile inoltre scaricarne una versione stand-alone (cioè che funziona senza dover sviluppare codice che la utilizzi), che permette di effettuare una serie di operazioni agendo direttamente da linea di comando.

Vediamo ora come è strutturato Apache PDFBox, dopo di che faremo degli esempi pratici in Java.

I documenti PDF sono degli stream di oggetti di tipo base, questi oggetti di basso livello sono rappresentati in PDFBox nel package org.apache.pdfbox.cos package. Gli oggetti base in PDF sono:

Il modello basato su oggetti COS permette di accedere a qualsiasi elemento del documento PDF, ma per accedervi l’utente deve conoscere il nome dei parametri che vuole usare e ciò porta ad inevitabili errori. Di conseguenza è stato creato un altro Modello (PD Model) che offre delle agevolazioni per il programmatore. Ogni oggetto del documento ha un set di attributi definiti che possono essere disponibili nel dizionario. La libreria fornisce una classe PD Model per ogni tipo di oggetto del documento le quali forniscono dei metodi fortemente tipizzati che permetto di accedere agli attributi definiti. Di conseguenza il PD Model è collocabile al di sopra del COS Model come mostrato in figura:

Struttura del COS Model e del PD Model

Ovviamente nei nostri esempi faremo sempre uso delle classi del PD Model.

A questo punto scarichiamo la libreria all’indirizzo:

http://pdfbox.apache.org/download.html

scegliendo il file .jar pdfbox-version.jar (la 1.5.0 nel momento in cui scriviamo), dobbiamo inoltre scaricare sempre dalla stessa pagina il file di dipendenza .jsr fontbox-version.jar (è un componente stand-alone che permette di manipolare i formati dei font).

Una ulteriore dipendenza da soddisfare è la libreria commons-logging che possiamo scaricare da questa url:

http://apache.panu.it//commons/logging/binaries/commons-logging-1.1.1-bin.zip

Utilizzeremo per i nostri esempi Java l’IDE Eclipse.

Creiamo un nuovo Progetto Java in Eclipse (File -> New -> Java Project), creiamo una cartella lib e vi copiamo le libreria pdfbox-1.5.0.jar, fontbox-1.5.0.jar e commons-logging-1.1.1.jar, per cui avremo il nostro progetto così strutturato:

La struttura del nostro Progetto Java

Dobbiamo poi includerle nel Build Path del nostro progetto: click col tasto destro sul progetto -> Build Path -> Configure Build Path):

• pdfbox-1.5.0.jar;
• fontbox-1.5.0.jar;
• commons-logging-1.1.1.jar.

Il Java Build Path del progetto

Creiamo ora una classe Java per poter provare la libreria (tasto destro sulla cartella src -> New -> Class), ed indichiamo il nome, il package e la JVM da utilizzare come riportato in figura:

Creiamo la nostra classe Java di esempio

Aggiungiamo del codice per creare una pagina PDF con un testo in una certa posizione della pagina:

Con il codice precedente viene creato un file pdf dal nome output.pdf che viene salvato nella directory root del nostro progetto, all’interno del quale viene scritta la Stringa che abbiamo passato all’oggetto PDPageContentStream. Come vediamo la prima cosa da fare è creare un documento PDF (istanza di PDDocument) e poi aggiungervi una pagina (istanza di PDPage) con il metodo addPage().

A questo punto istanziamo uno stream a cui passiamo come argomento il documento e la pagina su cui agire. Abbiamo inoltre settato un font (Helvetica_Bold) col metodo setFont (prima lo abbiamo definito utilizzando un campo statico della classe PDType1Font). Con il metodo moveTextPositionByAmount( x , y) posizioniamo il cursore da cui iniziare a scrivere, è importante notare che nei documenti PDF la posizione (0 , 0 ) rappresenta l’angolo in basso a sinistra. Dopo aver chiuso lo stream possiamo procedere al salvataggio con il metodo save(nomefile).

Scriviamo un’altra classe in cui andiamo ad aprire un file pdf già esistente, lo modifichiamo e lo scriviamo su di un altro file:

Le differenze con il precedente esempio sono l’utilizzo di PDDocument.load(nomefile) con il quale carichiamo in memoria il file  e con doc.getDocumentCatalog().getAllPages().get(indexpagina) recuperiamo la lista di tutte le pagine e ci posizioniamo sulla prima.

La versione che prendiamo in esame in questo articolo è la 1.1.1 (la più recente nel momento in cui scriviamo) nella quale è stato aggiunto il supporto alla Virtual Machine Dalvik (la VM di Android).

Per scaricarla possiamo farlo da questa URL:

http://www.jdom.org/dist/binary/

Iniziamo a vedere le classi basilari di questa libreria: l’istanza della classe org.jdom.Document è quella che rappresenterà il nostro documento XML una volta che sarà parserizzato. La prima cosa da notare è che tale classe non ha niente a che vedere con l’analogo Document del modello DOM (che in Java è implementato nelle API JAXP consultabili a questo indirizzo: http://download.oracle.com/javase/6/docs/technotes/guides/xml/index.html), nè tanto meno le altre classi di JDOM che hanno un nome analogo (tra cui la classe Element oAttribute). Esse sono solo delle classi con le quali possiamo rappresentare una particolare “caratteristica” del nostro file XML, come ad esempio un Nodo, un Attributo, ecc…

Ritorniamo ora al nostro Document, il quale per essere istanziato ed associato ad un file XML ha bisogno dell’ausilio di un parser XML. Per istanziare ed utilizzare un Parser utilizziamo le classi Builder che possonoessere di due tipi:

• SAXBuilder;
• DOMBuilder.

come è facile intuire dai  nomi, il SaxBuilder caricherà ed effettuera il parsing di un documento XML utilizzando le API SAX, mentre il DOMBuilder utilizzerà il modello DOM. Entrambi i Builder utilizzano come default il Parser implementato in JAXP, il quale è incluso nella distribuzione Java e di conseguenza non dobbiamo aggiungere altre librerie al nostro progetto.

Il SAXBuilder accetta diversi tipi di formati in input, tramite il metodo overloaded build(), quali ad esempio un InputStream, un InputSource, un File, un URL o semplicemente una Stringa contenente il path del file XML, il DOMBuilder deve invece ricevere in input una istanza del documento XML già parserizzata secondo il modello DOM (un’istanza diorg.w3c.dom.Document). Con il seguente codice istanziamo la classe Document a partire da un file XML parserizzato tramite SAX:

E’ possibile validare il documento XML passando come parametro il valore true al costruttore del SAXBuilder (new SAXBuilder(true)). Se volessimo invece utilizzare un altro Parser quale ad esempio Xerces, allora dobbiamo specificare il nome della classe parser da utilizzare che nel caso di Xerces è org.apache.xerces.parsers.SAXParser e passarla al costruttore del SAXBuilder:

ovviamente dobbiamo includere la libreria xercesImpl.jar (scaricabile dall’indirizzo http://xerces.apache.org/xerces-j/) nel Build Path del progetto.

Ottenuto il Document possiamo navigare all’interno di esso in maniera molto facile utilizzando i metodi forniti dalle API JDOM: ad esempio possiamo ottenere l’elemento (nodo) radice con il seguente metodo:

e su questo elemento andare a visionare i figli (del primo livello) con il metodo:

inoltre possiamo navigare su tutti i discendenti di un nodo utilizzando il seguente metodo:

il metodo getDescendant() ritorna un iteratore il quale ci permette di scorrere tutti i discendenti in ordine. A tale metodo possiamo passare un Filter (ElementFilter) con il quale selezionare solo particolari tipi di Elementi, ad esempio con il seguente codice:

Non specificando alcun valore per ElementFilter verranno selezionati solo i discendenti di tipo Element, se avessimo usato new ElementFilter(“contatto”), allora avremmo selezionato solo i discendenti con come elemento uguale a contatto (cioè con tag <contatto>).

I tipi di nodi che JDOM riconosce e mappa su di una sua classe sono i seguenti:

Le classi Core della libreria JDOM

Faremo ora un esempio concreto di utilizzo utilizzando Eclipse. Come sempre configuriamo un Progetto Java all’interno di Eclipse  cliccando su File -> New -> Java Project:

Nominiamo il nostro progetto TestJdom

poi creiamo una cartella lib e vi copiamo la libreria jdom.jar, non dimentichiamoci poi di includerla nel Build Path del nostro progetto: click col tasto destro -> Build Path -> Configure Build Path):

Includiamo JDOM nel Build Path del progetto

Creiamo una classe Java al suo interno e copiamo il codice seguente, il quale permette di leggere un file XML e di stampare i valori ed il tipo dei Nodi incontrati durante la visita del documento XML.

1	package it.appuntisoftware;

2

3	import java.io.IOException;

4	import java.util.Iterator;

5	import java.util.List;

6	import org.jdom.Attribute;

7	import org.jdom.CDATA;

8	import org.jdom.Comment;

9	import org.jdom.DocType;

10	import org.jdom.Document;

11	import org.jdom.Element;

12	import org.jdom.JDOMException;

13	import org.jdom.Text;

14	import org.jdom.input.SAXBuilder;

15

16	public class ReadXML {

17	public static void main(String args[]){

18	SAXBuilder builder = new SAXBuilder();

19	Document doc;

20

try {

21	doc = builder.build("rubrica.xml");

22	listNodes(doc,0);

23	} catch (IOException e) {

24	e.printStackTrace();

25	} catch (JDOMException e) {

26	e.printStackTrace();

27

}

28

}

29

30	public static void listNodes(Object o, int depth) {

31	stampaSpazi(depth);

32	if (o instanceof Element) {

33	Element element = (Element) o;

34	if(((Element) o).isRootElement())

35	System.out.println("Root Element:"+ ((Element) o).getName());

36

else

37	System.out.println("Element: " + element.getName());

38	//Itera sugli eventuali attributi dell'elemento

39	if(!((Element) o).getAttributes().isEmpty()){

40	Iterator iter =element.getAttributes().iterator();

41	while (iter.hasNext()) {

42	Object attribute = iter.next();

43	listNodes(attribute, depth+1);

44

45

}

46

}

47	//Itera sui figli dell'elemento

48	List children = element.getContent();

49	Iterator iterator = children.iterator();

50	while (iterator.hasNext()) {

51	Object child = iterator.next();

52	listNodes(child, depth+1);

53

}

54

}

55	else if (o instanceof Document) {

56	System.out.println("Document");

57	Document doc = (Document) o;

58	List children = doc.getContent();

59	Iterator iterator = children.iterator();

60	while (iterator.hasNext()) {

61	Object child = iterator.next();

62	listNodes(child, depth+1);

63

}

64

}

65	else if (o instanceof Comment) {

66	System.out.println("Comment:");

67	System.out.println(((Comment) o).getText());

68

}

69	else if (o instanceof CDATA) {

70	System.out.print("Sezione CDATA:");

71	// CDATA è una sottoclasse di Text di conseguenza questo test

72	// va prima di quello per Text.

73	System.out.println(((CDATA) o).getText());

74

}

75	else if (o instanceof Text) {

76	System.out.print("Text:");

77	System.out.println(((Text) o).getValue());

78

}

79	else if (o instanceof Attribute) {

80	System.out.print("Attribute:");

81	System.out.print(((Attribute) o).getQualifiedName());

82	System.out.println(((Attribute) o).getValue());

83

}

84	else if (o instanceof DocType) {

85	System.out.print("DocType:");

86	System.out.print(((DocType) o).getElementName());

87	System.out.println(((DocType) o).getPublicID());

88

}

89

else {

90	System.out.println("Tipo non previsto: " + o.getClass());

91

}

92

}

93	private static void stampaSpazi(int n) {

94	for (int i = 0; i < n; i++) {

95	System.out.print(' ');

96

}

97

}

98

}

Possiamo provare questo programma utilizzando questo file XML, nel quale abbiamo inserito i tipi di Nodi più variegati possibili:

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

2	<!DOCTYPE rubrica [

3	<!ENTITY FS "Fisico">

4

]>

5	<rubrica xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

6	<!-- Rubrica Contatti -->

7	<contatto id="1">

8	<![CDATA[<1° Contatto>]]>

9	<nome>Enrico</nome>

10	<cognome>Fermi</cognome>

11	<professione>&FS;</professione>

12	</contatto>

13	<contatto id="2">

14	<![CDATA[<2° Contatto>]]>

15	<nome>Albert</nome>

16	<cognome>Einstein</cognome>

17	</contatto>

18	<contatto id="3">

19	<![CDATA[<3° Contatto>]]>

20	<nome>Isaac</nome>

21	<cognome>Newton</cognome>

22	</contatto>

23	<contatto id="4">

24	<![CDATA[<4° Contatto>]]>

25	<nome>Johannes</nome>

26	<cognome>Stark</cognome>

27	</contatto>

28	</rubrica>

una volta lanciato il programma vedremo apparire sulla Console in output numerose diciture di tipo Text: con degli spazi vuoti, ciò è dovuto al fatto che il Parser considera come nodo Text anche i simboli di andata a capo ( gli “\n” per farla breve) e li valorizza correttamente come vuoti, per evitare ciò il file XML non dovrebbe avere queste rimandi a capo ma dovrebbe essere un’unica sequenza di tag (poco leggibile se  fosse riportata su questo articolo). Fatta questa precisazione di carattere per lo più estetico ma che non cambia nulla dal punto di vista funzionale, entriamo nel dettaglio dell’esempio: una volta ottenuto il Document dal SAXBuilder, utilizziamo una funzione ricorsiva per scorrere tutti i nodi dell’albero XML. A seconda del nodo incontrato ne stampiamo il tipo ed il valore contenuto.

Nel caso di Nodi di tipo Element, verifichiamo se essi abbiano degli attributi e stampiamo a video sia il loro nome che il valore contenuto. Ogni elemento contatto ha poi un nodo di tipo CDATA che viene correttamente interpretato dalla libreria JDOM, infatti esso contiene dei caratteri quali le virgolette < e > ed il simbolo ° che darebbero errore se inseriti in un tag XML (in CDATA possiamo inserire qualsiasi carattere dato che essi vengono sempre interpretati come sequenze di caratteri).

Un’altra particolarità è data dalla presenza di un valore (&FS; presente nel tag <professione>) collegato ad un tag Entity (Entity Reference) , il quale viene correttamente interpretato e sostituito col valore della Entity (nel nostro caso il valore “Fisico”). Infine vengono correttamente stampati sia i valori dei Comment che del DocType.

Launch4j è un progetto Open Source ospitato sul sito SourceForgehttp://sourceforge.net/projects/launch4j/.

Tipicamente una applicazione Java consiste di una serie di file .class raggruppati per essere distribuiti, in un archivio .jar corredato da un file Manifest che descrive la Main-Classdell’archivio (cioè dove si trova il metodo main della nostra applicazione) ed eventualmente indica se bisogna includere altri file .jar nel classpath (utilizzando la direttiva classpath).

Un esempio di  file Manifest è il seguente:

definito un opportuno Manifest per la nostra applicazione ed incluso nella cartella META-INF, possiamo eseguire l’applicazione con il seguente comando:

java -jar applicazionediesempio.jar

dunque bisogna aprire una console in Windows (Start -> Esegui -> cmd ) e digitare il comando sopra riportato, operazione non sempre banale per un utente medio di Windows.

Infatti non sempre il doppio click sul file .jar riesce a far eseguire l’applicazione in quanto il comando di default associato all’azione di doppio click prevede il solo passaggio del nome del  file .jar al comando javaw.exe, di conseguenza senza il parametro -jar viene visualizzato un errore Java del tipo:

java.lang.NoClassDefFoundError: nomeapplicativo/jar

In nostro aiuto viene Launch4j che permette la creazione di file .exe compatibili con Windows i quali possono includere totalmente il file .jar della nostra applicazione oppure possiamo scegliere di mantenere indipendente il file .jar.

Elenchiamo alcune delle caratteristiche offerte da Launch4j:

• possibilità di richiedere una particolare JRE (ad esempio una versione specifica) per l’esecuzione del nostro applicativo;
• se una JRE non viene rilevata nel sistema dell’utente può essere indicato l’URL dal qual scaricare la JRE, aprendo una scheda del browser in automatico;
• possibilità di includere una JRE nella distribuzione del nostro applicativo;
• possibilità di visualizzare un’icona per il notro .exe;
• possibilità di visualizzare uno Splash screen prima del lancio dell’applicazione e di settarne la durata;
• possibilità di settare delle variabili di ambiente o di modificare i parametri con cui viene lanciata la JVM (ad esempio l’heap size);
• customizzazione dei messaggi di errore.

Le possibili configurazioni offerte da Launch4j

Entriamo ora nei dettagli dell’applicativo, per far ciò bisogna dapprima scaricare ed installare il software Launch4j che possiamo trovare sul sito SourceForge:

http://sourceforge.net/projects/launch4j/files/

l’ultima versione è la 3.0.2 la quale è oggetto di questa prova.

Scaricata la corretta versione per il nostro S.O., lanciamo l’applicativo e dopo lo splash screen ci viene presentata la seguente schermata:

La schermata principale di Launch4j

in questa schermata definiamo le informazioni basilari per la creazione del nostro file .exe. Dobbiamo innanzitutto definire il nome ed il path dove verrà memorizzato del nostro file exe, dopo bisogna indicare il path del file .jar della nostra applicazione che si vuol rendere eseguibile.

La checkbox sottostante (Don’t wrap the jar, launch only) se non flaggata ingloberà il file .jar all’interno dell’exe in questo modo potremo distribuire il solo file .exe.

Se non è presente un file Manifest nel .jar dobbiamo indicarne uno esterno nel campoManifest, mentre nel campo Icon indichiamo il file .ico che sarà l’icona del nostro file .exe.

Il parametro Change dir permette di specificare in quale directory spostarsi prima di eseguire l’applicazione: ciò è importante se l’applicazione fa riferimento a file utilizzando path relativi alla propria directory di esecuzione. Inserendo un punto (.) come valore Launch4j si sposterà nella directory dell’eseguibile prima di eseguire l’applicazione, altrimenti assume come directory di esecuzione quella dove è contenuto l’eseguibile launch4j.exe (tipicamente in C:\Programmi\Launch4j). In Command line args possiamo inserire tutti i parametri che l’applicazione deve ricevere da riga di comando.

Possiamo poi specificare il livello di priorità del processo in Process Priority e se customizzare il nome del processo. Infine se non viene rilevata una JRE compatibile con quella specificata nel tab JRE (che vedremo a breve) possiamo inserire il titolo dell’errore da lanciare (in Error Title) e l’URL da aprire nel browser per poter scaricare quella specifica JRE.

Esaminiamo ora la scheda JRE:

La scheda JRE

In essa possiamo specificare una eventuale JRE da includere nel nostro bundle tramite il campo Bundled JRE Path, nel quale indicheremo il path in cui si trova una JRE che abbiamo scaricato in formato .exe.

Inoltre, anche se non indicato, è obbligatorio specificare una versione minima della JRE richiesta (Min JRE version), mentre è opzionale indicare la massima (Max JRE version).

Possiamo inoltre indicare la dimensione dell’Heap da riservare all’inizio e quella massima sia in termini di MegaByte o in termini percentuali della memoria disponibile (Initial e Max Heap size).

Visualizziamo la scheda Splash:

La scheda Splash

In questa scheda possiamo abilitare la visualizazzione di uno splash screen prima del lancio del nostro applicativo, ne indichiamo il path dell’immagine ed il timeout di durata.

Esaminiamo la scheda Messages:

La scheda Messages

Nella scheda Messagges possiamo specificare e customizzare tutti i messaggi di errore che l’applicativo .exe può lanciare.

Infine vediamo la scheda Single Instance:

La scheda Single Instance

tramite questa scheda è possibile definire una variabile mutex in modo da permettere l’esecuzione di una singola istanza della nostra applicazione.

Una volta configurato il nostro applicativo dobbiamo salvare la configurazione in un file .xml tramite l’icona a forma di dischetto. Dopo aver salvato creiamo l’exe con il tasto a forma di rotellina e lo lanciamo col tasto play.

I file .xml di configurazione dell’applicativo sono di questo tipo: