DBeaver il database manager universale!

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

0

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

0

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.

Invio di mail in Java

Postato da ROb | nella categoria Java | mercoledì, 17 marzo 2010

0

Qualsiasi programmatore, prima o poi, ha necessità di inviare delle mail.

In Java esistono moltissimi modi per farlo e uno di questi è utilizzando la libreria Apache Commons Email.
Le librerie Apache Commons sono state scritte per permettere a tutti i progretti Jakarta ma non solo di poter disporre di componenti, pronti all’uso, integrabili nei rispettivi progetti.
Uno di questi componenti è proprio Commons Email, utilizzabile per inviare mail in formato normale o anche html, con o senza attachment.

Utilizzare tale libreria, per chi ha un minimo di confidenza con Java, è davvero semplice.
Con 7 righe di codice è possibile inviare una mail in formato html senza allegati.
Ecco un esempio:

HtmlEmail email = new HtmlEmail();
email.setSubject("Una nuova mail per Roberto Rossi");
email.setHtmlMsg("Ecco un testo in formato <b>HTML</b><br/>");
email.setHostName("host");
email.setFrom("no-reply@bits4beats.it");
email.addTo("user@bits4beats.it");
email.send();

Se invece vogliamo spedire una mail in formato testo standard basta usare l’oggetto SimpleEmail anziché HtmlEmail e il metodo setMsg anziché setHtmlMsg, in questo modo:

SimpleEmail email = new SimpleEmail();
email.setSubject("Una nuova mail per Roberto Rossi");
email.setMsg("Ecco un testo in formato standard");
email.setHostName("host");
email.setFrom("no-reply@bits4beats.it");
email.addTo("user@bits4beats.it");
email.send();

Infine, se abbiamo la necessità di aggiungere degli allegati alla mail, nel primo caso possiamo utilizzare semplicemente il metodo attach passando come parametro un oggetto EmailAttachment costruito così:

EmailAttachment attachment = new EmailAttachment();

String filePath = "pathtofile";
attachment.setPath(filePath);
attachment.setDisposition(EmailAttachment.ATTACHMENT);
attachment.setDescription("description for this attachment");

emailAdmin.attach(attachment);

Mentre nel secondo caso dobbiamo utilizzare il tipo di email MultiPartEmail anziché SimpleEmail per poter disporre del metodo attach utile per l’inclusione di allegati.

Decisamente comodo e potente.

Creare un file zip in Java

Postato da ROb | nella categoria Java | giovedì, 4 marzo 2010

2

Già dalla versione 1.4 Java supporta la possibilità di creare file compressi di uno o più file.
L’algoritmo di compressione supportato è lo zip e le classi in gioco sono java.util.zip.ZipEntry e java.util.zip.ZipOutputStream.

File zip

La seguente funzione prende in input un file, che conterrà il nostro zip, e una lista di file.
All’interno del file zip inserirà tutti i file passati nel secondo parametro.

	private void createZip(File zipFile, List<File> files) throws IOException {
		FileOutputStream dest = null;
		ZipOutputStream out = null;

		byte data[] = new byte[BUFFER];

		try {
			dest = new  FileOutputStream(zipFile);
			out = new ZipOutputStream(new BufferedOutputStream(dest));

			if (files != null) {
				for (Iterator iter = files.iterator(); iter.hasNext();) {
					File file = null;
					FileInputStream fi = null;

					try {
						file = (File) iter.next();
						fi = new FileInputStream(file);

						/* add zip entry */
						ZipEntry entry = new ZipEntry(file.getName());
						out.putNextEntry(entry);

						int count;
						while ((count = fi.read(data, 0, BUFFER)) != -1) {
						   out.write(data, 0, count);
						}
					}
					catch (Exception e) {
						e.printStackTrace();
					}
					finally {
						fi.close();
					}
				}
			}
		}
		catch (Exception e) {
			e.printStackTrace();
		}
		finally {
			out.close();
		}
	}

Aggiungere o sottrarre giorni, mesi, anni a una data in Java

Postato da ROb | nella categoria Java | lunedì, 22 febbraio 2010

0

Può sembrare banale ma la prima volta che ho cercato di farlo ci ho messo un pochino per trovare la soluzione giusta. Ho deciso così di pubblicare queste poche righe di codice.

date

Per sottrarre o aggiungere un giorno a una data, bisogna creare un’istanza della classe Calendar, impostando una data e sommando a questa 1 di tipo giorno.

/* adding 1 day to the actual date */
Date eventDate = new Date();
Calendar calendar = Calendar.getInstance();
calendar.setTime(eventDate);
calendar.add(Calendar.DATE, 1);
Date pastDate = calendar.getTime();

