DBeaver il database manager universale!

Postato da ROb | nella categoria Java, Utilità | mercoledì, 28 settembre 2011

2

Ogni sviluppatore sa quanto è importante avere nella propria cassetta degli attrezzi un valido software di interrogazione e gestione delle base di dati.

Generalmente ogni db vendor propone la sua soluzione specifica, console e grafica, per accedere ai propri db e tabelle. Sono poche le soluzioni open in grado di connettersi e lavorare con successo su diverse piattaforme e che nello stesso tempo siano facilmente utilizzabili.

Dopo anni e anni di ricerca quasi per caso ho trovato DBeaver, il castoro dei database (dal suo nome curioso).
DBeaver è un software sviluppato in Java tramite il framework di sviluppo di Eclipse: RCP.
E’ disponibile per moltissime piattaforme (cosa comune a quasi tutti i software scritti in Java) e segue dei cicli di sviluppo molto regolari tanto che in poco più di un anno dalla sua pubblicazione ha raggiunto una maturità e una lista di funzioni veramente invidiabili.

Attualmente è alla versione 1.4.0, rilasciata pochi giorni fa.

I db vendor attualmente supportati sono molti (tutti? :-D ):

  • MySQL
  • Oracle
  • PostgreSQL
  • IBM DB2
  • Microsoft SQL Server
  • Sybase
  • ODBC
  • Java DB (Derby)
  • Firebird (Interbase)
  • HSQLDB
  • SQLite
  • Mimer
  • H2
  • IBM Informix
  • SAP MAX DB
  • Cache
  • Ingres
  • Linter
  • Any JDBC compliant data source

Nelle sue ultime versioni permette anche di modificare lo schema dei dati (tabelle e altro) e di visualizzare/salvare degli schemi ER delle tabelle selezionate.

Per me è diventato un indispensabile compagno di viaggio e quando posso cerco anche di segnalare eventuali malfunzionamenti o problemi.

Ecco alcuni screenshot presi direttamente dal sito ufficiale.

Provatelo e datemi il nostro parere!

Autenticazione nativa Windows Active Directory in Tomcat

Postato da ROb | nella categoria Java, Sviluppo web | venerdì, 22 luglio 2011

2

Per un interessante progetto a cui sto lavorando, ho avuto la necessità di configurare Tomcat per poter autenticare nativamente i client (con browser IE7 e IE8 e Firefox) attraverso il repository Active Directory di Windows 2003 Server.

Per farlo ci sono a disposizione, come spesso avviene, numerose possibilità.
Dopo averne provate un paio alla fine ho scelto la soluzione proposta dalla libreria spnego.

spnego implementa il protocollo Kerberos/SPNEGO invece del classico NTLM per dialogare con i domain controller e, attraverso un filtro inserito nella nostra web application, ci offre la possibilità di verificare l’identità degli utenti (attraverso la chiamata java request.getRemoteUser() ) già autenticati in Windows dopo un logon positivo nel dominio di Active Directory.