Se vogliamo invece sottrarre un giorno dobbiamo usare “-1″ anziché “1″ alla riga 5.
Nel caso in cui dobbiamo aggiungere o sottrarre mesi o anni possiamo usare, sempre alla riga 5, Calendar.MONTH o Calendar.YEAR .

Fare debugging di applicazioni web Java con Tomcat ed Eclipse

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

2

Qualche anno fa ritenevo impossibile fare debugging di applicazioni web.
Mi chiedevo in particolar modo come fosse possibile raggruppare all’interno di un unico debugger la componente client side (cioè il mix di codice html+css+javascript eseguito nel browser) con la componente server side (in qualsiasi forma si presentasse: php, java, dot.net).

Eclipse, compagno di debug

Ultimamente molti framework, così come importanti application server con il loro IDE associato, sono riusciti a colmare questa mancanza ed ad offire a noi poveri sviluppatori il nostro caro e provvidenziale debugger.

In realtà in questo articolo non spiegherò come sia possibile fare debugging di entrambe le componenti (client e server) in un’unico IDE bensì mi concentrerò solamente sulla parte server, che ho sempre considerato la più spinosa.
La parte client, in realtà, dà spesso meno noie. Il suo comportamento è più facilmente intuibile e spesso è sufficiente fare delle stampe extra di codice html o qualche alert javascript per poter venire a capo dei problemi (anche se non dobbiamo dimenticare l’utilissimo Firebug in Firefox, di cui ho parlato anche ieri, che permette di fare debugging anche del Javascript lato client).

Oggi voglio parlare del debugging server side di applicazioni web per il mondo Java e in particolare della modalità fornita da Eclipse chiamata “Remote Java Application”. E’ una modalità tale per cui è possibile avviare la JVM con un demone in ascolto su una determinata porta. A questa porta, IDE opportunamente istruiti (quale ad esempio Eclipse), possono collegarsi e dialogare con la JVM stessa.
La JVM segnala all’IDE la riga in quel momento in esecuzione e riceve dall’IDE stesso dei comandi in merito all’esecuzione del codice: breakpoint, step-into, step-over, stato delle variabili, …

Per arrivare a poter debuggare la nostra JVM remota, dobbiamo essenzialmente eseguire due passi: avviare la JVM di Tomcat con degli opportuni parametri per la modalità “remote instance” e indicare al nostro IDE, per il nostro progetto da debuggare, qual è la porta della JVM a cui collegarsi.

Cominciamo con la parte di modifica dell’avvio di Tomcat:

  • scegliere una porta libera su cui mettere in ascolto la JVM di Tomcat. Per questo esempio useremo la porta 5050
  • individuare il file startup.sh all’interno della nostra distribuzione Tomcat (la versione di Tomcat di questo post è la 6, ma tale procedura è ugualmente applicabile alla versione 5.5)
  • modificare l’ultima riga di tale file in questo modo
    # vecchia riga
    # exec "$PRGDIR"/"$EXECUTABLE" start "$@"
    # nuova riga
    export JPDA_TRANSPORT=dt_socket
    export JPDA_ADDRESS=5050
    exec "$PRGDIR"/"$EXECUTABLE" jpda start "$@"
    
  • controllare che, dopo aver avviato Tomcat, la JVM sia effettivamente in ascolto
    telnet localhost 5050
    Trying 127.0.0.1...
    Connected to localhost.
    Escape character is '^]'.
    

Abbiamo terminato con le modifiche alla sequenza di avvio di Tomcat. Passiamo ora ad Eclipse.
Dopo aver scelto il progetto che vogliamo debuggare, le cui classi compilate devono essere in esecuzione all’interno di una webapp del nostro application server Tomcat, dobbiamo creare una nuova istanza di compilazione di tipo “Remote Java Application“.

  • dal menu “Run” di Eclipse scegliamo la voce: “Debug…”
  • scorriamo fino alla voce “Remote Java Application” e scegliamo “New” utilizzando il tasto destro del mouse


    Nuova istanza di debug JVM remota

  • diamo un nome alla nostra istanza di debug e modifichiamo la porta di default con la porta scelta 5050


    Modifica delle impostazioni standar, istanza remota java

  • a questo punto clicchiamo su Debug. Se tutto va bene Eclipse dovrebbe essere in grado di connettersi e dialogare con la nostro JVM in esecuzione con Tomcat

Ora viene la parte più bella!