La guida offerta dal sito della libreria per il raggiungimento di tale integrazione è molto ben fatta. Qui sotto in breve voglio riassumere i miei passi, che in larga parte seguono appunto tale guida.

  • creazione di un utente in Active Directory, che sarà utilizzato dal filtro per loggarsi al dominio e verificare le credenziali degli utenti.
  • creazione del file krb5.conf (all’interno della directory di esecuzione di Tomcat, nel mio caso la bin) con tale contenuto:
    [libdefaults]
    	default_realm = <NOME_DOMINIO>
    	default_tkt_enctypes = aes128-cts rc4-hmac des3-cbc-sha1 des-cbc-md5 des-cbc-crc
    	default_tgs_enctypes = aes128-cts rc4-hmac des3-cbc-sha1 des-cbc-md5 des-cbc-crc
    	permitted_enctypes   = aes128-cts rc4-hmac des3-cbc-sha1 des-cbc-md5 des-cbc-crc
    
    [realms]
    	<NOME_DOMINIO>  = {
    		kdc = <DOMAIN_CONTROLLER>
    		default_domain =  <NOME_DOMINIO>
    }
    
    [domain_realm]
    	. <NOME_DOMINIO> =  <NOME_DOMINIO>
    
  • creazione del file login.conf (nella stessa posizione del file krb5.conf) con il seguente contenuto
    spnego-client {
    	com.sun.security.auth.module.Krb5LoginModule required;
    };
    
    spnego-server {
    	com.sun.security.auth.module.Krb5LoginModule required
    	storeKey=true
    	isInitiator=false;
    };
    
  • creazione di una web application (nel mio caso il suo nome è testad) con dentro solamente la directory WEB-INF con dentro una cartella lib con la libreria jar di spnego (nel mio caso l’ultima versione disponibile era la 7, spnego-r7.jar) e il file web.xml con il seguente contenuto (rimpiazzate opportunamente l’utente e la password dell’utente di Active Directory):
    <?xml version="1.0" encoding="ISO-8859-1"?>
    
    <web-app xmlns="http://java.sun.com/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
       version="2.5">
    
      <filter>
        <filter-name>SpnegoHttpFilter</filter-name>
        <filter-class>net.sourceforge.spnego.SpnegoHttpFilter</filter-class>
    
        <init-param>
            <param-name>spnego.allow.basic</param-name>
            <param-value>true</param-value>
        </init-param>
    
        <init-param>
            <param-name>spnego.allow.localhost</param-name>
            <param-value>false</param-value>
        </init-param>
    
        <init-param>
            <param-name>spnego.allow.unsecure.basic</param-name>
            <param-value>true</param-value>
        </init-param>
    
        <init-param>
            <param-name>spnego.login.client.module</param-name>
            <param-value>spnego-client</param-value>
        </init-param>
    
        <init-param>
            <param-name>spnego.krb5.conf</param-name>
            <param-value>krb5.conf</param-value>
        </init-param>
    
        <init-param>
            <param-name>spnego.login.conf</param-name>
            <param-value>login.conf</param-value>
        </init-param>
    
        <init-param>
            <param-name>spnego.preauth.username</param-name>
            <param-value>utentead</param-value>
        </init-param>
    
        <init-param>
            <param-name>spnego.preauth.password</param-name>
            <param-value>password_utentead</param-value>
        </init-param>
    
        <init-param>
            <param-name>spnego.login.server.module</param-name>
            <param-value>spnego-server</param-value>
        </init-param>
    
        <init-param>
            <param-name>spnego.prompt.ntlm</param-name>
            <param-value>true</param-value>
        </init-param>
    
        <init-param>
            <param-name>spnego.logger.level</param-name>
            <param-value>1</param-value>
        </init-param>
    </filter>
    
    <filter-mapping>
        <filter-name>SpnegoHttpFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
    </web-app>
    

    aggiungete anche il file index.jsp nella root della web application con il seguente contenuto:

    <%@page import="java.security.Principal" %>
    <html>
     <head>
      <title>Protected Page for Examples</title>
     </head>
     <body bgcolor="white">
      You are logged in as remote user <b><%= request.getRemoteUser() %></b> in session <b><%= session.getId() %></b>
      <br><br>
      <%
    	if (request.getUserPrincipal() != null) {
      %>
      Your user principal name is <b><%= request.getUserPrincipal().getName() %></b>.
      <br><br>
      <%
       } else {
      %>
       No user principal could be identified.
       <br><br>
      <%
      }
      %>
      <%
      String role = request.getParameter("role");
      if (role == null)
        role = "";
      if (role.length() > 0) {
        if (request.isUserInRole(role)) {
      %>
      You have been granted role <b><%= role %></b>.
      <br><br>
      <%
       } else {
      %>
      You have <i>not</i> been granted role <b><%= role %></b>.
      <br><br>
      <%
       }
      }
      %>
      To check whether your username has been granted a particular role, enter it here:
      <form method="GET" action='<%= response.encodeURL("index.jsp") %>'>
       <input type="text" name="role" value="<%= role %>">
      </form>
      <br><br>
      You can logoff by clicking
      <a href='<%= response.encodeURL("index.jsp?logoff=true") %>'>here</a>.
      This should cause automatic re-logon with Waffle and a new session ID.
      <br>
     </body>
    </html>
    
  • a questo punto inserite questa web application nelle applicazioni del vostro Tomcat
  • per completare il processo bisogna lanciare nel domain controller un paio di istruzioni per abilitare il tab delegation all’utente Active Directory che effettuerà la verifica dei token del Kerberos.
    setspn.exe -A HTTP/<sito> utentead
    setspn.exe -A HTTP/<sito_con_dominio> utentead
    

    poi aprendo le proprietà dell’utente, nel tab “Delegation”, abilitare la funzione “Trust this user for delegation to any service (Kerberos only)”.

  • per permettere al browser di passare le credenziali al server bisognerà, nel caso di IE, inserire il sito all’interno dell’Area Intranet e verificare che sotto la voce Autenticazione Utente (dentro livello personalizzato) sia impostato come “Accesso automatico solo nell’area Internet”, mentre per Firefox (testato con il 3.x) bisogna impostare le seguenti chiavi con il valore del vostro sito web
    network.negotiate-auth.delegation-uris = http://<sito>
    network.negotiate-auth.trusted-uris = http://<sito>
    
  • riavviate ora Tomcat e accedete alla root della vostra nuova web application
  • il filtro di spnego proteggerà tutti i file della web application e chiederà l’autenticazione nativa (o eventualmente l’autenticazione basic tramite prompt). Se l’autenticazione avverrà correttamente accederete al file index.jsp e leggerete il vostro nome utente nella pagina.