Iniziamo a impostare dei breakpoint nei punti di codice che vogliamo controllare e facciamo sì che il flusso di esecuzione arrivi in quel punto.
Magicamente potremmo vedere tutti i nostri oggetti Java materializzarsi. Possiamo esaminarne tutte le proprietà, impostare delle espressioni di controllo, entrare e uscire dalle funzioni.

Un aspetto decisamente divertente è l’interazione con il browser. Interrompendo il flusso di esecuzione della JVM interrompiamo ovviamente anche la risposta del server verso il browser. Il cursore di attesa del nostro amato Firefox girerà finché non avremo terminato il controllo del nostro codice e lanceremo il nostro ultimo F8.

Nel caso di debug di applicazioni web AJAX tale possibilità di sviluppo facilita ulteriormente le cose. In questi casi infatti è meno banale controllare i dati restituiti dal server in quanto non compongono quasi mai una pagina html ispezionabile bensì solamente delle porzioni di codice XML o del Javascript serializzato in formato JSON.

Spero che l’articolo vi sia tornato utile; commenti e osservazioni sono sempre molto ben accetti.

La serializzazione XML di oggetti attraverso XStream

Postato da ROb | nella categoria Java, Sviluppo web | mercoledì, 3 febbraio 2010

0

Prima o poi capita a tutti di dover mettere gli oggetti da qualche parte (anche ai più disordinati :-) ).

Quando è capitato anche a me mi sono chiesto quale fosse il metodo più veloce (in termini di tempo di ricerche e test) e semplice. Mi rendo conto che non è sempre l’approccio corretto per risolvere i problemi ma in questo caso, visto che l’ambito di applicazione era veramente ristretto, mi sono permesso di usare questa tattica.

La serializzazione xml di oggetti Java

Quando sono approdato nel “Two Minute Tutorial” dell’homepage del progetto mi sono subito convinto a provare la libreria XStream.

Ritornando per un attimo sul problema originale, stavo cercando una libreria che mi permettesse di salvare degli oggetti Java (quindi delle istanze di classi) all’interno di stringhe o file in formato xml. Ero convinto della fattibilità della cosa ma non sapevo effettivamente come fare.
La comodità di avere dei pezzi di codice in xml contenenti oggetti Java serializzati apre effettivamente a un mondo di possibili applicazioni interessanti, prima fra tutti la possibilità di salvare lo stato di un applicazione oppure anche la possibilità di caricare dei parametri di configurazione di un servizio.

Ispirato dal codice del tutorial e dopo aver scaricato i due file jar (uno contenente la libreria XStream e l’altro una libreria da cui XStream dipende) ho iniziato a pasticciare con Eclipse per arrivare al mio desiderato semilavorato.
Effettivamente il “Two Minute Tutorial” non tradisce le aspettative e grazie alla semplicità di utilizzo di XStream sono riuscito a generare stringhe xml da oggetti e viceversa istanziare oggetti Java a partire da porzioni di codice xml.

Ecco qua il risultato:

package it.bits4beats.test;

import com.thoughtworks.xstream.XStream;

/**
 * @author Roberto Rossi
 */
public final class ObjectSerialization {

    private ObjectSerialization() {
    }