Grazie per l’attenzione e buon lavoro!

Generazione di un hash md5 in Java

Postato da ROb | nella categoria Java, Sviluppo web | mercoledì, 10 novembre 2010

0

Con questa semplice funzione è possibile generare una stringa in codifica md5 a partire da una stringa di testo.

       /**
	 * Generates the md5sum of the given digest
	 *
	 * @param digest
	 * @return
	 */
	public static String md5sum(String digest) {
		String message = null;

		if (digest != null) {
			try {
				MessageDigest md = MessageDigest.getInstance("MD5");
				md.reset();
				byte[] messageBytes = md.digest(digest.getBytes());
				BigInteger number = new BigInteger(1, messageBytes);
				message = number.toString(16);
			} catch (NoSuchAlgorithmException e) {
				e.printStackTrace();
			}
		}

		return message;
	}

Pulire codice HTML eccetto alcuni tag in Java sfruttando Jsoup

Postato da ROb | nella categoria Java, Sviluppo web | venerdì, 24 settembre 2010

4

Abbiamo già parlato di Jsoup in questo precedente post.
In due parole Jsoup è una potente libreria di parsing html/xml che permette di leggere e manipolare facilmente stringhe e porzioni anche grandi di codice html/xml.

Oggi voglio farvi vedere come possiamo sfruttarla per pulire del codice html (proveniente ad esempio dal campo di un web form) mantenendo solamente i tag che vogliamo.

Questa opzione è infatti molto utile nel caso in cui si voglia permettere agli utenti di arricchire il dato con la formattazione classica dei testi: bold, italico, … senza però rischiare di esporci al pericoloso XSS attack che consiste nell’inserire codice Javascript malevolo che punta verso qualche altro sito.

Con poche righe di codice Jsoup ci permette di definire la nostro lista di tag partendo da alcuni set predefiniti.

        ...
        String unsafe = "<p><a href='http://www.bits4beats.com/' onclick='stealCookies()'>Benvenuto <b>Roberto Rossi</b></a> lo so che che sei di Macerata! <br/>... sei proprio un <i>impiastro</i>!</p>";

		Whitelist myWL = Whitelist.simpleText();
		myWL.addTags("br", "hr");

		String safe = Jsoup.clean(unsafe, myWL);
		System.out.println("stringa sicura: " + safe);
        ...

Se lo eseguiamo otterremo la seguente stringa:

stringa sicura: Benvenuto <b>Roberto Rossi</b> lo sei che sei di Macerata! <br /> sei proprio un <i>impiastro</i>!

In pratica abbiamo detto a Jsoup di partire dalla lista accettata simpleText() che contiene i tag essenziali della formattazione a cui abbiamo aggiunto il tag br e il tag hr.

Java: le variabili di ambiente in un oggetto Properties

Postato da ROb | nella categoria Java, Sviluppo web | giovedì, 16 settembre 2010

0

Ecco come è possibile ottenere in un oggetto di tipo Properties contenente le variabili di ambiente della nostra Linux box.

       /**
	 * Legge le variabili di ambiente e popola un oggetto di tipo Properties
	 */
	public static Properties getEnvironment() throws java.io.IOException {
	    Properties env = new Properties();
	    env.load(Runtime.getRuntime().exec("env").getInputStream());
	    return env;
	}

A questo punto con il seguente codice possiamo conoscere, ad esempio, il valore della variabile LANG che determina la codifica dei file.

       ...
       Properties env = Utils.getEnvironment();
       String lang = (String) env.get("LANG");
       ...

Una comunità di programmatori per programmatori: StackOverflow

Postato da ROb | nella categoria Java, Sviluppo web, Varie | domenica, 12 settembre 2010