    public static void main(String[] args) {
        try {
        	XStream xstream = new XStream();

        	xstream.alias("address", Address.class);

        	Address address = new Address();
        	address.setAddress("Via Giacomo Leopardi, 2");
        	address.setCity("Recanati");

        	String xml = xstream.toXML(address);

        	System.out.println("--- SERIALIZATION ---");
        	System.out.println(xml + "\n");

        	Address address2 = (Address) xstream.fromXML("<address><address>Via Beniamino Gigli, 4</address><city>Porto Recanati</city></address>");

        	System.out.println("--- DESERIALIZATION ---");
        	System.out.println("address: " + address2.getAddress());
        	System.out.println("city: " + address2.getCity());
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

}

class Address {
	private String address;
	private String city;

	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
}

La riga 15 istanzia la classe XStream, addetta a tutte le operazioni di serializzazione/deserializzazione degli oggetti. Nella riga 17 si comunica a XStream che l’elemento root per la class Address (definita in questo stesso file) si chiama appunto “address”.
Successivamente si procede a due test indipendenti, il primo (righe 19-26) crea un oggetto di tipo Address e ne genera la versione xml, il secondo (righe 28-32) inizializza una stringa xml contenente un indirizzo e istanzia un oggetto Address che la rappresenta.

Questo è l’output della console:

--- SERIALIZATION ---
<address>
  <address>Via Giacomo Leopardi, 2</address>
  <city>Recanati</city>
</address>

--- DESERIALIZATION ---
address: Via Beniamino Gigli, 4
city: Porto Recanati

Della serie: minimo sforzo, massima resa!

MySQL Workbench, lo strumento principe per il db design con MySQL

Postato da ROb | nella categoria Java, Linux, Sviluppo web | martedì, 2 febbraio 2010

0

Negli ultimi tempi, prima di iniziare a scrivere il codice sql necessario alla creazione di tabelle e indici, ho imparato a modellare le entità attraverso MySQL Workbench, lo strumento di design di MySQL.

MySQL Workbench nasce dalle ceneri del bellissimo e potente DbDesigner 4 della fabFORCE, disponibile in ambiente Windows e sviluppato con librerie Qt.

Le prime versioni di MySQL Workbench erano praticamente inusabili: crash continui e improvvisi impedivano di utilizzarlo in modo produttivo.
La versione che ho installato qualche mese fa (cioè la 5.1.17) è invece sorprendentemente stabile e ben realizzata.

Schermata di avvio MySQL Workbench

Con questo software MySQL (ormai Oracle) ha pensato di dare una mano agli sviluppatori open source per poter progettare e realizzare in modo grafico strutture dati complesse.
MySQL Workbench permette di creare tabelle, relazioni fra tabelle, indici. Con tali oggetti è possibile, tramite trascinamento costruire diagrammi E/R (tutte le relazioni vengono visualizzate anche graficamente) che possono essere arricchiti di immagini e layer (contenitori colorati di tabelle).
Dopo qualche ora di lavoro, MySQL WB ripaga gli sforzi fatti per apprenderlo e ci permette di dominare schemi anche molto densi di tabelle.

MySQL Workbeanch al lavoro sul database di demo Sakila

MySQL Workbeanch al lavoro sul database di demo Sakila

Al termine del processo di design è possibile puntare direttamente a un db, locale o remoto, per materializzare tutti gli oggetti creati.
Altra funzionalità decisamente comoda è anche il Reverse Engineering da un db, che permette di ricostruire lo schema grafico partendo da un’istanza di db già esistente.

Non manca neanche la funzione di sincronizzazione modello che evidenzia le incoerenze tra modello e db e riporta le modifiche all’uno o all’altro dei due sistemi.

Estrarre informazioni da un sito attraverso jsoup, html parser per Java

Postato da ROb | nella categoria Java, Sviluppo web | lunedì, 1 febbraio 2010

0

Ieri mi sono divertito a testare una nuova libreria in Java per il parsing di documenti HTML/XML.

Jsoup, questo il nome particolare di tale libreria, permette con una sintassi a selettori (stile JQuery) di inviduare specifici elementi del DOM di un documento html, sia locale che remoto.

Jsoup, html java parser

Dopo aver scaricato la libreria dal sito ufficiale e averla importata nel mio workspace Eclipse, ho modificato leggermente uno degli esempi proposti per provare a estrarre i titoli e gli url di tutti i post dall’homepage del mio blog (http://www.bits4beats.it).

Beh… il risultato è stato veramente interessante e ho molta voglia di farci qualcosa di più costruttivo. Pensavo addirittura a uno script o un programmino per visualizzare il posizionamento di un sito per particolari keyword su più motori di ricerca. Se avrò voglia, tempo e capacità per farlo pubblicherò un post in merito.

Per ora godetevi queste 10 righe di codice:

		Document doc = Jsoup.parse(new URL("http://www.bits4beats.it/"), 2000);

		Elements resultLinks = doc.select("div.post-title > h2 > a");
		System.out.println("Ultimi post di www.bits4beats.it con jsoup");
		for (Element link : resultLinks) {
			System.out.println();
			String href = link.attr("href");
			System.out.println("Titolo: " + link.text());
			System.out.println("Url: " + href);
		}

Nella riga 1 si crea un oggetto Document facendo il download dell’homepage del blog aspettando al massimo 2000 millisecondi.
Successivamente si cercano tutti gli elementi di tipo a figli diretti di elementi di tipo h2 figli diretti a loro volta di elementi div con classe post-title.
Per ognuno di questi elementi trovati, alle righe 8 e 9, vengono stampati rispettivamente l‘anchor text (cioè il testo cliccabile del link) e l’url del post.

Un ringraziamento allo sviluppatore del progetto, Jonathan Hedley, che ha corretto in tempi brevissimi un piccolo errore nel codice del jsoup Cookbook.

Risolvere il nome host dall’indirizzo ip in Java

Postato da ROb | nella categoria Java | domenica, 31 gennaio 2010

0

Ecco uno snippet di codice Java utile per ottenere l’hostname a partire dall’indirizzo ip (reverse dns lookup).

	public void testHostnameByIp() throws UnknownHostException {
		// ottiene un'istanza di InetAddress a partire dall'indirizzo IP
		InetAddress inetAddress = InetAddress.getByName("63.245.213.92");
		// risolve il nome
		String hostname = inetAddress.getHostName();
		// stampa in console l'indirizzo risolto
		System.out.println("nome host: " + hostname + " per l'indirizzo: " + inetAddress.getHostAddress());
	}

Questa funzione Java è all’interno di un TestCase Junit, per eseguirlo da Eclipse è sufficiente individuare la funzione nel box Outline e cliccando con il tasto destro scegliere la voce Debug As => JUnit Test.

P.S.: l’indirizzo IP utilizzato appartiene alla rete server web pubblici di Mozilla Foundation.

EasyEclipse: un Eclipse potenziato

Postato da ROb | nella categoria Java, Sviluppo web | venerdì, 22 gennaio 2010

0

Eclipse è indubbiamente un potentissimo IDE Open Source. Negli ultimi anni la Eclipse Foundation ha praticamente sbaragliato la concorrenza commerciale sia introducendo le librerie SWT (versione os dependent delle Java AWT) che creando l’IDE Eclipse, strumento avanzato di sviluppo in Java ma poi diventato in realtà un framework per lo sviluppo multilinguaggio e oltre.

Accanto all’Eclipse ufficiale esiste però una versione già completa di tutti i plugin di sviluppo più diffusi, si chiama: EasyEclipse.

EasyEclipse, figlia diretta di Eclipse, è una versione pacchettizzata di Eclipse (con un suo installer grafico) completa di numerosi plugin a seconda della versione scelta. Ne esiste una per PHP, una per LAMP in generale, una per lo sviluppo Java client, una per sviluppo Java Web, una per Python, una per C/C++.


Get EasyEclipse

Insomma ognuno può scaricare la propria versione di EasyEclipse a seconda del suo linguaggio di sviluppo preferito.

Io ho provato la versione per PHP e sono decisamente soddisfatto. In realtà è come un normale Eclipse con l’aggiunta di una vista particolare per PHP e la code completion delle classi PHP (dopo aver correttamente impostato il path alle librerie).

Visto che gli sviluppatori/mantainer hanno chiesto di parlarne … io l’ho fatto.

L’ultima versione disponibile è la 1.3 che segue lo sviluppo della versione 3.4 di Eclipse.

Criptare e decriptare una stringa in Java

Postato da ROb | nella categoria Java | giovedì, 21 gennaio 2010

0

In alcuni casi ho avuto bisogno di fare una crittazione e decrittazione al volo di una stringa di testo nei miei programmi Java.

Criptare e decriptare

Ho cercato una classe che fosse semplice da utilizzare ma sufficientemente efficace e flessibile per i miei scopi. Dopo un pò di navigazione sono imbattuto in questo bell’articolo di Javid Jamae.

Ecco il file (zippato) da scaricare, all’interno del quale trovate la classe StringEncrypter.java.

Dopo averlo inserito nel vostro classpath e averlo compilato potete criptare e decriptare tramite queste due funzioni:

	/**
	 * Encrypt a string using a key
	 *
	 * @param str
	 * @param resourcemap
	 * @return
	 */
	public static String encrypt(String str, HashMap<String, String> resourcemap) {
		try {
			String encryptionKey = resourcemap.get("encrypt.key");

			StringEncrypter encrypter =  new StringEncrypter(StringEncrypter.DES_ENCRYPTION_SCHEME, encryptionKey );
			String encryptedString = encrypter.encrypt( str );

			return encryptedString;
		}
		catch (Exception e) {
			e.printStackTrace();
			// do nothing
		}

		return null;
	}

	/**
	 * Decrypt a string using a key
	 *
	 * @param str
	 * @param resourcemap
	 * @return
	 */
	public static String decrypt(String str, HashMap<String, String> resourcemap) {
		try {
			String encryptionKey = resourcemap.get("encrypt.key");

			StringEncrypter decrypter =  new StringEncrypter(StringEncrypter.DES_ENCRYPTION_SCHEME, encryptionKey );
			String decryptedString = decrypter.decrypt(str);

			return decryptedString;
		}
		catch (Exception e) {
			// do nothing
		}

		return null;
	}

Dove la stringa “encryptionKey” è una chiave personale e privata utilizzata per criptare e decriptare.

L’algoritmo utilizzato di default è il DES.