2

Quando avevo bisogno di informazioni tecniche e mi affidavo a Google per le mie care ricerche, spesso capitavo in un sito decisamente simpatico dove trovavo quasi sempre le risposte alle mie domande.

Sinceramente non ho mai approfondito la natura del sito, né tantomeno quale fossero gli argomenti prelaventi. Mi limitavo a provare le soluzioni proposte e se funzionavano me ne andavo per sempre dal sito.

Qualche giorno fa, mosso da uno strano spirito di curiosità (non è vero ce l’ho sempre solo che spesso è soffocato dalla voglia di concludere le attività) mi sono soffermato a studiarlo un pò.

Il sito si chiama StackOverflow, un nome decisamente per programmatori, e in realtà unisce un gruppo numerosissimo di sviluppatori in tutto il mondo.
Il suo funzionamento è di una banalità imbarazzante ma forse è anche il motivo del suo successo. Se hai qualche dubbio, problema, richiesta, fai prima una ricerca nel sito e se non trovi niente scrivilo direttamente su StackOverflow.
Troverai sicuramente qualcuno che ha già avuto il tuo stesso dubbio oppure ha già risolto il tuo stesso problema. Se così non fosse magari troverai allora qualcuno disposto ad aiutarti e “perdere” un pò del suo tempo prezioso per rispondere in modo efficace alla tua domanda.

StackOverflow è un sito di programmatori per programmatori. Chiunque comunque può accedere al sito, non sono richiesti particolari prerequisiti, e chiunque può aiutare o rispondere.
In realtà non è sempre così, nel senso che il sistema di StackOverflow è autopremiante e automoderato.
Rispondendo, commentando e risolvendo le domande ogni iscritto riceve dei punti che gli permettono oltre che di guadagnare reputazione e stima dagli altri anche di acquisire facoltà operative.
Non tutti cioè possono fare tutto. Ad esempio chi ha un punteggio pari a 0 non può inserire più di 2 link in una risposta, probabilmente per allontanare gli spammer o chi vuole fare solamente pubblicità.

Se avete voglia di diventare dei guru di StackOverflow, se avete delle forti spinte filantropiche oppure se semplicemente avete bisogno di aiuto in uno dei moltissimi argomenti trattati, di programmazione e non solo, rivolgetevi allora a StackOverflow, iscrivetevi e partecipate a questa grandissima community.

Per chi mi dovesse cercare, io sono impiastro e, come potete vedere, il mio punteggio è ancora veramente molto basso.

Qui sotto trovate il codice javascript che potete inserire all’interno del vostro sito per segnalare la vostra situazione StackOverflow. Questo è il mio.



Java: misurare i tempi di esecuzione delle nostre procedure

Postato da ROb | nella categoria Java, Sviluppo web | mercoledì, 21 luglio 2010

0

Spesso mi sono trovato nella situazione di voler possedere uno strumento che mi permettesse di misurare i tempi di esecuzione di una procedura, di un metodo di una classe o di un semplice blocco di codice.

chronometer

Tutte le volte mi sono scritto delle apposite funzioni, che facevano la differenza tra la data di fine e la data di inizio della misurazione e poi stampavano il risultato tramite un sistema di logging.

Ieri però, non soddisfatto delle esperienze precedenti, ho cercato un tool che facesse lo sporco lavoro per me, che fosse affidabile e che permettesse di avere un valido report di visualizzazione dei dati raccolti.

Eccomi quindi arrivato, non so come (perché dal nome del progetto non sono chiare le finalità della libreria), a JETM.
JETM è l’acronimo di “Java™ Execution Time Measurement Library” che dichiara di essere “a small and free library, that helps locating performance problems in existing Java applications.”

Per integrarla nelle nostre applicazioni è sufficiente inserire il file jar della distribuzione, chiamato jetm-x-x-x.jar, all’interno del nostro CLASSPATH e fare in modo tale che la configurazione venga inizializzata prima della registrazione delle misurazioni vere e proprie.

Le applicazioni standalone possono inizializzare la configurazione all’inizio del loro ciclo di esecuzione, le applicazioni web possono affidarsi alla configurazione di Spring oppure tramite degli opportuni ContextListener definiti nel file web.xml.

Il codice banale di inizializzazione è:

	    BasicEtmConfigurator.configure();
	    monitor = EtmManager.getEtmMonitor();
	    monitor.start();

a questo punto per poter collezionare una misurazione dobbiamo definire un punto e successivamente determinare la fine della misurazione, in questo modo:

	    EtmPoint point = monitor.createPoint("Nomedelpuntodicollezione");
	    // do something...
	    point.collect();

Il parametro del metodo createPoint serve per distinguere un punto di misurazione da un altro.
Alla fine della nostra applicazione, o quando lo riteniamo più opportuno, possiamo visualizzare i dati collezionati e al termine stoppare il servizio di monitoraggio:

	    monitor.render(new SimpleTextRenderer(new Locale("it")));
	    monitor.stop();

Il renderer inizializzato in italiano serve per utilizzare i corretti separatori di decimali e migliaia.
L’output ottenuto dal metodo render assomiglia a qualcosa di questo tipo:

Java(TM) Execution Time Measurement Library

Il tempo calcolato è espresso in millisecondi.

Se vogliamo anche visualizzare l’annidamento delle misurazioni/chiamate possiamo passare il parametro “true” al metodo di inizializzazione della configurazione:

        BasicEtmConfigurator.configure();

Per ulteriori informazioni e tutta la documentazione necessaria fate riferimento al sito ufficiale del progetto (http://jetm.void.fm/)

Formattazione di un numero decimale in Java

Postato da ROb | nella categoria Java, Sviluppo web | martedì, 20 luglio 2010

2

Può capitare di dover modificare i caratteri separatori di decimali e migliaia nella formattazione di un numero in Java.

Questa porzione di codice vi permette di farlo sfruttando alcune classi base di Java:

    		DecimalFormatSymbols symbols = new DecimalFormatSymbols();
    		symbols.setDecimalSeparator('$');
        	symbols.setGroupingSeparator('#');

        	String format = "###,###.###";
        	DecimalFormat formatter = new DecimalFormat(format, symbols);
        	formatter.setGroupingSize(3);

        	String numberString = formatter.format(number);

In questo caso, un pò per gioco, abbiamo impostato il carattere $ come separatore dei decimali e # come separatore delle migliaia.

La classe DecimalFormat formatta il numero sfruttando il pattern specificato in questo “###,###.###”. Il suo costruttore però accetta anche una variabile di tipo DecimalFormatSymbols che può essere inizializzata a partire da uno specifico Locale (avremmo infatti potuto rimpiazzare la chiamata con DecimalFormatSymbols symbols = new DecimalFormatSymbols(new Locale(“it”)); ).

A questo punto la variabile symbols può essere utilizzata per sovrascrivere le impostazioni dell’eventuale Locale utilizzato oppure può essere utilizzato in modo nativo lasciando i separatori di default che, per la lingua italiana, sono tipicamente la “,” come separatore dei decimali e il “.” come raggruppatore della migliaia (non sempre visualizzato).

Sfruttare le Google Picasa API per generare una galleria di immagini

Postato da ROb | nella categoria Java, Linux, Sviluppo web | giovedì, 22 aprile 2010

0

Chi non conosce il bellissimo e potentissimo software Picasa?
E’ sempre più facile vederlo installato nei desktop degli utenti come rimpiazzo dell’applicazione di default di visualizzazione immagini. Anche io che uso Linux, nonostante la scelta di software di gestione e visualizzazione immagini sia molto ricca e il fatto che non è un’applicazione nativa Linux ma emulata tramite Wine, ho eletto Picasa come il “mio” software di gestione immagini.

Google Picasa API

Non voglio però dilungarmi molto in merito ai pregi di questo gestore di immagini. L’oggetto di questo post è la possibilità di sfruttare il servizio web ad esso associato (ma anche utilizzabile in modo indipendente) chiamato Picasa Web Albums.

Picasa Web Albums è un servizio web che ci permette di caricare, organizzare i nostri album di foto e di condividerli con chi vogliamo. Migliorato di mese e mese, si è arricchito ultimamente anche della capacità di riconoscere i volti delle persone nelle foto in modo automatico.

Questo servizio Google, come molti altri dell’azienda di Mountain View, espone delle API, cioè delle librerie utilizzabili dagli sviluppatori, che, dopo un’opportuna autenticazione, permettono di leggere e manipolare i dati del servizio stesso.
Nel caso ad esempio delle API di Picasa Web Albums possiamo richiedere la lista dei nostri album oppure ricevere la lista delle immagini contenuto in uno specifico album oppure caricare una foto nell’album e così via.

Oggi voglio parlarvi di una piccola applicazione scritta in Java, che sfrutta l’API del servizio per questo linguaggio, in grado di generare una porzione di codice html partendo da una lista di immagini di uno specifico album caricato in Picasa Web Albums.

Per poter eseguire l’applicazione dovete avere opportunamente scaricato e configurato il pacchetto delle API di Google, impostando correttamente le dipendenze verso i file jar dei servizi che utilizzate.
Per comodità comunque allego in fondo all’articolo l’intero progetto Eclipse zippato.

Il programma deve essere eseguito in due passaggi.
Nel primo passaggio, dopo aver opportunamente modificato l’utente e password, bisogna attendere che il programma stampi a video la lista degli album caricati e i relativi id. Scegliamo a questo punto l’id del nostro album e impostiamolo come valore della variabile albumId.

Rieseguiamo quindi il programma (secondo passaggio) e a questo punto potremmo vedere un output decisamente più ricco che contiene un html generato partendo dai dati e dalle immagini contenuti nell’album specificato.
L’html viene generato utilizzando il motore di templating Velocity a cui è stato passato l’oggetto feed contenente tutti i dati del nostro album. Il file del template è album.vm che si trova all’interno della cartella del progetto di nome templates.
Ovviamente potete modificare a vostro piacimento tale template utilizzando a pieno il modello dei dati messo a disposizione da Google.

Di seguito propongo il codice Java del programma, ovviamente con delle credenziali fasulle:

import java.io.StringWriter;
import java.net.URL;
import java.util.Properties;

import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;

import com.google.gdata.client.photos.PicasawebService;
import com.google.gdata.data.photos.AlbumEntry;
import com.google.gdata.data.photos.AlbumFeed;
import com.google.gdata.data.photos.UserFeed;

public class Main {
	public static void main(String[] args) {
		try {
			String username = "<username>";
			String domain = "@gmail.com";
			String password = "<password>";
			String albumId = "<empy>";

			PicasawebService myService = new PicasawebService(username);
			myService.setUserCredentials(username + domain, password);

			URL feedUrl = new URL("http://picasaweb.google.com/data/feed/api/user/" + username + "?kind=album");

			UserFeed myUserFeed = myService.getFeed(feedUrl, UserFeed.class);
			for (AlbumEntry myAlbum : myUserFeed.getAlbumEntries()) {
			    System.out.println(myAlbum.getTitle().getPlainText() + " - " + myAlbum.getId());
			}

			URL feedAlbumUrl = new URL("http://picasaweb.google.com/data/feed/api/user/" + username + "/albumid/" + albumId);

			AlbumFeed feed = null;
			try {
				feed = myService.getFeed(feedAlbumUrl, AlbumFeed.class);
			}
			catch (com.google.gdata.util.ResourceNotFoundException rnfe) {
				System.out.println("\nalbum non trovato, controlla l'id");
			}

			if (feed != null) {
				Properties velProps = new Properties();
				velProps.load(Main.class.getResourceAsStream("velocity.properties"));
				Velocity.init(velProps);

				VelocityContext context = new VelocityContext();

				context.put("feed", feed);

				Template template = null;

				try {
				   template = Velocity.getTemplate("templates/album.vm");
				}
				catch( Exception e ) {
					e.printStackTrace();
				}

				StringWriter sw = new StringWriter();

				template.merge( context, sw );

				System.out.println();
				System.out.println(sw);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

Questo è invece il codice del template album.vm :

		<h4>$!feed.title.plainText</h4>
		<ul class="gallery clearfix">
#foreach($photo in $feed.getPhotoEntries())
		    <li>
		       <a rel='prettyPhoto[$feed.id]' title="$photo.getDescription().getPlainText()" href='$photo.getMediaContents().get(0).getUrl()' >
		          <img src='$photo.getMediaThumbnails().get(0).getUrl()' width='100' class='thumb' border='0' />
		       </a>
		    </li>
#end
		</ul>

Ecco infine il file compresso contenente il progetto completo in formato Eclipse.

Allungare il tempo delle sessioni in un’applicatione web

Postato da ROb | nella categoria Java, Sviluppo web | giovedì, 15 aprile 2010

0

Per aumentare la durata di una sessione in un’applicazione web Java J2EE è sufficiente inserire una particolare direttiva all’interno del file web.xml dell’applicazione stessa.

Ecco la sintassi:

  ...
  <session-config>
    <session-timeout>120</session-timeout>
  </session-config>
  ...

dove il numero rappresenta i minuti.