All Around the e-World

URLConnection : richiesta http + login

2010-12-07T00:41:00.009+01:00

E' da tanto tempo che non scrivo un post sul mio blog, trovo l'occasione grazie ad un client che stò sviluppando che permette di eseguire il login su un sito mediante classi standard java.net, anzichè utilizzare librerie note come quella di apache.

In particolare in questo post vedremo come creare un wrapper per eseguire connessioni tramite l'oggetto URLConnection.
Quella che vedremo di seguito è una classe di utilità per la gestione delle richieste http con parametri post e/o invio delle informazioni presenti nei cookies.

Ecco il codice sorgente della classe :

package util;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.io.OutputStreamWriter;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import util.entity.ResponseWrapper;

/***
 * Classe di utilità per l'utilizzo delle connessioni mediante UrlConnection del package java.net
 *
 */
public class ConnectionUtils {

 /***
  * Metodo per eseguire una chiamata http.
  * Il metodo richiama un link, passandogli nell'header del pacchetto le informazioni sui parametri
  * e le informazioni sui cookies.
  * Dopo la chiamata http, recupera le informazioni dei cookies ed il contenuto html della risposta
  * e li restituisce in un oggetto modellato per contenere tali informazioni.
  * 
  * @param link   : link da chiamare
  * @param params  : parametri post da passare
  * @param cookiesToSend : cookies da inviare nell'header
  * @return
  */
 public static ResponseWrapper downloadPagePost(String link, Map params,List cookiesToSend) { 

  ResponseWrapper ouputRequest = null;
  try {
   URL url = new URL(link);
   URLConnection conn = url.openConnection();
   // mantiene la connessione anche dopo la richiesta
   conn.setDoOutput(true); 
   conn.setRequestProperty("User-Agent","Java1.6 / "+System.getProperty("os.name")+" ("+System.getProperty("os.version")+")");
   conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
   conn.setRequestProperty("Cookie", CookiesUtils.getMyCookiesString(cookiesToSend));

   OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
   String paramsEncoded = RequestUtils.getEncodedParameters(params);
   wr.write(paramsEncoded);
   wr.flush();

   System.out.println("Call page : "+link);
   String headerName = null;
   List cookiesretrieved = new ArrayList(); 

   for (int i = 1; (headerName = conn.getHeaderFieldKey(i)) != null; i++) {
    //    System.out.println("------------------");
    //    System.out.println("header : "+headerName);
    //    System.out.println("Content : "+conn.getHeaderField(i));

    if (headerName.equals("Set-Cookie")) {
     String cookie = conn.getHeaderField(i);
     //System.out.println("cookie : "+cookie);
     // Estraggo il cookie corrente e lo metto nella lista per il wrapper
     String currCook = cookie.substring(0, cookie.indexOf(";"));
     cookiesretrieved.add(currCook);
    } //end if
   }

   StringBuffer output = new StringBuffer();
   BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
   String line;
   while ((line = rd.readLine()) != null) {
    output.append(line);
   }

   ouputRequest = new ResponseWrapper(output,cookiesretrieved);

  } catch (Exception e) {
   e.printStackTrace();
  }
  return ouputRequest;
 }
}

In dipendenza a questa classe è necessario definire la classe ResponseWrapper :

package util.entity;

import java.io.FileWriter;
import java.io.IOException;
import java.util.List;

public class ResponseWrapper {
 private List cookies;
 private StringBuffer content;
 
 public ResponseWrapper(StringBuffer acontent,List cookin){
  cookies = cookin;
  content = acontent;
 }
 
 public List getCookies() {
  return cookies;
 }

 public void setCookies(List cookies) {
  this.cookies = cookies;
 }

 public StringBuffer getContent() {
  return content;
 }

 public void setContent(StringBuffer content) {
  this.content = content;
 }
 
 public boolean writeToFile(String fileName){
  FileWriter out;
  try {
   out = new FileWriter(fileName);
   out.write(getContent().toString());
   out.close();
  } catch (IOException e) {
   return false;
  }
  
  return true;
 }
}

Questa classe è ha il compito di incapsulare le informazioni recuperate mediante la richiesta http, in particolare l'html contenuto e la lista di cookies generati dal sito.

Definiamo adesso un metodo per eseguire il login a cui passiamo username, password e cookies generati dal sito

 public static boolean login(String username, String password,List cookies){
  Map parametri = new HashMap();
  parametri.put("username",username);
  parametri.put("password",password);
  parametri.put("otherParam","param");
  
  ResponseWrapper responseLogin = ConnectionUtils.downloadPagePost("mysite.org/login.php", parametri,cookies);
  
  boolean loggedin = true ;// Here we can check login
  
                // write html content to a file named checklogin.html
  responseLogin.writeToFile("checklogin.html");
  
  return loggedin;
 }

Come utilizzare questo metodo ? Semplice :

List cookies = new ArrayList();
cookies.add("PHPSESSID=asd5nkl4nmnskdfjsidd=");  
MySampleLogin.login("myUsr","myPasw",cookies);

Spero che la classe vi possa rendere le cose più semplici.
Alla prossima!

Browser.Engine : distinguere i Browser con mootools

2010-05-10T22:27:00.005+02:00

I mootools tra la miriade di funzionalità, ci permette di individuare la versione del browser mediante la classe Browser.

Un classico esempio di distinzione tra i browser possiamo vederla nel seguente esempio.


var BE = Browser.Engine;  
if (!this.BE.webkit && !this.BE.gecko && !this.BE.trident){
  // firefox 3.6 bug
  BE = Browser.Engines;
}
if (BE.webkit) {
   alert ("webkit : Safari, Google Chrome, Konqueror";
}
if (BE.gecko) {
   alert ("gecko : Firefox, or any Mozilla Browser";
}
if (BE.trident) {
   alert ("trident : Internet Explorer";
}

Come potete vedere nell'esempio nel caso in cui si tratti di firefox 3.6, visto che l'oggetto Broser.Engine.gecko non è definito (undefined), è stato fixato con un workaround, utilizzando l'oggetto Browser.Engines.gecko per intercettare il browser.

Risolvere il problema 80048051 di msn

2010-03-17T09:58:00.003+01:00

Tra tutti gli errori derivanti dall'utilizzo di un OS Windows, ve ne segnalo uno in cui mi imbatto diverse volte a lavoro, specialmente quando interrompo la connessione di rete del mio pc e lo metto in standBy.
Nel momento in cui tento di riconnettermi a MSN ottengo un magnifico errore 80048051.

Per poterlo risolvere non è necessario come al solito chiudere e riaprire il programma, ma è necessario eseguire i seguenti passi :

- Aprire il broswer;
- Selezionare il menù "file", posto in alto a sinistra e vi si aprirà un ulteriore menù;
- Togliere la spunta (ovvero la v), dalla modalità "non in linea".

Alla prossima!!

FileUtils : funzionalità aggiuntive per la gestione dei files in Java

2010-02-26T13:01:00.012+01:00

Tramite questo post metto a disposizione l'implementazione di una classe di utilità che implementa alcune funzionalità per la gestione dei Files in Java.

In dettagli le funzionalità implementate sono le seguenti :

- Cancellare i files più vecchi di un certo numero di giorni da una cartella
- Creare una cartella nel caso in cui non esista
- Recuperare l'elenco dei files da una cartella ordinandoli per data crescente / decrescente.

Il codice qui di seguito :

package it.fritzzz.utils;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/***
 * Classe di utilità per la gestione dei files
 * @author a.franzi
 *
 */
public class FileUtils {
 
 /***
  * Ordina e restituisce i files per data di ultima modifica
  * @param directory : directory su cui eseguire il list del files
  * @param asc  : boolean (true = dal più lontano al più recente ; false = il contrario)
  * @return   : List di nomi files
  */
 public static List listFilesOfDirOrderByLastModifiedDate(final File directory,boolean asc){
  if (directory!=null && directory.isDirectory()) {
   String[] children = directory.list();
   if (children!=null && children.length>0){
    List childList = Arrays.asList(children);
    Collections.sort(childList,new Comparator() {
     
     public int compare(Object o1, Object o2) {
      if (o1 !=null && o2 !=null){
       File file1 = new File(directory, (String)o1);
       File file2 = new File(directory, (String)o2);
       
       if (file1.lastModified()==file2.lastModified()){
        return 0;
       }else if (file1.lastModified()>file2.lastModified()){
        return 1;
       }else if (file1.lastModified()<file2.lastModified()){
        return -1;
       }
      }
      return 0;
     }
    });
    return childList;
   }
  }
  return null;
 }
 

 /***
  * Metodo per rimuovere i files troppo vecchi da una determinata cartella
  * @param folderName : nome della cartella
  * @param numberOfDays : numero di giorni di tolleranza
  * @return    : boolean true se tutto è andato a buon fine
  */
 public static boolean removeTooOldFilesFromDir(String folderName, int numberOfDays){
  boolean ok = true;
  
  try{
   File dir = new File(folderName);
      
   if (dir.isDirectory()){
    File[] filesIntoDir = dir.listFiles();
    if (filesIntoDir!=null && filesIntoDir.length> 0){
     for (int i = 0 ; i < filesIntoDir.length; i++){
      if (filesIntoDir[i].isFile()){
       long lastUpdateOfFile = filesIntoDir[i].lastModified();
       Calendar cal = Calendar.getInstance();
       cal.setTimeInMillis(lastUpdateOfFile);
       Calendar today = Calendar.getInstance();
       today.add(Calendar.DAY_OF_YEAR, -numberOfDays);
       if (cal.before(today)){
        boolean currDelete = filesIntoDir[i].delete();
        if (!currDelete){
         System.out.println("Problem removing too old file : "+filesIntoDir[i].getAbsolutePath());
         ok = false;
        }else{
         System.out.println("Removed too old file : "+filesIntoDir[i].getAbsolutePath());
        }
       }
      }
     }
    }else{
     throw new IOException("nessun file presente nella cartella : "+folderName);
    }
    
   }else{
    throw new IOException("il path : "+folderName+" non è una directory");
   }
  }catch(IOException ex){
   System.out.println("Eccezione : "+ex.getMessage());
   ok = false;
  }


  return ok;
 }
 
 /***
  * Metodo per creare una cartella nel caso non esiste gia'
  * @param path : path
  * @return  : boolean
  */
 public static boolean createFolderIfNotExits(String path){
  File folder = new File(path);
  if (!folder.exists()){
   return folder.mkdirs();
  }else{
   System.out.println("la cartella : "+path+" esiste gia'");   
  }
  return false;
 }
}

ORACLE : Visualizzare lista di job in esecuzione

2010-02-22T10:54:00.004+01:00

Per poter visualizzare l'elenco dei job in esecuzione la query da eseguire è la seguente :

SELECT r.sid,r.job,r.this_date,r.this_sec,SUBSTR(what,1,40),total_time
FROM dba_jobs_running r,dba_jobs j
WHERE r.job = j.job

Eseguire il redirect degli output di un batch in un file di log su Windows

2010-02-19T11:17:00.005+01:00

Qualche semplice suggerimento per eseguire il redirect degli output dell'esecuzione di un file batch su windows.

E' necessario sapere che ci sono 2 livelli di output in maniera analoga ai sistemi Linux/Unix, il primo livello è lo STANDARD OUTPUT mentre il secondo livello è lo STANDARD ERROR.
Per cui le applicazioni ridirezionano gli output su questi 2 livelli a seconda delle esigenze.

Come è possibile salvare gli output dell'esecuzione di un batch?

Per poter eseguire delle prove creare con blocco note un nuovo di nome "test.bat" e copiare al suo interno i seguenti comandi :


@ECHO OFF
ECHO This text goes to Standard Output
ECHO This text goes to Standard Error 1>&2

Eseguendo il file "test.bat" da riga di comando (Start->Esegui..->cmd) otterremo il seguente risultato :

C:\>test.bat
This text goes to Standard Output
This text goes to Standard Error

REDIRECT DEGLI STANDARD OUTPUT SU FILE DI LOG

Eseguendo il comando "test.bat > logFile.log" otterremo il seguente risultato :

C:\>test.bat > logFile.log
This text goes to Standard Error

nel file di log logFile.log il contenuto sarà il seguente :

This text goes to Standard Output

REDIRECT DEGLI STANDARD ERORR SU FILE DI LOG

Eseguendo il comando "test.bat 2> logFile.log" otterremo il seguente risultato :

C:\>test.bat 2> logFile.log
This text goes to Standard Output

nel file di log logFile.log il contenuto sarà il seguente :

This text goes to Standard Error

REDIRECT DI TUTTI GLI OUTPUT SU UN UNICO FILE DI LOG

Eseguendo il comando "test.bat > logFile.log 2>&1" otterremo il seguente risultato :

C:\>test.bat > logFile.log 2>&1

nel file di log logFile.log il contenuto sarà il seguente :

This text goes to Standard Output
This text goes to Standard Error

N.B : è possibile loggare separatamente errori e output su 2 files differenti con il comando "test.bat > logFile.log 2> logFile.2.log"

E' possibile anche evitare che errori o output non siano visualizzati nè loggati. Nel seguente esempio verranno visualizzati solo gli errori tramite il comando "test.bat > NUL"

C:\>test.bat > NUL
This text goes to Standard Error

Usare JDBC per connettersi a Mysql da Java

2010-02-14T15:15:00.016+01:00

Introduzione
Lo scopo di questo tutorial è quello di eseguire i seguenti passi :
- Scaricare e installare un database MySQL
- Preparare il database per essere usato tramite i JDBC
- Scrivere e testare la nostra prima applicazione che usa i JDBC

Che cosa è JDBC ?
JDBC (Java DataBase Connectivity), è un connettore per database che consente l'accesso alle basi di dati da qualsiasi programma scritto con il linguaggio di programmazione Java, indipendentemente dal tipo di DBMS utilizzato. È costituita da una API, raggruppata nel package java.sql, che serve ai client per connettersi a un database. Fornisce metodi per interrogare e modificare i dati. È orientata ai database relazionali ed è Object Oriented. La piattaforma Java 2 Standard Edition contiene le API JDBC, insieme all'implementazione di un bridge JDBC-ODBC, che permette di connettersi a database relazionali che supportino ODBC. Questo driver è in codice nativo e non in Java.

Per poter utilizzare MySQL dalle vostre applicazioni Java è necessario scaricare il Connector/J dal seguente link.

Cosa è MySQL ?
MySQL è un Relational database management system (RDBMS), composto da un client con interfaccia a caratteri e un server, entrambi disponibili sia per sistemi Unix come GNU/Linux che per Windows, anche se prevale un suo utilizzo in ambito Unix.
Dal 1996 supporta la maggior parte della sintassi SQL e si prevede in futuro il pieno rispetto dello standard ANSI. Possiede delle interfacce per diversi linguaggi, compreso un driver ODBC, due driver Java e un driver per Mono e .NET.

Per poter installare MySQL è necessario scaricare il pacchetto adatto al vostro Sistema Operativo dal seguente link.

Adesso abbiamo tutto il necessario per poter utilizzare MySQL all' interno della nostra applicazione java.

CONFIGURARE TOMCAT e MYSQL per il recupero della connessione

Prima di procedere, è necessario copiare il Driver JDBC (Connector) nella cartella : $CATALINA_HOME/lib.

In secondo luogo nel caso si tratti di un applicazione WEB è possibile definire un datasource nel file di configurazione del server context.xml:

<Resource name="jdbc/TestDB" auth="Container" type="javax.sql.DataSource"
maxActive="100" maxIdle="30" maxWait="10000"
username="javauser" password="javadude" driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/javatest?autoReconnect=true"/>

Adesso tramite l'applicazione ed in particolare con il seguente pezzo di codice sarà possibile recuperare una connessione :

/***
 * Classe di utilità per gestione connessioni
 * @author alessandrofranzi
 *
 */
public class DBAccess {
 private static Logger logger = Logger.getRootLogger();
 
 public DBAccess() {
 }
 
 /***
  * Recupera la connessione
  * @return : connessione
  * @throws DatabaseException : eccezione personalizzata
  */
 public static Connection getConnection() throws DatabaseException{
  try {
    InitialContext ic = new InitialContext();
    DataSource ds = (DataSource) ic.lookup("java:comp/env/jdbc/TestDB");
    return ds.getConnection();
  } catch (NamingException e){
   System.out.println("Eccezione : "+e.getMessage());
  } catch (SQLException e){
   System.out.println("Eccezione : "+e.getMessage());
  } catch (Exception e){
   System.out.println("Eccezione : "+e.getMessage());
  }
 }
}

Eliminare le notifiche Buzz dalle mail di Gmail

2010-02-11T13:27:00.015+01:00

Nel caso in cui non abbiate abbastanza tempo/voglia/banda per gestire la miriade di notifiche che vi arrivano da qualsiasi social network e vi siete spaventati dal numero di notifiche ricevute a causa del nuovo Buzz non preoccupatepi, è semplice non visualizzare le notifiche nella vostra "inbox".

Ciascuna notifica di Buzz automaticamente soddisfa la query label:buzz, per cui è necessario solamente settare un quick filter per mantenere queste notifiche fuori dalla inbox.

Filtrare le notifiche Buzz dalla inbox

1. Cliccare sul pulsante "Create a Filter", accanto alla search box

2. Quindi, nella casella di testo "Has the word" nella finestra dei criteri inserire la stringa "label:buzz". Si può anche testare la ricerca per essere sicuri che vengano matchate le giuste mail.
Cliccare il pulsante "Next";
A questo punto si aprirà una finestra di avviso, cliccate su OK.

3. Infine, selezionare la checkbox corrispondente a "Skip the Inbox" e quindi clicca sul pulsante "Create Filter".
E' possibile opzionalmente aggiungere una label alle notifiche in maniera tale da raggruppare le notifiche in un altra cartella.

Disabilitare Buzz completamente

Altrimenti (anche se lo dico con rammarico, essendo un sostenitore delle GoogleApps), è possibile disattivare completamente Buzz mediante il link nella parte basse della finestra di Gmail :

Copiare il path di un file su Mac Os X Snow Leopard tramite il finder

2010-02-08T22:26:00.001+01:00

Precedentemente su questo Blog (link) avevo pubblicato un post per aggiungere funzionalità al finder di Mac Os X Leopard mediante automator.
In particolare era stato implementato uno script Applescript mediante il cui era possibile aprire nella finestra contestuale dal Finder un menu per poter recuperare il path di uno o più files.

Mi è stato fatto notare che ci sono stati dei cambiamenti in Snow Leopard per cui ho adattato lo script al nuovo sistema operativo.

Ho deciso quindi di implementare una nuova versione dello script. Anzi 2 nuove versioni da usare in 2 modalità alternative.
METODO 1 - MENU CONTESTUALE NEL FINDER
I passi da eseguire sono pochi e semplici, cercherò di rendere la cosa il meno possibile complessa con l'ausilio di opportune immagini.

1. Aprire l'applicazione AUTOMATOR (applicazione davvero utile, potete trovare maggiori informazioni al link) e selezionare come tipo di progetto "Servizio".

2. Nei menù a tendina presenti nella parte centrale della finestra dovrete scegliere rispettivamente le voci : "documenti e cartelle" e "Finder.app"

3. Nel menà alla sinistra della vostra pagina dovrete scegliere "Utility" e "Esegui Applescript".

4. Dovrete copiare e incollare questo pezzo di codice all'interno dell' opportuno riquadro, come in figura :

(* 
 author : Franzi Alessandro 
*)
on run {input, parameters}
 
 set sel to input
 if sel is {} then
  display dialog "Devi selezionare almeno un file prima" buttons {"Cancel"} default button "Cancel" giving up after 15
  return {}
 end if
 
 -- se sono state selezionate piu voci
 set baseList to {}
 repeat with selItem in sel
  -- Recupero la corrente
  set lastItem to POSIX path of (selItem as text)
  -- Inserisco in lista
  set baseList to baseList & lastItem
 end repeat
 
 -- recupero le directory se piu di una
 set pathList to my baseList
 
 
 if pathList is {} then
 else
  set scelte to (choose from list pathList with prompt "Path:" with title "Show Path" with multiple selections allowed)
  
  if scelte is {} then
  else
   set myString to ""
   --set the clipboard to selected
   repeat with theItem in scelte
    set myString to theItem & "
" & myString
   end repeat
   --set the clipboard to selected
   try
    
    set the clipboard to myString
   on error
    display dialog "Problemi"
   end try
  end if
  
 end if
end run

5. Scegliere di Salvare il file e inserire il nome con cui volete registrare il servizio (stesso nome con cui lo vedrete nel menu contestuale nel vostro Finder)

6. Adesso utilizzando il finder potrete accedere alla nuova funzionalità

METODO 2 - BARRA CONTESTUALE MAC OS X

Il seguente metodo consiste semplicemente nell' aggiungere nella barra di Mac Os X il pulsante per accedere alla funzionalità relative agli AppleScript del vostro sistema. I passi sono semplici come nel caso precedente, anche lo script cambia, visto che il contesto in cui viene utilizzato è diverso. Naturalmente l'utilizzo è lo stesso, per cui tramite il finder potrete selezionare i files e tramite l'icona accedere alla funzionalità.

1. Lanciare l'applicazione "AppleScript Editor", entrare nelle preferenze ed abilitare l'icona per gli script nella barra di Mac Os X :

(Come potete vedere la seconda icona in alto da sinistra è quella di applescript).

2. Tramite automator salvare il seguente codice in un file di script :

(* 
 author : Franzi Alessandro 
*)

set debug to true

global windowTitle
set windowTitle to "Show Path"

on findPath()
end findPath

-- Restituisce la lista dei path selezionati 
on getPathList(sel)
 if sel is {} then
  display dialog "Devi selezionare almeno un file prima" buttons {"Cancel"} default button "Cancel" giving up after 15 with title windowTitle
  return {}
 end if
 
 -- se sono state selezionate piu voci
 set baseList to {}
 repeat with selItem in sel
  -- Recupero la corrente
  set lastItem to POSIX path of (selItem as text)
  -- Inserisco in lista
  set baseList to baseList & lastItem
 end repeat
 return baseList
end getPathList

on getSelected(selected)
 if selected is {} then
 else
  set myString to ""
  --set the clipboard to selected
  repeat with theItem in selected
   set myString to theItem & "
" & myString
  end repeat
  --set the clipboard to selected
  try
   
   set the clipboard to myString
  on error
   display dialog "Problemi"
  end try
 end if
end getSelected

tell application "Finder"
 
 -- recupero le directory se piu di una
 set pathList to my getPathList(selection)
 
 -- se non sono i debug mostro una dialog
 --if debug then display dialog cmd with title windowTitle
 
 if pathList is {} then
 else
  set scelte to (choose from list pathList with prompt "Path:" with title windowTitle with multiple selections allowed)
  
  set return to my getSelected(scelte)
  
 end if
 
end tell

3. Copiare i files degli script nella cartella dove essi verranno recuperati. Cliccare sull'icona appena aggiunta, navigare il menù "apri la cartella Script", dopodichè "Apri la cartella script Finder" (scegliendo in quale cartella copiare i files potrete usare gli script a livello locale sull'applicazione, altrimenti a livello globale su tutto il sistema operativo)

4. Adesso accedendo mediante l'icona nella barra contestuale di Mac Os X potrete usare lo script che ai fini pratici analizzeremo tra un pò.

COME FUNZIONA

Il funzionamento è semplice, è possibile selezionare uno o più files di cui si intende visualizzare il percorso completo. Dopodichè mediante il menù contestuale o la barra contestuale richiamare lo script appena salvato.

In questa finestra, è possibile selezionare una o più voci (mediante il tasto ctrl + click è possibile selezionarne più di una) dopodichè premendo sul tasto OK si ha la possibilità di copiare nella clipboard il percorso dei vostri files.

Spero che questo strumento vi sia d'aiuto, tendo a ribadire che è davvero strano che la Apple non abbia implementato in maniera nativa questo strumento, io lo trovo davvero comodo.
Alla prossima...Stay Tuned!!

Da ArrayList a vettore in Java

2009-09-01T17:18:00.000+02:00

Mi capita spessisimo di dover integrare componenti scritte da me con vecchie componenti che utilizzano ancora semplici vettori.
Personalmente tendo ad usare spessissimo gli ArrayList, ma mi capita altrettanto spesso di dimenticare come convertire gli stessi in vettori.
Ecco come si fà :

(MyClass[]) mioArrayList.toArray(new MyClass[0])

Nel caso volessimo avere almeno un elemento per il vettore generato la sinstassi sarebbe la seguente :

(MyClass[]) mioArrayList.toArray(new MyClass[1])

Nascondere banner pubblicitario su Netsons

2009-08-30T16:27:00.000+02:00

Da poco tempo Netsons ha introdotto una nuova policy per quanto riguarda l' hosting gratuito e cioè quella di inserire nella vostra pagina un banner pubblicitario fastidiiosissimo.

In pochissimi passi vi spiego come evitare di mostrare il banner, ricordandovi che è illegale in quanto al momento della firma del vostro contratto avete accettato di mostrare eventuali pubblicità aggiunte.

Innanzitutto è necessario creare un file .html o .php da includere nel template del vostro sito oppure nella pagina in cui non intendete visualizzare eventuale pubblicità.
Nel mio caso la pagina l' ho chiamata deleteBanner.php

Guardiamo il codice all'interno della pagina :

<html>
 <script>
  function addLoadEventToHideBanner(func) {
    var oldonload = window.onload;
    if (typeof window.onload != 'function') {
      window.onload = func;
    } else {
      window.onload = function() {
      if (oldonload) {
        oldonload();
      }
      func();
      }
    }
  }
addLoadEventToHideBanner( function () {
 var banner = document.getElementById('frameBanner');
 if (banner){
  var divsInsideBanner = banner.getElementsByTagName('div');
  for(i=0; i < divsInsideBanner.length; i++){
   var functionClose = divsInsideBanner[i].onclick;
   functionClose.call(divsInsideBanner[i]);
  } 
 }
}); 
 </script>
</html>

Dopo aver creato questa pagina, è necessario includerla ad esempio nel vostro template. In questo caso copiare deleteBanner.php nella stessa cartella del template e modificare l'ultimo aggiungendo la seguente riga:

<?php
require('./deleteBanner.php');
?>

Eseguire print screen con Mac Os X

2009-07-25T09:51:00.000+02:00

Quando un utente windows passa ad un sistema più semplice e completo come Mac OS X a volte si trova di fronte all' enigma di come si svolgano alcuni task nel nuovo OS.

Uno dei task che oggi andremo ad analizzare è quello della print screen. Sulla tastiera di un Mac come noterete non esiste il pulsante per eseguire la print screen, ma vi assicuro che tale funzionalità è implementata e nauturalmente in un modo molto più che efficiente.

Analizziamo 3 modalità di print screen disponibili :

Schermo intero
Questa è la tipologia di printScreen presente su windows, mediante cui si salva l'intero contenuto del vostro monitor in un determinato moemento. Per fare questo è necessario visualizzare ciò che si intende ottenere nella print screen e premere i seguenti tasti :
Apple key ⌘ + Shift + 3
In questo modo sul vostro desktop comparirà una nuova immagine contenente l'immagine appena stampata. La differenza da windows è che non dovrete usare paint o qualsiasi altro programma di grafica per incollare la print screen e salvarla, ma il sistema farà tutto in automatico per voi.

Catturare una determinata porzione di schermo
Per poter eseguire questa modalità è necessario premere i seguenti tasti:
Apple key ⌘ + Shift + 4
Dopodichè noterete che il vostro mouse si sarà trasformato in un puntatore con un +, eseguendo il drag con il mouse potrete selezionare la porzione di schermo da visualizzare sulla print screen.

Catturare una particolare finestra applicativa
I primi passi per l'esecuzione di questa modalità sono praticamente identici al punto precedente. Quindi è necessario premere i seguenti tasti :
Apple key ⌘ + Shift + 4
Quando il cursore si sarà trasformato in un puntatore a forma di +, è necessario premere la barra spaziatrice, in questo modo il puntatore si sarà trasformato in una macchina fotografica e sul mouseover delle finestre, esse verranno colorate in maniera differente. Tramite il click sarà possibile salvare l'immagine sul desktop in maniera analoga alle modalità analizzate precedentemente.

Spero che questo articolo vi sia stato utile. Alla prossima.

MegaGo, scaricare utilizzando account premium per Megavideo, Megaupload e Rapidshare.

2009-07-25T09:41:00.000+02:00

Non volete spendere soldi per acquistare un account premium su Rapidshrare, Megaupload e Megavideo?
Eccovi una delle tante soluzioni disponibili, un generatore di account premium per questi due siti di hosting file che si chiama MegaGo.

MegaGo ha la particolarità di essere un generatore valido per più siti di hosting, la maggior parte infatti sono validi o solo per Megavideo o per Rapidshare, in alcuni casi per tutti e due ma pochissimi sono quelli che comprendono anche Megaupload.
Ci sono delle limitazioni per quando riguarda i file che si possono scaricare, per Megavideo e Megaupload non si possono prelevare file di dimensione maggiore a 900MB mentre per Rapidshare di 200MB.

Il link generato con MegaGo rimarrà valido per 120 minuti dopo di che verrà cancellato.

Richieste HTTP GET, POST, REST con Android

2009-06-22T23:14:00.000+02:00

Dopo il tutorial su cos'è rest ecco un' implementazione per poter utilizzare REST sulla piattaforma Android.

In particolare ciò che ho creato è una classe di utilità in cui sono presenti una serie di metodi utili per l'esecuzionedi richieste di tipo GET e POST ed un wrapper mediante il quale è possibile eseguire una chiamata REST modellata in base al tipo di method che gli si passa in input.

public class RestUtils {
 private final static String METHOD_POST = "post";
 private final static String METHOD_GET= "get";
 private final static String TAG= "RestUtils";
 
 /***
  * Esegue una richiesta REST
  * 
  * @param host   : hostname
  * @param method  : methodo (GET,POST supportati per ora)
  * @param path   : percorso
  * @param parameters : parametri
  * @return    : Stringa contenente la response
  * @throws RestRequestException : Eccezione personalizzata
  */
 public static String doRESTRequest (String host,  String method, String path, Map<String,String> parameters) 
  throws RestRequestException{
  
  return doRESTRequest(host, "80", method, path, parameters);
 }
 
 /***
  * Esegue una richiesta REST
  * 
  * @param host   : hostname
  * @param port   : porta
  * @param method  : methodo (GET,POST supportati per ora)
  * @param path   : percorso
  * @param parameters : parametri
  * @return    : Stringa contenente la response
  * @throws RestRequestException : Eccezione personalizzata
  */
 public static String doRESTRequest (String host, String port, String method, String path, Map<String,String> parameters) 
  throws RestRequestException{
  
  String returnString = null;
  try{
    
   String url = host+":"+port+path;
   Log.i(TAG,METHOD_GET+" Request - URL : "+url );
   
   if (METHOD_GET.equalsIgnoreCase(method)){
    returnString = doGETRequest(url,parameters); 
   }else if (METHOD_POST.equalsIgnoreCase(method)){
    returnString = doPOSTRequest(url, parameters);
   }
  }catch(GetRequestException e){
   throw new RestRequestException(e.getMessage());  
  }catch(PostRequestException e){
   throw new RestRequestException(e.getMessage());
  }
    
  return returnString;
  
 }
 
 /***
  * Metodo per eseguire una request di tipo GET
  * @param url : url della request
  * @return  : stringa contenente la response
  * @throws GetRequestException : Eccezione modellata
  */
 public static String doGETRequest(String url,Map<String, String> parameters) throws GetRequestException{
  String paramStr = composeParametersForGetRequest(parameters);
  
  if (paramStr!=null && paramStr.length() > 0 ) url = url +"?"+paramStr;
  String websiteData = null;
  
  try {
   Log.i(TAG,"GetRequest - url : "+url);
   DefaultHttpClient client = new DefaultHttpClient();
   URI uri = new URI(url);
   HttpGet method = new HttpGet(uri);
   HttpResponse res = client.execute(method);
   InputStream data = res.getEntity().getContent();
   websiteData = parseISToString(data);
  } catch (ClientProtocolException e) {
   throw new GetRequestException(e.getMessage());
  } catch (IOException e) {
   throw new GetRequestException(e.getMessage());
  } catch (URISyntaxException e) {
   throw new GetRequestException(e.getMessage());
  }finally{
   Log.i(TAG,"GetRequest - Request & Response completed");
  }
  return websiteData;
 }
 
 public static String doPOSTRequest(String url,Map<String, String> parameters) 
  throws PostRequestException{
  
  String returnString = null;
     // Creo un nuovo HttpClient e l'Header del post
     HttpClient httpclient = new DefaultHttpClient();
     HttpPost httppost = new HttpPost(url);
     httppost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded");

     try {
         // aggiungo i dati alla richiesta
         List<NameValuePair> nameValuePairs = composeParametersForPostRequest(parameters);
         httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));

         // Eseguo la richiesta HTTP
         HttpResponse response = httpclient.execute(httppost);
         if (response.getStatusLine().getStatusCode() == 200) { 
          returnString = EntityUtils.toString(response.getEntity()); 
                response = null; 
                 
         }
     } catch (ClientProtocolException e) {
      throw new PostRequestException(e.getMessage());
     } catch (IOException e) {
      throw new PostRequestException(e.getMessage());
     }
     
     return returnString;
 
 }
 
 public static List<NameValuePair> composeParametersForPostRequest(Map<String,String> parameters){
  
  List<String> chiavi = new ArrayList<String>(parameters.keySet());
  List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
  
  for (int i = 0 ; i < chiavi.size(); i++){
   String chiave = chiavi.get(i);
   nameValuePairs.add(new BasicNameValuePair(chiave, parameters.get(chiave)));
  }
  
  return nameValuePairs;
 }
 
 /***
  * Metodo per comporre la parte di URL relativa ai parametri
  * @param parameters : mappa di parametri
  * @return    : Stringa contenente i parametri concatenati
  */
 public static String composeParametersForGetRequest(Map<String, String> parameters){
  String paramStr = "";
  List<String> chiavi = new ArrayList<String>(parameters.keySet());
  
  for (int i = 0 ; i < chiavi.size(); i++){
   String chiave = chiavi.get(i);
   paramStr += chiave+"=";  
   paramStr += URLEncoder.encode(parameters.get(chiave));  
   paramStr += "&";  
  }
  return paramStr;
 }
}

Innanzitutto noterete che mancano alcune componenti per cui non potrete compilare questa classe:
- Metodi per la conversione da Stringa ad InputStream e viceversa che potrete trovare su questo post.
- Eccezioni personalizzate...potete ricrearvele voi, l'importante è che estandano Exception.

Adesso analizziamo i metodi :
- doRESTRequest : ci sono 2 overload utilizzabili uno in cui è possibile utilizzare una porta diversa da quella di default (80). Tramite questo metodo è possibile eseguire qualsiasi tipo di richiesta REST in base al parametro method che può essere "get" o "post". Gli altri parametri sono facilmente intuibili e troverete un esempio più avanti.
- doGETRequest : è un metodo che dato un url ed una mappa di parametri esegue una richiesta di tipo GET e restituisce una stringa contenente la response.
- doPOSTRequest : è un metodo che dato un url e una mappa di parametri esegue una richiesta di tipo POST e restituisce una stringa contenente la response.
- composeParametersForPostRequest : metodo per comporre i parametri in maniera adeguata per poter eseguire una richiesta di tipo POST.
- composeParametersForGetRequest : metodo per comporre i parametri in maniera adeguata per completare l'url per una richiesta di tipo GET.

Vediamo un esempio di utilizzo della classe di utilità per una richiesta di tipo POST. L'esempio utilizza le API REST di Yahoo per eseguire una ricerca :

Map<String,String> paramz = new HashMap<String,String>();
        paramz.put("appid", "YahooDemo");
        paramz.put("query", "umbrella");
        paramz.put("results", "10");
        try {
   String retString = RestUtils.doRESTRequest("http://api.search.yahoo.com", "POST", "/WebSearchService/V1/webSearch", paramz);
   Log.i(TAG,"Return : "+retString);
        } catch (RestRequestException e) {
   Log.e(TAG,"Eccezione : ",e);
  }

Spero che questo post vi sia stato di aiuto.
Accetto domande e proponimenti a riguardo.

String ed InputStream in Java

2009-06-22T21:53:00.001+02:00

Premetto che non sono dotato di ottima memoria, quindi mi ritrovo ogni volta a riscrivere funzioni di conversione per ogni genere di Type in ogni genere di linguaggio di programmazione. Naturalmente ogni volta dimentico di come si convertano i diversi type... un esempio di conversione che avrò implementato milioni di volte ma che ogni volta devo riscrivere da zero è quella da Stringa ad InputStream e viceversa.

Per cui per mia comodità e per vostra necessità ecco 2 metodi con i quali potrete convertire questi due tipi di dati Java.

Da InputStream a String

public static String parseISToString(InputStream is){
  java.io.DataInputStream din = new java.io.DataInputStream(is);
  StringBuffer sb = new StringBuffer();
  try{
   String line = null;
   while((line=din.readLine()) != null){
    sb.append(line+"\n");
   }
  }catch(Exception ex){
   ex.getMessage();
  }finally{
   try{
    is.close();
   }catch(Exception ex){}
  }
  return sb.toString();
 }

Da String a InputStream

public java.io.InputStream parseStringToIS(String str){
  if(str==null) return null;
  str = str.trim();
  java.io.InputStream in = null;
  try{
   in = new java.io.ByteArrayInputStream(str.getBytes("UTF-8"));
  }catch(Exception ex){}
  return in;      
 }

Spero che questo breve post vi sia d'aiuto spessissime volte.
Alla prossima

Tutorial : Cos' è REST ?

2009-06-20T17:04:00.000+02:00

Cos'è REST

REST stà per Representational State Transfer.
Esso si basa su un protocollo di comunicazione stateless, client-server, chacheable e si appoggia sul protocollo HTTP.

REST è uno stile arichitetturale per il disegno di applicazioni di rete. L'idea è quella di usare una comunicazione tra macchine basata su richieste HTTP anzichè utilizzare meccanismi come CORBA, RPC o SOAP.

In molti casi, il World Wide Web, basato sull' HTTP, può essere visto come un' architettura REST-based.
Le applicazioni basate su REST dette anche RESTful usano richieste HTTP per inviare dati (creare e/o aggiornare), leggere dati (eseguire query), e cancellare dari.
Quindi REST usa richieste HTTP per tutti e 4 le operazioni di CRUD (Create/Read/Update/Delete).

REST è un alternativa leggere al meccanismo di RPC (Remote Procedure Calls) e quella dei Web Services (SOAP, WSDL, ..).
Dopo vedremo quanto è semplice utilizzare REST.

Malgrado la sua semplicità, REST è permettamente completo, non c'è nulla che si possa fare tramite un Web Service che non si possa fare mediante un'architettura RESTful.
REST non è uno "STANDARD", e mai lo sarà per la W3C.

REST visto come un Web Service leggero

Come un approccio di programmazione, REST è un alternativa leggera i Web Services e ad RPC.
In maniera molto simile ai Web Services, un servizio REST è :
- Indipendente dalla piattaforma
- Indipendente dal linguaggio di programmazione
- Basato su un protocollo di comunicazione Standard (HTTP)
- Poichè usa la porta 80 (porta di default per traffico HTTP) non ha bisogno che ci siano particolari configurazioni del firewall

Per la sicurezza, i token di username/password sono spesso usati.
Per la crittografia, REST può basarsi su protocolli sicuri come HTTPS

Una cosa che non fà parte di un buon disegno di REST sono i cookies: Nell' acronimo di REST, "ST" stà per "State transfer", e quindi, in un buon design queste operazioni sono auto-contenute, e in ogni richiesta vanno trasferite tutte le informazioni (stato) di cui il server ha bisogno per completare la richiesta.

Quanto è semplice REST
Guardiamo un semplice Web Service come esempio : interrogare un applicazione per gli elenchi telefonici per richiedere i dettagli di un utente. Tutto ciò che abbiamo è l'ID dell'utente.

Usando un Web Service e SOAP, la richiesta assomiglierebbe alla seguente:

<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
 <soap:body pb="http://www.acme.com/phonebook">
  <pb:GetUserDetails>
   <pb:UserID>12345</pb:UserID>
  </pb:GetUserDetails>
 </soap:Body>
</soap:Envelope>

I dettagli non sono importanti, è solo un esempio.
L'intero xml verrà inviato usando una richista HTTP POST al server.
Il risultato sarà probabilmente un file XML, ma sarà incluso, come payload, dentro l'envelope della risposta SOAP.

E con Rest?
La query probabilmente assomiglierà alla seguente :

http://www.acme.com/phonebook/UserDetails/12345

Nota che questo non è il body della richiesta -- è solo un URL. Questo URL è inviato al server usando una semplice richiesta GET, e la risposta HTTP è il campo con i dati del risultato. Tale risposta non è inclusa all'interno di nulla, i dati saranno trasmessi in maniera tale da essere subito disponibili per un eventuale utilizzo.

E' semplice vedere perchè i Web Services sono spesso usati con librerie che creano la richiesta SOAP/HTTP e la inviano e quindi parsano la risposta SOAP.
Con REST, una semplice connessione di rete è ciò che ti serve. Puoi testare le API direttamente usando il browser.

Comunque le librerie REST esistono (per semplificare le cose), ne discuteremo dopo.
Da notare come nell'URL il metodo non è chiamato "GetUserDetails" ma semplicemente "UserDetails". E' una convenzione comune usata nel disegno di REST di usare nomi anzichè verbi per denotare semplici risorse.

Simpatica Similutudine
Una similitudine simpatica tra REST e SOAP è quella tra una lettera e una cartolina : con SOAP, devi usare una busta da lettera, con REST è una cartolina. La cartolina è più semplice da gestire. Tralaltro c'è una convenienza per quanto riguarda il fattore banda da utilizzare, in quanto i contenuti sono di gran lunga inferiori.

Richieste REST più complesse
La sezione precedente includeva un esempio semplice per una richiesta REST con un unico parametro.
REST può semplicemente gestire richieste più complesse che includono molti parametri.
In molti casi, si possono semplicemente utilizzare parametri GET nell'URL della richiesta HTTP.

Ad esempio:

http://www.acme.com/phonebook/UserDetails?firstName=John&lastName=Doe

Se si ha la necessità di passare parametri lunghi, o binari, è necessario utilizzare richieste HTTP di tipo POST ed includere i parametri nel body della richiesta POST.

Per regola, le richieste GET vengono utilizzare per query di sola lettura, esse non cambiano lo stato del server e dei suoi dati.
Per la creazione, aggiornamento, e cancellazione si usano richieste POST. (POST può anche essere usato per lettura nel caso in cui vengono inviati parametri più complessi).

In un modo, questa pagina web (così come altre) può essere vista offrendo servizi mediante API rest. E' possibile usare una richiesta GET per leggere i dati e una POST per postare un commento.

Mentre un servizio REST può uesare XML nelle sue risposte (come un modo di organizzare dati strutturati), le richieste REST raramente usano l'XML. Come mostrato prima, in molti casi, i parametri di richiesta sono semplici, e non c'è bisogno di utilizzare XML.

Un vantaggio di usare XML è la "safety" dei tipi. Comunque, in un sistema stateless come REST, devi solo verificare la validità del tuo input, XML o altro.

Risposta REST del server

Una risposta del server in REST è spesso un file XML. Per esempio :

<parts-list>
 <part id="3322">
  <name>ACME Boomerang</name>
  <desc>
   Used by Coyote in <i>Zoom at the Top</i>, 1962
  </desc>
  <price currency="usd" quantity="1">17.32</price>
  <uri>http://www.acme.com/parts/3322</uri>
 </part>
 <part id="783">
  <name>ACME Dehydrated Boulders</name>
  <desc>
   Used by Coyote in <i>Scrambled Aches</i>, 1957
  </desc>
  <price currency="usd" quantity="pack">19.95</price>
 <uri>http://www.acme.com/parts/783</uri>
 </part>
</parts-list>

Comunque, altri formati possono essere anche usati, diversamente dai servizi SOAP, REST non è obbligato ad utilizzare XML.
Possibili formati possono essere CVS (comma-separated values) e JSON (JavaScript Object Notation)

Ciascun formato ha i suoi vantaggi e svantaggi. XML è facilmente espandibile (i client possono ignorare campi sconosciuti) ed è type-safe, CSV è molto compatto e JSON è facilmente parsabile dai client Javascript (ed è facilmente parsabile anche in altri linguaggi).

Un opzione non è accettabile come formato di risposta REST, eccetto in casi molto specifici : HTML, o altri formati non sono facilmente processabili dai client. L'eccezione specifica è, sicuramente, quando il servizio REST è documentato per ritornare un documento human-readable (facilmente leggibile dall'uomo). Comunque guardando l'intero WWW come ritorno di un applicazione RESTful, troviamo che l'HTML è infatti il formato di risposta REST più comunemente usato.

Esempi Rest reali

Potete trovare esempi di API REST utilizzate da portali abbastanza noti:

- Twitter API
- Search API

In rete comunque, ne troverete un' infinità.

REST e Ajax
AJAX è una tecnica popolarissima per lo sviluppo web che permette alle pagine di essere interattive mediante il semplice utilizzo di Javascript.

In AJAX, le richieste sono inviate al server usando oggetti di tipo XMLHttpRequest. La risposta è usata dal Javascript che dinamicamente cambia la pagina corrente.

In molti casi, le applicazioni AJAX seguono i principi del disegno REST. Ciascuna XMLHttpRequest può essere vista come una richiesta ad un servizio REST, inviata tramite il metodo GET.
La risposta è spesso in JSON, un formato popolare di risposta per REST.

Per rendere le vostre applicazioni AJAX veramente RESTful, è necessario seguire gli standard di disegno per REST.
Troverete che molto di questo contribuirà ad un buon design.

Comunque in seguito analizzeremo meglio richieste eseguite mediante javascript e AJAX.

Componenti di un architettura REST

Le componenti chiave di un architettura REST sono le seguenti:

- Risorse, che sono dentificate mediante URL logici. Sia stato che funzionalità sono rappresentati usando risorse.
Gli URL logici implacano che le risorse sono universalmente indirizzabili da altre parti del sistema.
Risorse sono gli elementi chiave di un design RESTful, in opposizione ai "metodi" e "servizi" rispettivamente usati nell'RPC e nelle richieste SOAP dei servizi WEB.
- Un web di risorse, significa che una singola risorsa non dovrebbe essere eccessivamente largo e contenere troppi dettagli.
In qualsiasi momento rilevante, una risorsa dovrebbe contenere i link ad informazioni addizionali, così come in pagine Web.
- Il sistema è client-server, ma sicuramente una componente server può essere una componente client.
- Non ci sono connessioni agli stati, l'interazione è stateless. Ogni nuova richiesta può trasportare le informazioni richieste per poterla completare, e non deve contare sulle interazioni precedenti con lo stesso client.
- Le risorse devono essere cachable quando possibile con una data di scadenza. Il protocollo deve permettere al server di specificare esplicitamente quali risorse possono essere messe in chache e per quanto tempo.
Sin da quando l' HTTP è universalmente usato per il protocollo RET, gli header di controllo della cache dell' HTTP sono usati per questo scopo. I clients devono rispettare le specifiche di cache del server per ogni risorsa.
- I server Proxy possono essere usati come parte dell'architettura, per perfezionare le performance e la scalabilità. Ogni proxy HTTP standard può essere usato.

Da notare che l' applicazione può usare i servizi REST senza essere stats scritta per essere un architettura REST. Ad esempio una macchina non pragrammata per REST può accedere a servizi REST di terze parti.

Linee guida per il design di REST

Alcune semplici linee guida per il design di un architettura REST:

Non usare URL fisici. Un URL fisico punta a qualcosa di fisico, ad esempio un file XML:
"http://www.acme.com/inventory/product003.xml". Un URL logico non implica un file fisico : "http://www.acme.com/inventory/product/003".
Certo, tutto ciò che comunque ha estensione .xml potrebbe essere generato dinamicamente. Ma deve essere "umanamente visibile" che un URL è logico e non fisico.

Le Query non devono ritornare troppi dati. Se necessario, fornire un meccanismo di paging. Per esempio una richiesta di tipo GET che chiede ad esempio una "product list) deve restituire i primi n prodotti con i link al prossimo/precedente.
Pensare sempre al fatto che le risposte REST possono essere di qualsiasi tipo, è necessario essere sicuri che tutto sia ben documentato, e non cambiare il formato di output leggermente.

Ricordarsi, nel caso in cui l'output sia umanamente-leggibile, che i client snon sono utenti umani.
Se l'output è un XML, essere sicuri che il documento faccia riferimento ad uno schema o a un DTD.

ROA vs. SOA, REST vs. SOAP

ROA (REST Oriented Architecture) è solo un nome di fantasia per una SOA (Service Oriented Architecture) che usa servizi REST.

Il principale vantaggio di una SOA basata su SOAP riepetto a ROA è che ci sono tool di supporto più "maturi", comunque questo potrà variare nel tempo.
Un altro vantaggio della SOA include la tipatura Safe delle richieste XML (per le risposte, ROA può anch'essa utilizzare XML se gli sviluppatori lo desiderano).

Il vantaggio principale di ROA è la facilità nell' implementazione, agilità nel progetto, e l' approccio alleggerito nell'approccio alle cose. SOA e SOAP è per gente che sviluppa suite business ed è quello che troverete nel sistemi bancari e finanziari.
Viceversa quando c'è la necessità di qualcosa di più veloce, con buone performance e basso sovraccarico, è spesso più indicato utilizzare REST e la ROA.

Per esempio, quando viene spiegato il perchè si scelga REST anzichè SOAP da yahoo, la gente dice che REST ha poche barriere, è più semplice di SOAP, ed è sufficiente per i servizi che yahoo fornisce. Questo è vero non solo tra REST e SOAP, ma più in generale tra ROA e SOA.

Un altro vantaggio è dato dalla performance : con un supporto alla cache migliore, richieste e risposte più leggere, quindi un parsing delle risposte più leggero, REST permette di ridurre notevolmente il traffico.

Documentare i servizi REST : WSDL e WADL

Il WSDL, è uno standard W3C che definisce un linguaggio per la descrizione di servizi web. Esso è comunemente usato per descrivere i servizi offerti dal server SOAP. Mentre il WSDL è flessibile nell' opzione di bind dei servizi, esso non supporta originariamente operazioni HTTP come GET e POST. Sin dall' inizio invece i servizi REST usano altri verbi HTTP, come PUT e DELETE. Il WSDL è una scelta troppo povera per documentare i servizi REST.

Nella versione 2.0, i WSDL supportano tutti i verbi HTTP ed è ora considerato essere un metodo accettabile per la documentazione dei servizi REST.

La seconda alternativa è il WADL ( Web Application Description Language) adottata da Sun Microsystem.
così come REST, il WADL è leggero, semplice da capire e semplice da scrivere rispetto ai WSDL. In alcuni aspetti non è flessibile come il WSDL ma è sufficiente per ogni servizio REST ed è molto meno complesso.

Ecco un frammento di una specifica WADL, che descrive un servizio di "Item Search" di Amazon :

 <method name="GET" id="ItemSearch">
 <request>
  <param name="Service" style="query"
   fixed="AWSECommerceService"/>
  <param name="Version" style="query" fixed="2005-07-26"/>
  <param name="Operation" style="query" fixed="ItemSearch"/>
  <param name="SubscriptionId" style="query"
   type="xsd:string" required="true"/>
  <param name="SearchIndex" style="query"
   type="aws:SearchIndexType" required="true">
    <option value="Books"/>
    <option value="DVD"/>
    <option value="Music"/>
  </param>
  <param name="Keywords" style="query"
   type="aws:KeywordList" required="true"/>
  <param name="ResponseGroup" style="query"
   type="aws:ResponseGroupType" repeating="true">
    <option value="Small"/>
    <option value="Medium"/>
    <option value="Large"/>
    <option value="Images"/>
  </param>
 </request>
 <response>
  <representation mediaType="text/xml"
   element="aws:ItemSearchResponse"/>
 </response>
</method>

Come puoi vedere, il formato è molto più self-explanatory, ed arricchisce il REST con alcune aggiunte come la tipizzazione safety usando i tipi dell' Xml schema.

L' intero documento è lungo solo 10 righe in più di quello precedente (include i namespace dell' XML, importa le grammatiche degli schema, etc. ) e può essere trovato nelle specifiche WADL.

Usare REST con php

Richieste GET

Moderne versioni di PHP rendono insignificante la richiesta di pagine web : ogni funzione che accede ai file funziona in maniera analoga con gli URL. Così si può usare fopen, file_get_contents, o ogni altro tipo di comando eseguendo una richiesta GET. Ad esempio :

$url = "http://www.acme.com/products/3322";
$response = file_get_contents($url);
echo $response;

Ogni parametro passato a richieste GET deve essere encodato. Si possono encodare stringhe usando la funzione urlencode.

Richieste POST

In forte contrasto alla facilità con cui fare una richiesta GET, non c'è un modo semplice per farlo via POST in php.
E' necessario aprire una connessione con il server e manualmente inviare tutti gli headers HTTP. Qui c'è una semplice funzione che fà tutto il lavoro per ogni metodo HTTP :

function httpRequest($host, $port, $method, $path, $params) {
  // Params are a map from names to values
  $paramStr = "";
  foreach ($params as $name, $val) {
    $paramStr .= $name . "=";
    $paramStr .= urlencode($val);
    $paramStr .= "&";
  }

  // Assign defaults to $method and $port, if needed
  if (empty($method)) {
    $method = 'GET';
  }
  $method = strtoupper($method);
  if (empty($port)) {
    $port = 80; // Default HTTP port
  }

  // Create the connection
  $sock = fsockopen($host, $port);
  if ($method == "GET") {
    $path .= "?" . $data;
  }
  fputs($sock, "$method $path HTTP/1.1\r\n");
  fputs($sock, "Host: $host\r\n");
  fputs($sock, "Content-type: " .
               "application/x-www-form-urlencoded\r\n");
  if ($method == "POST") {
    fputs($sock, "Content-length: " . 
                 strlen($paramStr) . "\r\n");
  }
  fputs($sock, "Connection: close\r\n\r\n");
  if ($method == "POST") {
    fputs($sock, $paramStr);
  }

  // Buffer the result
  $result = "";
  while (!feof($sock)) {
    $result .= fgets($sock,1024);
  }

  fclose($sock);
  return $result;
}

Eseguire una richiesta POST usando questa funzione è semplice come :

$resp = httpRequest("www.acme.com",
    80, "POST", "/userDetails",
    array("firstName" => "John", "lastName" => "Doe"));

Un alternativa a questo approccio è usando il supporto ai CURL di PHP.

Usare REST con Java

Bisognerebbe partire con la spiegazione di come eseguire richieste mediante le classi base come HttpURLConnection, però ritengo sia molto più utile utilizzare le Apache Commons library ed in particolare i packages httpclient.

Richieste GET

String request = "http://api.search.yahoo.com/WebSearchService/V1/webSearch?appid=YahooDemo&query=umbrella&results=10";
HttpClient client = new HttpClient();
GetMethod method = new GetMethod(request);
// Send GET request
int statusCode = client.executeMethod(method);

In questo modo con qualche riga di codice eseguiamo una richiesta GET ed otteniamo lo statusCode del risultato della stessa.
Adesso vediamo come processare la risposta:

InputStream rstream = null;
rstream = method.getResponseBodyAsStream();
BufferedReader br = new BufferedReader(new InputStreamReader(rstream));
String line;
while ((line = br.readLine()) != null) {
 System.out.println(line);
}
br.close();

Naturalmente è possibile usare strumenti per eseguire il marshalling dell' xml...
Per questo stò preparando un tutorial.

Richieste POST

Le richeiste post sono usate dai browser web quando eseguono il submit di dati con le form HTML. Il content type di tipo "multipart/form-data" può essere usato per eseguire il submit di form che contengono files, dati non-ASCII e dati binary.
Per le richieste POST, costruiamo i dati POST separatamente dall' URL.

String request = "http://api.search.yahoo.com/WebSearchService/V1/webSearch";
HttpClient client = new HttpClient();
PostMethod method = new PostMethod(request);
// Add POST parameters
method.addParameter("appid","YahooDemo");
method.addParameter("query","umbrella");
method.addParameter("results","10");
// Send POST request
int statusCode = client.executeMethod(method);
InputStream rstream = null;    
// Get the response body
rstream = method.getResponseBodyAsStream();

Richieste POST con i socket

E' possibile anche eseguire le richieste post utilizzando i socket...Vediamo un esempio :

// Create POST data string
String postdata = "appid" + "=" + URLEncoder.encode("YahooDemo", "UTF-8");
postdata += "&" + "query" + "=" + URLEncoder.encode("umbrella", "UTF-8");
postdata += "&" + "results" + "=" + URLEncoder.encode("10", "UTF-8");
// Create a socket to the host
String hostname = "api.search.yahoo.com";
int port = 80;
InetAddress addr = InetAddress.getByName(hostname);
Socket socket = new Socket(addr, port);
// Send header
String path = "/WebSearchService/V1/webSearch";
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "UTF8"));
bw.write("POST " + path + " HTTP/1.0\r\n");
bw.write("Content-Length: " + postdata.length() + "\r\n");
bw.write("Content-Type: application/x-www-form-urlencoded\r\n");
bw.write("\r\n"); 
// Send POST data string
bw.write(postdata);
bw.flush();

La fonte dell'articolo in inglese potete trovarla al seguente link

Installare GIT su Mac Os x 10.5

2009-06-14T20:14:00.000+02:00

Cos' è GIT
Git è un progetto Open Souce ed in particolare è un sistema per il controllo del versioning distribuito.
Lo scopo di utilizzare GIT è quello di permettere la gestione di progetti di grandi o piccole dimensioni con velocità ed efficenza.
Ogni clonde di Git è un repository completo di una propria history ed un tracking delle revision completo, indipendente dagli accessi di rete su un sistema centrale.

Vediamo in pochi passi come configurare GIT sul tuo sistema Mac Os X 10.5

Il primo passo è quello di scaricare GnuPG dal link : ftp://ftp.gnupg.org/gcrypt/gnupg/gnupg-1.4.7.tar.bz2.
Dopo aver scaricato il pacchetto è necessario decomprimerlo ed installarlo con i seguenti comandi:


tar -xjvf gnupg-1.4.7.tar.bz2
cd gnupg-1.4.7
./configure
make
sudo make install
cd ..

Dopo aver installato GnuPG è necessario passare all'installazione di GetText che potrete trovare al link : http://mirrors.usc.edu/pub/gnu/gettext/gettext-0.17.tar.gz.
Dopo averlo scaricato è necessario decomprimere e installare anch'esso mediante i seguenti comandi:


tar xvf gettext-0.17.tar
cd gettext-0.17
./configure
make
sudo make install
cd ..

Dopo aver installato GetText passiamo al passo finale e quindi all'installazione di GIT.
E' possibile scaricare il pacchetto per l'installazione al link :http://kernel.org/pub/software/scm/git/git-1.5.5.tar.bz2.
Dopo averlo scaricato eseguiamo i seguenti comandi per l'installazione:


tar -xjvf git-1.5.5.tar.bz2
cd git-1.5.5
./configure
make
sudo make install
cd ..
curl  http://www.kernel.org/pub/software/scm/git/git-manpages-1.5.5.tar.bz2  \
sudo tar xj -C /usr/local/share/man

Dopodichè eseguire in cascata tutti questi comandi :


# you
git config --global user.name "Mr Man"
git config --global user.email "mr@man.com"

# colors

git config --global color.diff auto
git config --global color.status auto
git config --global color.branch auto
git config --global color.interactive auto


# shortcuts
git config --global alias.st status
git config --global alias.ci commit
git config --global alias.co checkout
git config --global alias.br branch

# if you ever have conflicts you can type git-mergetool
# to use Apple opendiff (FileMerge) for resolving conflicts
git config --global merge.tool opendiff
# Whenever we merge provide a summary of commits
git config --global merge.summary true

# globally ignore some cruft files
git config --global core.excludesfile ~/.gitignore
echo "*~" >~/.gitignore
echo ".DS_Store" >>~/.gitignore

# setup nice fonts on gitk
cat >~/.gitk <<\EOF
set mainfont {Monaco 10}
set textfont {Monaco 10}
set uifont {Monaco 10}
EOF

Dopo l'esecuzione di questi semplici passi il tuo MAC è configurato per poter usare GIT.

Anatomia di un applicazione Android

2009-06-08T13:41:00.000+02:00

Ci sono 4 blocchi fondamentali in un applicazione Android:

* Activity
* Intent Receiver
* Service
* Content Provider

Naturalmente la maggiorparte delle applicazioni non sviluppano tutti e 4 i blocchi, ma con una qualsiasi combinazione degli stessi.

Dopo aver deciso quali componenti sono necessari per la tua applicazione, è necessario elencarli in un file chiamato AndroidManifest.xml.

E' un file XML dove vengono dichiarate le componenti di un' applicazione e quali sono i relativi requisiti e capacità. Per poterne sapere di più è possibile guardare la documentazione relativa al file di manifest di Android.

Vediamo i 4 macro blocchi in dettaglio...

Activity
Le Activities sono le componenti più comuni presenti tra i 4 blocchi.
Un attività è di solito una schermata di un' applicazione.
Ogni attività è implementata in una singola classe che estende la classe base Activity.
La tua classe visualizzerà una User Interface composta da Views e risponderà a degli eventi.
La maggiorparte delle applicazioni sono composte da molteplici schermate.
Ad esempio un applicazione per l'invio di messaggi avrà una schermata in cui si avrà a disposizione l'elenco dei contatti a cui poter inviare il messaggio, una seconda scermata in cui si eseguirà la scrittura vera e propria del messaggio e schermate in cui modificare i setting o consultare la lista di messaggi in ingresso.

Ciascuna di queste schermate sarà implementata come un attività.
Muoversi su un altra schermata consisterà allo START di una nuova attività.
In alcuni casi un attività può restituire un valore all' attività precedente.

Quando viene aperta una nuova schermata, quella precedente viene messa in pausa ed inserita all'interno di un history stack.

L'utente potrà navigare indietro mediante questa history. Si può inoltra forzare l'eliminazione di una attitivà dall' history stack nel caso in cui non si ritenesse appropriata la relativa permanenza.
Android mantiene uno stack per ogni applicazione lanciata dalla schermata HOME.

Intent and Intent Filters
Android usa una classe speciale chiamata Intent per muoversi da una schermata all'altra.
Un intent descrive cosa vuole fare un applicazione. Le due parti più importanti della struttura dati di un intent sono le azioni e i dati su cui si basano.
Tipicalmente valori per le azioni sono MAIN (la pagina principale delle attività), VIEW, PICK, EDIT, etc.
I dati sono espressi come URI.
Per esempio, per visualizzare le informazioni di un contatto, si dovrà creare un intent con l'azione VIEW e i dati settati all'interno dell' URI che rappresentano la persona.

C'è una classe connessa chiamata IntentFilter.
Mentre un intent è effettivamente una richiesta di eseguire qualcosa, un intent filter è una descrizione di quali intents un attività è capace di gestire.
Un attività che è capace di visualizzare le informazioni di un contatto pubblicherà un IntentFilter che dice che essa conosce il modo di gestire l'azione VIEW che verrà applicata ai dati per rappresentare la persona. Le attività pubblicano i propri IntentFilters nel file AndroidManifest.xml.
Navigare da schermata a schermata è compiuto risolvendo gli intents.
Per navigare in avanti, un attività chiama il metodo startActivity(myIntent).
Il sistema cerca l'intent filter tra tutte le applicazioni installate e prende quello che ha il miglior match con myIntent.
La nuova activity verrà informata dell'intent, che causerà la propria esecuzione.
Il processo di risoluzione degli intent viene eseguito a run time quando la startActivity viene chiamata e questo offre 2 benefici:
* Le attività possono riusare funzionalità da altre componenti semplicemente eseguendo una richiesta mediante una Intent.
* Le attività possono essere rimpiazzare in ogni istante da un Activity con lo stesso IntentFilter.

Intent Receiver
Puoi usare un IntentReceiver quando desideri eseguire qualcosa nella tua applicazione in relazione ad un evento esterno. Per esempio, quando il telefono suona, oppure quando una rete è disponibile, oppure quando è mezzanotte. Gli intent receivers non visualizzano una UI, sebbene esse possano usare il NotificationManager per alertare l'utente che qualcosa di interessante stà succedendo.

Gli Intent receivers sono registrati sempre nel file AndroidManifest.xml, ma si possono registrare tramite il codice mediante l'uso dell'istruzione:

Context.registerReceiver();

La tua applicazione non deve essere in esecuzione per ricevere delle chiamate agli intent receivers.
Il sistema eseguirà la tua applicazione, se necessario, quando l'event receiver viene triggerato.

Le applicazioni possono anche inviare il proprio intent in broadcast alle altre applicazioni mediante l'istruzione:

 Context.broadcastIntent();

Service

Un Service è un codice che è in esecuzione come long-lived e viene eseguito senza una UI.
Un buon esempio è il media player che riproduce delle canzoni da una play list.
Mediante una schermata l'utente potrà scegliere i brani da inserire o eliminare dalla playlist. Ma l'utente vorrà anche uscire da questa gestione, in questo caso l'attività del player potrà eseguire un nuovo servizio usando l'istruzione :

Context.startService();

In questo modo il servizio sarà eseguito in background per poter continuare l'esecuzione della musica.
Il sistema quindi continuerà ad eseguire il servizio finchè esso avrà necessità di essere eseguito.
Nota che è possibile connettersi ad un servizio (e farlo partire se esso non è ancora in esecuzione) mediante il comando:

Context.bindService();

Quando si è connessi con un service, puoi comunicare con esso mediante una serie di interfaccie esposte dal servizio.

Content Provider

Le applicazioni possono immagazzinare i dati in files, in un database SQLite, o mediante qualsiasi altro meccanismo abbia senso utilizzare.
Un content provider, comunque, è utile nel caso si voglia che i dati della propria applicazione siano condivisi con altre applicazioni. Un content provider è una classe che implementa un set standard di metodi per permettere alle altre applicazioni di salvare o utilizzare i tipi di dati che sono gestiti dal content provider.

Spero che questo post sia stato utile...buon divertimento :|

Eseguire un backup completo del sistema Android

2009-05-15T11:38:00.000+02:00

Il "googleFonino" per quanto stupendo, potente, figo sia naturalmente permettendo l'installazione di applicazioni al di fuori del google Market è soggetto e sarà soggetto come qualsiasi altro dispositivo a problemi legati a software non affidabile.
In questo articolo descriverò brevemente come poter eseguire di tanto in tanto un backup del tuo telefonino in maniera tale da poterlo ripristinare con facilità ad uno stato sicuramente funzionante.

E' necessario innanzitutto far partire android in Recovery mode (HOME+pulsante di accensione) da spento.
Dopo questo primo passo è necessario eseguire un backup (ALT+B)
Nel caso ti interessasse avere maggiori informazioni sullà modalità di recoveri puoi istruirti tramite questo link.

Una volta che nandroid ha eseguito il backup sulla sd, basta recuperare i files dal telefonino e copiarli sul proprio pc.

Scaricati fastboot.exe, e lo usi con i files di nandroid tramite i seguenti comandi:


fastboot.exe flash boot boot.img
fastboot.exe flash recovery recovery.img
fastboot.exe flash system system.img
fastboot.exe flash userdata data.img
fastboot.exe flash cache cache.img

Spero che questo post sia stato utile a molti di voi androidiani.

Scrolling fluido sugli anchor usando i Mootools

2009-04-08T21:53:00.000+02:00

Una delle funzionalità implementate dai more dei mootools-more è quella legata al modulo SmoothScroll.
I mootools infatti hanno prestato parecchia attenzione allo sviluppo delle funzionalità legata al “Fx” all'interno del proprio framework.

Gli ancoraggi all'interno delle pagine HTML sono molto importanti, permettono infatti di poter accedere in maniera istantanea a determinati contenuti sommersi della marea di informazioni contenute nella pagina.

Un altro esempio di ancoraggio è quello che permette di poter accedere al "top" della pagina senza dover forzare l'utente a dover scrollare per tutta la lunghezza della stessa. Il problema è che in maniera nativa questa funzionalità è troppo istantanea, infatti la pagina esegue un salto immediato che trasmette all'utente una sorta di risveglio immediato da quello che può essere il relax trasmesso della pagina.

Per questo in questo post si vuole suggerire un modo mediante cui eseguire uno scrolling fluido e graduale della pagina quando si clicca sugli ancoraggi.

La potenza stà nel fatto che l'html da inserire nella pagina è lo stesso che inseriremmo in una normale situazione di utilizzo degli ancoraggi.
Esempio;

<a href="#top" >Top</a>

Questo è il codice da inserire nella vostra pagina per ottenere l'effetto desiderato su tutti gli ancoraggi.

window.addEvent('load', function() { new SmoothScroll({ duration: 1800 }); });

E' necessario importare all'interno della pagina 2 file javascript:
- Il core dei mootools
- il more dei mootools contenente il plugin Asset
I 2 files sono disponibili qui (core) e qui (more).

<script type="text/javascript" language="JavaScript" src="http://www.franziale.netsons.org/src/js/mootools/mootools-1.2.1-core-nc.js"></script>
<script type="text/javascript" language="JavaScript" src="http://www.franziale.netsons.org/src/js/mootools/mootools-1.2-more.js"></script>

E' possibile trovare un esempio di questa funizionalità a questo link Ancoraggi fluidi

Recuperare Charset di default della Java Virtual Machine (JVM)

2009-03-31T00:02:00.000+02:00

A volte in fase di compilazione si può incorrere in problemi di charset, specialmente se si sviluppa in ambienti eterogenei (Linux, Windows, Unix).
A volte si incorre in classi Java compilate con virtual machine che utilizzano charset diverse, causando problemi nelle stringhe che contengono caratteri speciali.
Il metodo mediante cui è possibile riconoscere il charset utilizzato dalla Virtual Machine per compilare è il seguente.

Questo esempio presenta una sezione compatibile con la versione 1.4 della jdk ed un altra con la 1.5. Per poter eseguire lo script è necessario commentare la sezione non interessata.

public class Hello {
 public static void main(String args[]) throws Exception{
  // not crossplateform safe
  System.out.println(System.getProperty("file.encoding"));
  // jdk1.4
  System.out.println(
     new java.io.OutputStreamWriter(
        new java.io.ByteArrayOutputStream()).getEncoding()
     );
  // jdk1.5
  System.out.println(java.nio.charset.Charset.defaultCharset().name());
  }
}

L'output sarà del tipo:

>java Hello
Cp1252
Cp1252
windows-1252

Chiamare Javascript da filmato Flash

2009-03-30T23:12:00.000+02:00

Potrebbe risultare utile dover chiamare una funzione javascript da un filmato flash.
Tale azione può essere associata ad un evento o richiamata alla fine dell'esecuzione del filmato in base alle esigenze dello sviluppatore.

Di seguito potete trovare un esempio di actionScript da includere in un qualunque frame del vostro flash:

function runJS(script:String):Void {
 getURL("javascript:" +  script + "");
}

var js = "var doc = document.URL; alert(doc);";
runJS(js);

Nell' esempio viene richiamata la funzione alert, ma è possibile richiamare qualsiasi funzione dichiarata nel documento.
Questo risulterà senz'altro utile per chi ha a che fare con entrambe le tecnologie all'interno della propria applicazione web.

Padding di una stringa in Java

2009-03-15T21:30:00.000+01:00

Questo post ha come scopo quello di illustrare una possibile implementazione della funzionalità di padding per le stringhe in Java.
In questo esempio la funzionalità di padding è una funzione generica in cui è possibile specificare come parametri di input le seguenti informazioni :
- Stringa di cui effettuare il padding
- Carattere o stringa con cui eseguire il padding
- Numero di caratteri della stringa di output
- Orientamento del padding (sinistra, destra)
Ecco l'implementazione:

public class Padding {
 
   public static final int PADDING_LEFT = 0;
     public static final int PADDING_RIGHT = 1;

     public static String padString(String str, String paddingChar, int lngth, int paddingSide) {
         if (str == null) {
             str = "";
         }

         if (str.length() < lngth) {
             for (int k = str.length(); k < lngth; k++) {
                 if (paddingSide == PADDING_LEFT)
                     str = paddingChar + str;
                 else if (paddingSide == PADDING_RIGHT)
                     str = str + paddingChar;
                 else throw new IllegalArgumentException("paddingSide argument wrong!");
             }
         }
         return str;
     }
}

Di seguito un esempio di un possibile utilizzo di questo metodo :

String padded = Padding.padString("Hello World","-",50,Padding.PADDING_LEFT);

Java : Eseguire Jar o Web Application in modalità debug

2009-03-03T10:33:00.001+01:00

Capita spesso di dover rintracciare determinati errori o comportamenti anomali della propria applicazione. Ritorna utilissimo utilizzare l'esecuzione in modalità debug rendendo possibile tramite il proprio IDE l'esecuzione passo passo di una determinato blocco di codice, controllare lo stato delle variabili in un determinato stato del sistema, controllare lo stack trace, valutare determinate espressioni personalizzate e modificare a runtime il valore delle variabili.
Con un utilizzo corretto e avanzato di questa modalità è possibile rintracciare e risolvere i problemi delle nostre applicazioni in pochissimi istanti.

Non starò a spiegare come eseguire il debug in maniera ottimale. Questo post ha il semplice scopo di voler aiutare gli utenti a configurare il proprio ide, la propria web application o applicazione stand alone ad essere eseguita in modalità debug.
Il primo passo da eseguire è quello di lanciare l'application server o l'applicazione con i seguenti parametri :

-Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=4142,suspend=n

Ad esempio se volessi lanciare il mio container, in questo caso un Oc4j:


java -XX:PermSize=128m -Xmx512m -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=4142,suspend=n -jar oc4j.jar -userThreads

Se invece volessi lanciare il jar della mia applicazione:

javaw -jar -Xmx512M -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=4142,suspend=n -jar externalEPG.jar

Dopodichè è necessario configurare il proprio IDE per poter comunicare con la virtual machine ed eseguire il codice in debug.
N.B : E' necessario che eclipse utilizzi la stessa virtual machine utilizzata dall'applicazione.
E' necessario andare nel menù Run -> Open Debug dialog...
Settare le impostazioni come nell'immagine:

E' necessario quindi scegliere il progetto da cui eclipse andrà recuperare i relativi sources, la connection type: Socket (metodo con cui eclipse si connette alla VirtualMachine) e la porta che abbiamo impostato precedentemente nei parametri passati alla VM (nel nostro caso 4142).
Adesso è necessario solamente avviare il debug mediante il corrispondente pulsante e switchare la modalità di visualizzazione in quella di debug. Il risultato che otterrete sarà il seguente:

Molti non adorano "Debuggare" ma altri riescono a coglierne a pieno la potenza. Buon divertimento!

Catalogare Film con Mac OSX e DVDpedia

2009-02-23T18:50:00.000+01:00

Per chi avesse necessità di catalogare la propria collezione di film in DVD potrebbe essere interessante provare lo “shareware” per OSX DVDpedia. La versione dimostrativa consente di testare il programma e di archiviare fino ad un limite di 10 titoli cinematografici, acquistando la licenza (ad un prezzo accessibilissimo) è possibile usufruire di alcuni extra (plugin, temi grafici, bottoni) messi a disposizione dal sito produttore.

L’utilizzo di DVDpedia è molto semplice ed intuitivo in tutte le sue molteplici opzioni. La ricerca dei titoli sfrutta circa una ventina di motori di ricerca come IMDb, Amazon, BOL IT, dvd.it ed altri ancora. E’ presente inoltre una funzione di ricerca tramite iSight e il codice a barre, se presente sulla copertina del DVD. Un’altra comoda opzione è quella di poter gestire i prestiti (nel caso si dia uno o piu DVD ad un amico) tramite Rubrica Indirizzi, iCal ed eventualmente sollecitarne la restituzione via Mail.

Per effettuare la ricerca di un film andiamo sul menu’ Modifica e scegliamo Aggiungi DVD (o usiamo semplicemente da tastiera la combinazione tasti Mela + F). DVDpedia interrogherÃ i motori sopracitati e in base ai criteri di ricerca da noi impostati (titolo, regia, prezzo, DVD, VHS, etc) ci restituirà una serie di risultati che andremo a visionare. Nel caso di titoli abbastanza famosi la ricerca fornirà opzioni di scelta molto mirate, titolo originale, copertina DVD, edizione, data di pubblicazione, regia etc.

Una volta individuato il nostro DVD, selezioniamo il titolo e aggiungiamolo al nostro Archivio (Biblioteca). Se non dovessimo essere completamente soddisfatti dei risultati, possiamo ottenere informazioni ancor piu’ mirate per la selezione, interrogando i singoli motori di ricerca (consiglio IMDb e dvd.it per le produzioni italiane) o aggiungendo manualmente i dati mancanti o inesatti in seguito. Nel caso la ricerca non producesse alcun risultato, armiamoci di pazienza ed effettuiamo una nuova ricerca in rete affidandoci a Google.

E’ presente inoltre in DVDpedia la funzione Esporta che permette di salvare la nostra collezione cinematografica in vari formati (.Mac, iPod, FTP, HTML, Backup e nel formato proprietario .dvdpedia). E’ possibile anche esportare l’intera collezione per creare una copia di sicurezza o spedirla ad una altro utente di DVDpedia (ho avuto modo di provarla solo in rete locale, per cui non saprei come si comporti questa funzione al di fuori di una LAN). Nei vari formati di esportazione troviamo inoltre diverse opzioni di scelta. Il formato HTML ad esempio fornisce diversi temi grafici per personalizzare la nostra collezione, alcuni dei quali scaricabili dalla pagina degli extra di DVDpedia.

L’esportazione via FTP permette di creare una directory DVDs della nostra collezione, precedentemente esportata in locale in formato HTML, direttamente sul nostro spazio web (nel caso ne avessimo uno). E’ una comoda funzione che permette di consultare la propria lista di film anche se non siamo a casa o non abbiamo con noi il nostro portatile. (sconsiglio pero’ di aggiornare la collezione dal programma stesso ma di effettuare l’aggiornamento manualmente via FTP).

Di seguito un immagine di DVDPedia:

Per concludere, la mia voleva essere solo una semplice presentazione e veloce panoramica del programma. Esiste già in rete un’ottima guida su DVDpedia in italiano e la troviamo qui.

La fonte di questo articolo è il blog di macavanzi

Mostrare il percorso di uno o più files con il finder mediante un azione automator

2009-02-15T22:36:00.001+01:00

Gli sviluppatori quotidianamente compiono le stesse operazioni una miriade di volte, e velocizzarne l'esecuzione permette un risparmio di tempo considerevole. Per questo motivo tendo a creare facilitazioni mediante cui potermi facilitare il lavoro e farlo in maniera più veloce. Per uno sviluppatore, o per chiunque si trovi a dover recuperare in maniera istantanea il percorso assoluto di uno o più files sul proprio file system, questo post potrebbe risultare alquanto utile.
Per questo motivo ho creato uno script mediante cui, una volta aggiunto, è possibile selezionare uno o più file tramite il finder, premere il tasto destro del mouse e trovare sotto la voce Automator -> Mostra percorso la funzionalità adatta a tale scopo (visualizzare il path assoluto del file).
I passi da seguire sono i seguenti passi:
Aprire Automator
Creare un nuovo Script ad Hoc
Incollare il seguente script :

on run {input, parameters}
 global textString
 
 if (count of input) is equal to 1 then
  repeat with theItem in input
   set textString to POSIX path of (theItem as alias)
   tell application "Finder"
    set choice to display dialog "Percorso" default answer textString buttons {"Copia", "OK"} default button 1
    set textString to text returned of the result
    if the button returned of choice is not equal to "OK" then
     set the clipboard to textString
    end if
   end tell
  end repeat
 else
  tell application "TextEdit"
   make new document at the beginning of documents
  end tell
  tell application "TextEdit"
   make new paragraph at the end of document 1 with data ("Percorso file: " & return) with properties {font:titleFont, size:titleSize}
  end tell
  repeat with theItem in input
   
   tell application "TextEdit"
    make new paragraph at the end of document 1 with data (theItem)
    make new paragraph at the end of document 1 with data (return) with properties {font:titleFont, size:titleSize}
   end tell
  end repeat
 end if
 return input
end run

Scegliere dal menù Archivio->Registra come plugin
Inserire come nome : Mostra percorso
Scegliere nella combobox "Plugin in" la voce : Finder.

Il comportamento dello script si differenzia nel caso stiate selezionando una o più voci. Guardiamo insieme il caso in cui viene selezionato un solo file :

Mediante la pressione del tasto Copia è possibile copiare il percorso nella clipboard.
Nel caso in cui invece si siano selezionati più files il risultato sarà visualizzato all'interno di una finestra di textEdit così come in figura:

Nel caso abbiate suggerimenti o commenti su questo script vi prego di contattarmi.Alla prossima!

Htc G1, arriva in Europa il Google phone

2009-01-21T17:23:00.000+01:00

"The wait is over": l'attesa è finita. Così recita lo slogan scelto da T-Mobile per accompagnare l'Htc G1 sulla terraferma del continente europeo. Il primo smartphone equipaggiato con la piattaforma Android, sviluppata da Google, sarà disponibile a partire da fine gennaio anche in Olanda, Repubblica Ceca e Austria. Dal 2 febbraio sarà venduto in Germania e, a seguire, in Polonia. L'Htc G1 aveva già varcato l'Oceano dopo il lancio negli Usa: dallo scorso autunno il telefonino è in vendita anche in Gran Bretagna. Sempre per merito di T-Mobile. Nei cinque nuovi paesi europei il G1 sarà proposto a prezzi stracciati.

Sottoscrivendo il solito contratto con un vincolo di fedeltà di 24 mesi, basterà versare 1 euro per mettersi in tasca il primo GooglePhone. Negli Stati Uniti, lo smartphone con Android, sistema operativo peraltro derivato da Linux, si acquista a 179 dollari.
Nonostante i prezzi aggressivi, giustificati anche dalla necessità di rintuzzare l'Apple iPhone, la dotazione dell'Htc è di tutto rispetto.
Vanta antenna Gps, che opera insieme con Google Maps, e connessioni Umts, Bluetooth e Wi-Fi. In più, il touchscreen da 3,2 pollici (480x320 pixel) ruota rivelando una tastiera Qwerty completa. Non manca nemmeno la fotocamera da 3,2 Mpixel. Con l'apertura di nuovi mercati in Europa, T-Mobile punta a superare il milione di unità vendute in breve tempo: secondo alcune stime, il numero di G1 venduti solo negli Stati Uniti sono tra 400 mila e 600 mila unità (stando ai dati più ottimistici).
E in Italia? Ancora sconosciuti i tempi di commercializzazione di Android; il fatto, però, che lo smartphone sia distribuito da T-Mobile lascia pensare a un possibile accordo con Tim.
Entrambi i gestori sono membri del consorzio Freemove Alliance, oltre che della Open Handset Alliance che comprende provider telefonici e aziende produttrici impegnate nello sviluppo di Android. In quest'ultima categoria rientra, però, anche Vodafone. Dunque, nel Bel Paese, il G1 deve ancora trovare un operatore che decida di importarlo. Anche perché il dispositivo necessita di un pacchetto ad hoc per la navigazione sul Web che consenta di sfruttare appieno le funzioni connesse; per esempio, per scaricare le numerose applicazioni accessorie dall'Android Market che prende spunto dall'AppStore per l'iPhone. E poi il sistema operativo di Google è stato studiato per apparecchi fortemente orientati all'Internet in mobilità. A conti fatti, è ragionevole supporre che in Italia il telefonino sarà in vendita per l'estate. Nel frattempo, stando ad alcune indiscrezioni, Htc starebbe già lavorando al suo successore: il G2. Si vocifera che avrà un display più ampio e funzioni migliorate.

Fonte : Il Sole 24 Ore

Socket in Java (tcp e udp)

2009-01-18T17:29:00.000+01:00

Molti sistemi distribuiti ed applicazioni sono costruiti e basati semplicemente sul modello message-oriented del livello di trasporto.
In fase di progettazione del livello di trasporto è stata prestata molta attenzione alle standardizzazioni delle interfaccie per permettere ai programmatori di utilizzare l'intera suite di protocolli mediante un semplice set di primitive.
Un classico esempio sono le interfaccie socket introdotte in Berkley Unix.

Concettualmente un socket è un endpoint di comunicazione tramite cui un applicazione può scrivere dati che vengono inviati tramite la rete e tramite cui dati in ingresso possono essere letti.
Consideriamo le primitive :
1. SOCKET : crea un nuovo endpoint di comunicazione
2. BIND : attacca un indirizzo locale ad un socket
3. LISTEN : annuncia l'approvazione di accettare la connessione
4. ACCEPT : blocca il chiamante finchè non arriva una richiesta di connessione
5. CONNECT : tenta attivamente di stabilire una connessione
6. SEND : invia dati mediante la connessione
7. RECEIVE : riceve dati dalla connessione
8. CLOSE : rilascia la connessione

I server generalmente eseguono le prime 4 nell'ordine dato:
1. Il sistema operativo locale riserva la risorsa per garantire l'invio e la ricezione di messaggi per il protocollo specificato
2. Dice al S.O. che il server vuole ricevere dati solo su quell'indirizzo e su quella porta
3. E' chiamata solo in caso di comunicazione orientata alla connessione, serve a dire al S.O di allocare abbastanza buffer per un numero massimo di connessioni.
4. Quando arriva una richiesta il S.O. crea un nuovo socket con le stesse proprietà di quello originale e lo restituisce al chiamante.

Guardiamo il Client:
1. Va creato il SOCKET utilizzando la primitiva
5. La primitiva CONNECTION richiede che il chiamante specifichi l'indirizzo del livello di trasporto al quale la richiesta di connessione deve essere inviata. Il client si blocca finchè la richiesta è completata. Quindi le 2 parti possono iniziare a scambiare dati mediante le primitive READ e RECEIVE.

8. La chiusura è simmetrica e può avvenire sia lato client che lato server.

Vediamo un esempio di implementazione in cui avvengono i seguenti passi :
- Il client legge una linea dallo standard input (inFromUser stream) , e lo invia al server mediante socket (outToServer stream)
- Il server legge la linea dal socket
- Il server converte la line in uppercase e la restituisce al client
- Il client legge e stampa la linea modificata mediante il socket (inFromServer stream)

IMPLEMENTAZIONE TCP
Nella versione TCP dell'implementazione dei socket distinguiamo le seguenti caratteristiche peculiari:
Poichè il TCP fornisce un affidabile e ordinato trasferimento di bytes tra client e server (orientato alla connessione),
è necessario che il processo server sia il primo ad essere eseguito, in maniera tale da creare il socket (door) che accetta la connessione da parte dei client.
Quando i client creano il socket, il client TCP stabilisce una connessione con il server TCP il quale crea un nuovo socket per la comunicazione con il client. Questo permette di avere una comunicazione simultanea con più client.
Ecco l'implementazione del server :

/***
 * Classe per la gestione del server
 * 
 * @author Alessandro Franzi
 *
 */
public class TCPServer {
 public static final int PORT = 6768;
 
 public static void main(String[] args){
  String fraseClient;
  String fraseMaiuscola;
  try{
   // creo il socket di benvenuto
   ServerSocket welcomeSocket = new ServerSocket(PORT);
   
   // ciclo infinitamente (server)
   while (true){
    
    // aspetto il socket per il contatto con il client
    Socket connectionSocket = welcomeSocket.accept();
    
    System.out.println("Accettata connessione socket");
    System.out.println("Il client è connesso dall'ip : "+connectionSocket.getRemoteSocketAddress());
    
    //creo uno stream di input attaccato al socket
    BufferedReader inFromClient = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
    
    DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());
    
    // leggo la frase del client
    fraseClient = inFromClient.readLine();
    
    // trasformo la frase in maiuscolo
    fraseMaiuscola = fraseClient.toUpperCase();
    
    System.out.println("frase da inviare : "+fraseMaiuscola);
    
    outToClient.writeBytes(fraseMaiuscola+'\n');
    
   }
  }catch (IOException e) {
   System.out.println("Errore :"+e.getMessage());
  }
 }
}

Questa invece è l'implementazione del client :

/***
 * Classe client TCP
 * 
 * @author Alessandro Franzi
 *
 */
public class TCPClient {
 
 private static final String HOSTNAME = "1.46.193.82";
 public static final int PORT = 6768;
 
 public static void main(String[] args){
  String host ="";
  int port = PORT;
  String frase ="";
  String fraseModificata;
  
  if (args.length==0){
   System.out.println("Parametri di default.");
   System.out.println("Host : "+HOSTNAME+" Porta : "+PORT);
   host = HOSTNAME;
  }else{
   if (args.length==1){
    host = args[0];
   }
   if (args.length==2){
    host = args[0];
    port = new Integer(args[1]).intValue();
   }
  }
  // dichiaro un buffer Reader
  BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
  
  try{
   // connetto il socket locale
   
   Socket clientSocket = new Socket(host,port);
   
   System.out.println("Connessione accettata dal server ");
   // crea un outputStream connesso allo stram di output del socket
   DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());
   
   // creo un buffer di lettura dal server
   BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
   
   
   // prelevo la frase dallo standard input
   frase = inFromUser.readLine();
   
   // passo la frase al server
   outToServer.writeBytes(frase + '\n');
   
   // recupero la frase modificata dal server
   fraseModificata = inFromServer.readLine();
   
   System.out.println(fraseModificata);
   
   // chiudo il socket
   clientSocket.close();
   
  }catch(UnknownHostException e){
   System.out.println("Host sconosciuto : "+e.getMessage());
  }catch(IOException e){
   System.out.println("Problema con il server : "+e.getMessage());
  }
  
 }
}

IMPLEMENTAZIONE UDP
Il protocollo UDP non fornisce una connessione tra client e server, il server infatti esplicitamente si attacca ad un indirizzo IP ed una porta di un client del destinatario. Il server deve estrarre l'indirizzo IP e la porta del mittende ricavandoli dal datagram ricevuto.
Vediamo l'implementazione del server UDP:

public class UDPServer {
 public static final int PORT = 6769;
 
 public static void main(String[] args) {
  
  try {
   
   // creo il socket
   DatagramSocket serverSocket = new DatagramSocket(PORT);
   
   byte[] sendData = new byte[1024];
   byte[] receiveData = new byte[1024];
   
   while (true){
    
    // istanzio il datagramma in input
    DatagramPacket receivePacket = new DatagramPacket(receiveData,receiveData.length);
    
    // ricevo il datagramma dal socket
    serverSocket.receive(receivePacket);
    
    // recupero la frase
    String frase = new String(receivePacket.getData());
    
    // indirizzo ip
    InetAddress iPAddress = receivePacket.getAddress();
    
    // porta
    int port = receivePacket.getPort();
    
    // modifico la porta
    String fraseModificata = frase.toUpperCase();
    
    // trasformo in byte 
    sendData = fraseModificata.getBytes();
    
    // creo un datagramma per inviare al client
    DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length,iPAddress,port);
    
    //scrivo il datagramma sul socket
    serverSocket.send(sendPacket); 
   } 
  }catch(SocketException e){
   System.out.println("Problemi nell'apertura del socket "+e.getMessage());
  }catch(IOException e){
   System.out.println("Problemi di I/O : "+e.getMessage());
  }
 } 
 
}

Ecco invece l'implementazione del corrispettivo client

/***
 * Classe per la gestione del client UDP
 * 
 * @author Alessandro Franzi
 *
 */
public class UDPClient {
 public static final String HOSTNAME = "localhost";
 public static final int PORT = 6769;
 
 public static void main(String[] args) {
  String host ="";
  int port = PORT;
  
  if (args.length==0){
   System.out.println("Parametri di default.");
   System.out.println("Host : "+HOSTNAME);
   host = HOSTNAME;
  }else{
   if (args.length==1){
    host = args[0];
   }
   if (args.length==2){
    host = args[0];
    port = new Integer(args[1]).intValue();
   }
  }
  
  // buffer di input del client
  BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
  
  try{
   
   // creo il socket client
   DatagramSocket clientSocket = new DatagramSocket();
  
   // creo l'indirizzo ip
   InetAddress IPAddress = InetAddress.getByName(host);
   
   byte[] sendData = new byte[1024];
   byte[] receiveData = new byte[1024];
   
   String frase = inFromUser.readLine();
   
   sendData = frase.getBytes();
   
   // creo un datagramma con i dati da inviare, lunghezza, ip e porta
   DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length,IPAddress,port);
   
   // invio il datagramma al server
   clientSocket.send(sendPacket);
   
   // credo un pacchetto 
   DatagramPacket receivePacket = new DatagramPacket(receiveData,receiveData.length);
   
   clientSocket.receive(receivePacket);
   
   // frase ricevuta dal server
   String fraseModificata = new String(receivePacket.getData());
   
   System.out.println("Frase ricevuta : "+fraseModificata);
   
   // chiudo il socket
   clientSocket.close();
  }catch(SocketException e){
   System.out.println("Problemi con il socket : "+e.getMessage());
  }catch(UnknownHostException e){
   System.out.println("Host sconosciuto : "+e.getMessage());
  }catch (IOException e){
   System.out.println("I/O exception : "+e.getMessage());
  }
 }
}

Spero che questi esempi siano sufficienti a chiarire il funzionamento dei socket in Java. Per qualsiasi perplessità o chiarimento non esitate a contattarmi. Alla prossima.

Scrivere file di log con php

2009-01-11T20:41:00.000+01:00

E' indispensabile sia in fase di sviluppo che di manutenzione di un sito php utilizzare dei files di log per intercettare gli errori o comunque ricostruire il comportamento o il valore delle variabili prima che lo stesso si verifichi.
Per venire in contro agli sviluppatori ci sono framework come log4j tramite cui è possibile "smistare" la scrittura dei log su diversi files.
Personalmente ho ritenuto più semplice e leggero implementare una mia versione di un manager per i log.

Innanzitutto vediamo i parametri di configurazione che utilizzerà il Manager dei log:

 // logging 
 $log_path = "log/";
 $debugLogFile = "debug.log";
 $errorLogFile = "error.log";
 
 define("LOGPATH",   $log_path);
 define("DEBUGFILE",   $debugLogFile);
 define("DEBUGLOG",                    'DEBUGLOG');
 define("ERRLOG",                         'ERRLOG');
 define("ERRORFILE",   $errorLogFile);

Le righe relative alle define hanno essenzialmente lo scopo di dichiarare delle costanti utilizzabili in qualsiasi scope dell'applicazione.

Di seguito l'implementazione del Manager vero e proprio:

/***
 * Classe per il logger
 * 
 * @author Alessandro Franzi
 * 
 */
Class ManageLogger{

    private $FILELIST = array();
    private $HANDLER = array();
    private $ROOT = "";
    private $WIN32 = false;
    private $FORMAT = "%b %d %H:%M:%S";
    private $DEBUG = true;

 /***
  * Costruttore della classe logger
  */
    public function ManageLogger ( $LogRoot, $FileArray = "" ){
        if(empty($LogRoot)){
   // se non è stata specificata la root del logger
            if($this->DEBUG){
                error_log("[ErrorLog]: C'è bisogno della Root Folder per creare il logger",0);
            }
            return;
        }
        $this->set_root($LogRoot);
        if(!empty($FileArray)){
            // se non è vuoto l'array contenente i nomi dei files di log
            $this->initialize($FileArray);
        }
        return;
    }
 
 /***
  * Inizializza l'array dei file di log
  */
    public function initialize ($FileArray){
        if ( (gettype($FileArray)) != "array"){
            if($this->DEBUG){
                error_log("[ErrorLog]: Tipo di Array per i file di log invalido",0);
            }
            return;
        }
        while ( list ($key,$val) = each ($FileArray) ){
            if ( (!empty($key)) and (!empty($val)) ){
                // associo i vari file di log al relativo compito
                $val = "$this->ROOT"."$val";
                $this->FILELIST[$key] = $val;
                $this->HANDLER[$key] = null;
            }
        }
        return;
    }
 
 /***
  * Metodo per scrivere il log
  * 
  */
    public function log ($Handle,$LogEntry)
    {
        global $php_errormsg;

        $filename = $this->FILELIST[$Handle];
        $TimeStamp = strftime($this->FORMAT,time());
        // associo la mia formattazione alla stringa
        $LogEntry = "$TimeStamp - $LogEntry";

        if (!$this->HANDLER[$Handle]){
            $fd = fopen($filename,"a");
            if ( (!$fd) or (empty($fd)) ){
                if($this->DEBUG)
                {
                    error_log("[ErrorLog]: Errore fatale sul file:  $php_errormsg",0);
                }
                return;
            }
            fwrite($fd,"$LogEntry\n");
            $this->HANDLER[$Handle] = $fd;
        }else{
            fwrite($this->HANDLER[$Handle],"$LogEntry\n");
        }
        return;
    }

 /***
  * Metodo per chiudere i file di log
  */
    public function close_logs (){
        while ( list ($Handle, $Val) = each ($this->FILELIST) ){
            if($this->HANDLER[$Handle]){
                $TimeStamp = strftime($this->FORMAT,time());
                fclose($this->HANDLER[$Handle]);
                unset($this->HANDLER[$Handle]);
            }
        }
    }

 /***
  * Metodo per settare la root dei file di log
  */
    public function set_root ($root){
        if(!$this->WIN32){
            if(!ereg("\/$",$root)){
                $root = "$root"."/";
            }
            if(is_dir($root)){
                $this->ROOT = $root;
            }else{
                $this->ROOT = "";
                if($this->DEBUG){
                    error_log("La root specificata: [$root] non è una directory",0);
                }
            }
        }else{
            // Macchine Winzozz
            if(!ereg("\\$",$root)){
                $root = "$root"."\\";
            }
            $this->ROOT = $root;
        }
    }
    /***
     * Metodo per loggare messaggi di errore
     * 
     */
    public function error ($messaggio){
     $this->log(ERRLOG,"[".pagina::getNomePagina()."] - ".$messaggio);
    }
 /***
     * Metodo per loggare messaggi di debug
     * 
     */
    public function debug ($messaggio){
     $this->log(DEBUGLOG,"[".pagina::getNomePagina()."] - ".$messaggio);
    }
    
    /***
     * Distruttore della classe che invoca la chiusura dei file di log
     */
    public function __destruct() {
     $this->close_logs();
    }
}

Osserviamo come istanziare e inizializzare il ManageLogger :

$ManageLogger = new ManageLogger("./".LOGPATH);
$ManageLogger->initialize(array('ERRLOG' => ERRORFILE ,'DEBUGLOG' => DEBUGFILE));

E' chiaro che se si volessero utilizzare altri appender per i file di log, basterebbe aggiungerli all'array.
Queste sezioni di codice sarebbero sufficienti per poter avere un logger funzionante, richiamando i metodi opportuni (debug e error) sul manager, ma è sicuramente più comodo implementare una classe mediante cui interfacciarsi con il manager.
Il compito della classe Logger infatti è proprio quella di utilizzare i metodi del manageLogger da noi facilmente raggiungibile mediante i suoi metodi statici.
Ecco infine l'implementazione :

/**
 * Depends : ManageLogger
 * Classe di controllo per l'istanza dell'oggetto ManageLogger
 * 
 * @author Alessandro Franzi
 * 
 */
 class Logger{
 /***
  * Metodo statico per la stampa del log di debug
  */
 public static function debug ($msg) {
  global $ManageLogger;
  $ManageLogger->debug($msg);
 }
 /***
  * Metodo statico per la stampa del log di errore
  */
 public static function error ($msg,$e=null) {
  global $ManageLogger;
  $ManageLogger->error($msg);
  if ($e!=null){
   $ManageLogger->error("Causa : ".$e->getMessage()."\nStackTrace : ".$e->getTraceAsString());
  }
 }  
}

Vediamo quindi come poter utilizzare nel nostro codice i log:

// esempio di logging dell'errore in un blocco try/catch
try{
....
}catch(Exception $e){
   logger::error("Eccezione",$e);
}
// esempio di logging per il debug
Logger::debug("Il valore della variabile a è ".$a);

Un buon utilizzo dei logger in fase di sviluppo certamente renderà molto più semplice eseguire manutenzioni correttive sullo stesso. Spero che questo codice sia semplice da comprendere, naturalmente sono ben accetti consigli o correzioni sullo stesso.

Generazione valori random in php

2009-01-10T22:15:00.000+01:00

Questo post ha come obiettivo quello di fornire una soluzione alla generazione di valori numerici random e alla creazione di stringhe random in php.
L' utilizzo di stringhe random può essere utile ad esempio nel caso in cui si vogliano definire nomi di variabili javascript o identificatori di elementi per l'html univoci.
Qui di seguito l'implementazione di una classe mediante cui, attraverso i relativi metodi statici mette a disposizione tali funzionalità.

Ecco l'implementazione della classe :

/***
 * Classe per la generazione random
 * 
 * @author Alessandro Franzi
 * 
 */

class Random{
 /***
  * Genera una stringa random
  * 
  * @param $caratteri : numero di caratteri della stringa random
  * @return     : stringa generata in maniera random
  */
 public static function string($caratteri=7){
  $chars = "abcdefghijkmnopqrstuvwxyz023456789";
  srand((double)microtime()*1000000);
  $i = 0;
  $pass = '' ;
 
  while ($i <= $caratteri) {
   $num = rand() % 33;
   $tmp = substr($chars, $num, 1);
   $pass = $pass . $tmp;
   $i++;
  }
 
  return $pass;
 }
 /***
  * Metodo per generare un numero random
  * @param $min : valore minimo del numero random (optional)
  * @param $min : valore massimo del numero random (optional)
  * @return   : numero random
  */
 public static function numero ($min=null,$max=null){
  if (empty($min)&&empty($max)){
   return rand();
  }else{
   return rand($min,$max);
  }
 }
}

Vediamo ora come è possibile invocare tali funzionalità:

// creare una stringa di 10 caratteri
$strRand = Random::string(10);
// creare una stringa di 7 caratteri (numero di default)
$strRand = Random::string();
// recuperare un valore numerico random senza stabilire un range
$numRand = Random::numero();
// recuperare un valore numerico il cui range è [2,23]
$numRand = Random::numero(2,23);

Spero che questo post sia stato utile. Alla prossima!

Importare dinamicamente un file css o js all'interno del body

2009-01-10T20:44:00.000+01:00

Una limitazione nell'inclusione dei fogli di stile css mediante l'utilizzo del tag html <link> consiste nel fatto che lo stesso debba essere incluso all'interno del tag <head> affinchè gli stili inclusi possano essere utilizzati dal browser.
Nel caso in cui si voglia includere un file css in un qualsiasi punto della pagina, ad esempio nel <body>, magari associando l'inclusione ad un determinato evento o ad una determinata condizione risulterebbe impossibile se non ci venisse in contro il framework Javascript : MooTools.

E' possibile mediante questa classe includere anche file javascript a runtime, così come per i file css.
E' necessario importare all'interno della pagina 2 file javascript:
- Il core dei mootools
- il more dei mootools contenente il plugin Asset
I 2 files sono disponibili qui (core) e qui (more).

<script type="text/javascript" language="JavaScript" src="http://www.franziale.netsons.org/src/js/mootools/mootools-1.2.1-core-nc.js"></script>
<script type="text/javascript" language="JavaScript" src="http://www.franziale.netsons.org/src/js/mootools/mootools-1.2-more.js"></script>

Il passo successivo è quello di utilizzare all'interno della pagina il seguente codice:

// include un file css a runtime
var myCSS = new Asset.css("style.css");
// include un file javascript a runtime
var myJS = new Asset.javascript("jsdefinition.js");

Di seguito è presente il codice per poter gestire la stampa del javascript per la chiamata ai metodi dei mootools mediante una classe PHP.

/**
 * Classe Boundary per la gestione della stampa
 * @author a.franzi
 */
class MooTools{
 
 /**
  * Metodo per recuperare la chiamata al metodo della classe Asset dei mootools per 
  * importare un file css a runtime (quindi non necessariamente nell'head della pagina)
  *
  * @param $cssFile : path al file css
  * @return    : stringa javaScritpt contenente la chiamata al metodo della clase
  *        Asset dei mootools
  */
 public static function getAssetCss($cssFile){
  // nel caso in cui non si voglia usare un nome univoco , è possibile decommentare questa riga
  // ed eliminare la seguente
  //return "var myCss = new Asset.css('".$cssFile."');";
  return "var myCss".Random::string()." = new Asset.css('".$cssFile."');";
 }
 /**
  * Metodo per stampare la chiamata al metodo della classe Asset dei mootools per 
  * importare un file css a runtime (quindi non necessariamente nell'head della pagina)
  *
  * @param $cssFile : path al file css
  */
 public static function printAssetCss($cssFile){
  echo self::getAssetCss($cssFile);
 }
 /**
  * Metodo per recuperare la chiamata al metodo della classe Asset dei mootools per 
  * importare un file js a runtime
  *
  * @param $cssFile : path al file js
  * @return    : stringa javaScritpt contenente la chiamata al metodo della clase
  *        Asset dei mootools
  */
 public static function getAssetJs($jsFile){
  // nel caso in cui non si voglia usare un nome univoco , è possibile decommentare questa riga
  // ed eliminare la seguente
  //return "var myJs = new Asset.javascript('".$jsFile."')";
  return "var myJs".Random::string()." = new Asset.javascript('".$jsFile."')";
 }
 /**
  * Metodo per stampare la chiamata al metodo della classe Asset dei mootools per 
  * importare un file js a runtime
  *
  * @param $cssFile : path al file js
  * @return    : stringa javaScritpt contenente la chiamata al metodo della clase
  *        Asset dei mootools
  */
 public static function printAssetJs($jsFile){
  echo self::getAssetJs($jsFile);
 }
}

Attenzione : nel codice si fà riferimento alla classe Random la cui implementazione è possibile recuperarla sul post Generazione valori random in php.
Sicuramente questo post sarà utile a coloro, come nel mio caso utilizzino un controller per la gestione centralizzata dell'inclusione di file js e file css.

Mysql : Cambiare la password di root o di un determinato utente

2008-12-17T11:37:00.000+01:00

Nel normale utilizzo di un server Mysql si può incorrere in diverse situazioni in cui è necessario dover settare o resettare la password per un determinato utente.
Qui di seguito analizziamo le situazioni in cui si può incorrere e i relativi metodo di risoluzione di tali problematiche.

SETTARE LA PASSWORD DI ROOT LA PRIMA VOLTA
Il server di Mysql appena installato e lanciato per la prima volta non associa nessuna password di default per l'utente root.
Ecco 2 modi in cui poter settare la password per l'utente root nel caso in cui non sia stata ancora settata.
La prima soluzione è la seguente ed è seguita mediante il comando mysqladmin

mysqladmin -u root password NEWPASSWORD

Una seconda soluzione è eseguire una serie di comandi mysql per poter settare la password. E' necessario seguire i seguenti passaggi:
1) Loggarsi al server mysql, e eseguire i seguenti comandi sul promt di mysql:

mysql -u root

2) Cambiare la password:

SET PASSWORD FOR root@localhost = PASSWORD('tua_nuova_password');

In questo modo al prossimo tentativo di login è sufficiente utilizzare il seguente comando

mysql -u root -p

ed inserire la password per loggarsi.

RESETTARE LA PASSWORD DIMENTICATA
Può accadere che ci si dimentichi della password di root di un sistema db MySQL. Per resettare la password è necessario operare come segue: fermare mysql - su sistemi *nix da root con :

/etc/init.d/mysql stop

su windows - con privilegi di amministrazione - con:
Menu Start --> Esegui --> cmd --> services.msc
localizzare il servizio MySQL quindi selezionarlo con il tasto destro e stopparlo.

Una volta fermato MySQL:
# riavviarlo con (linux):

mysqld_safe --skip-grant-tables

su windows:
portarsi nella sottocartella bin della cartella in cui si trova il programma mysql, quindi:

mysqld --skip-grant-tables

aprire una nuova shell mysql (da windows o linux) e digitare solo:

mysql -h localhost

si è avuto accesso senza inserire la password. Per modificarla:

use mysql;
UPDATE user SET password=password("NUOVAPASSWORD") WHERE user="root";

Una volta completata l'operazione, fermare di nuovo il server MySQL e riavviarlo normalmente, cioè come demone o servizio.
SETTARE LA PASSWORD PER UN UTENTE
1) Loggarsi al server Mysql

mysql -u root -p

2) Usare il database Mysql (digitare il comando sul promt mysql>):

use mysql;

3) Cambiare la password per l'utente utenteProva:

update user set password=PASSWORD("NEWPASSWORD") where User='utenteProva';

4) Ricaricare i privilegi

flush privileges;

Questi esempi dovrebbero coprire la maggiorparte delle situzioni in cui si può incorrere.

Abilitare/disabilitare il multi-window Mode in Safari

2008-12-14T20:17:00.000+01:00

Per chi come me utilizza Mac Os X potrebbe essere davvero utile un appleScript mediante il quale poter abilitare e disabilitare l'apertura di nuove finestre di Safari.
Di default Safari, tende ad aprire i link in nuove Finestre anzichè utilizzare un nuovo Tab. Questo rende la navigazione alquanto caotica. Personalmente non ricordo se esista una voce nel menù di Safari per gestire questa particolare opzione.

Una soluzione è quella di crearsi uno script per poter scegliere la configurazione desiderata mediante una seplice Dialog.
Vediamo il codice:

beep
set choice to (display dialog ("Vuoi abilitare/disabilitare Safari in single window mode?") buttons {"Cancella", "Abilita", "Disabilita"} default button 1 with icon 1 with title "SSWM")

if the button returned of choice is not equal to "Cancellal" then
 if the button returned of choice is equal to "Abilita" then
  -- Terminal command to enable SWM
  set cmd to ("defaults write com.apple.Safari TargetedClicksCreateTabs -bool true")
 else
  -- Terminal command to disable SWM    
  set cmd to ("defaults write com.apple.Safari TargetedClicksCreateTabs -bool false")
 end if
 
 try
  -- Execute command
  set x to (do shell script cmd)
  -- Positive feedback
  set x to (result & "Operazione eseguita!")
 on error e
  -- Return Error
  set x to e
 end try
 
 -- Display feedback
 if the button returned of choice is equal to "Abilita" or "Disabilita" then
  
  set choice2 to (display dialog ((x as string) & return & "E' necessario riavviare Safari. Riavviare ora?") buttons {"Yes", "No"} default button 1 with icon 1 with title "SSWM")
  
  -- Quit and restart Safari
  if the button returned of choice2 is equal to "Yes" then
   if application "Safari" is running then
    tell application "Safari"
     quit
    end tell
    delay 1
    tell application "Safari"
     activate
    end tell
   end if
  end if
 end if
end if

Il risultato ottenuto è la seguente finestrella :

Abilitare/disabilitare visualizzazione file nascosti nel Finder di Mac Os X

2008-12-14T19:54:00.000+01:00

Nonstante Mac Os X sia davvero semplice ed intuitivo da utilizzare a volte trovare nei menù alcune opzioni può risultare una noia, specialmente per chi, come me, non è dotato di una memoria eccellente.
Ad esempio spesso mi imbatto nel dilemma : "Dov'è la voce di menù del finder per abilitare/disabilitare la visualizzazione dei file nascosi?".
La risposta è ....

Se Maometto non va dalla montagna, la montagna va da Maometto.
Per cui mi sono creato uno script mediante cui abilitare e disabilitare i file nascosti tramite una semplicissima dialog.
Vediamo il codice :

tell application "Finder" to quit

display dialog "Visualizza Files nascosti…" buttons {"Si", "No", "Annulla"} default button 3 with title "File Nascosti"
copy the result as list to {buttonpressed}

try
 if the buttonpressed is "No" then do shell script ¬
  "defaults write com.apple.finder AppleShowAllFiles OFF"
 if the buttonpressed is "Si" then do shell script ¬
  "defaults write com.apple.finder AppleShowAllFiles ON"
end try

tell application "Finder" to launch

E' necessario quindi creare un nuovo file mediante lo script editor, salvare il file ed esegurlo quando desiderate.
Il risultato è il seguente :

Ordinare ArrayList in Java

2008-12-12T10:46:00.000+01:00

In Java è indispensabile a volte dover ordinare collezioni di oggetti in maniera "custom". Se ad esempio avessimo un ArrayList di stringhe e volessimo ordinare tale collezione in ordine lessicologico, basterebbe richiamare il metodo : Collections.sort(arrayList);.
Tale operazione però su altri tipi di oggetti non funziona, poichè bisogna definire i criteri in base ai quali tale collezione andrebbe ordinata.

Ci sono 2 possibili approcci per la risoluzione di questo genere di problematiche.

Modificare la classe facendole implementare l'interfaccia Comparable
E' necessario che l'oggetto che inseriamo all'interno della collection implementi l'interfaccia Comparable e quindi bisogna definire il metodo compareTo che rappresenta il metodo richiamato dal Collections.sort per poter stabilire con quale criterio ordinare.
Vediamo un esempio :

public class MyClass implements Comparable {
public int ordine;
....
 public int compareTo(Object o) {
     if (o!=null){
      MyClass objOfMyClass = (MyClass)o;
      // qui ci arriva solo se i titoli sono uguali o un titolo è nullo quindi confronto i codici edizione
      if (ordine>objOfMyClass.ordine){
       return 1;
      }else{
       if (ordine==objOfMyClass.ordine){
        return 0;
       }
      }
     }
     return -1;
    }
}

Per poter ordinare L'ArrayList quindi basta richiamare il metodo:

List arrayList = new ArrayList ();
arrayList.add(myObj1);
arrayList.add(myObj2);
.....
Collections.sort(arrayList);

Creare una classe che implementa Comparator
Questo metodo necessita la creazione di una classe che funge da "Comparator" tra 2 oggetti. E' necessario quindi che tale classe implementi il metodo compare mediante cui il metodo Collection.sort riesce a stabilire l'ordine richiamandolo con i 2 oggetti che intende confrontare.
Vediamo un esempio :

public class OrderComparator implements Comparator {
    public int compare(Object obj1, Object obj2) {
        if (obj1!=null && obj1!=null){
      MyClass objOfMyClass1 = (MyClass)obj1;
   MyClass objOfMyClass2 = (MyClass)obj2;
      if (objOfMyClass1.ordine>objOfMyClass2.ordine){
       return 1;
      }else{
       if (objOfMyClass1.ordine==objOfMyClass2.ordine){
        return 0;
       }
      }
     }
     return -1;
 }
}

Per poter ordinare L'ArrayList quindi basta richiamare il metodo:

List arrayList = new ArrayList ();
arrayList.add(myObj1);
arrayList.add(myObj2);
.....
Collections.sort(arrayList,new OrderComparator () );

Naturalmente è possibile definire una serie di comparator da utilizzare quando e come si vuole, in maniera tale da poter avere a disposizione diversi criteri di ordinamento per uno stesso tipo di Classe.

Assert in Java : cosa sono e come configurare Eclipse o MyEclipse per poterle utilizzare

2008-12-10T12:26:00.000+01:00

Mi è capitato in questi giorni di aver a che fare con CheckStyle, un progetto openSource che ho scaricato da sourceForge ed ho importato come Java Project nel mio Eclipse.
Mi sono ritrovato davanti ad una serie di errori provocati da alcune istruzioni del tipo assert line != null; la cui sintassi mi era del tutto sconosciuta.
Non ero l'unico a cui era sconosciuta... anche il mio Eclipse segnava tutte le occorrenza di questa keyword con un errore.

Cosa sono le assert?
Le assert sono istruzioni che verificano la verità di una condizione booleana, e provocano la terminazione del programma (mediante il lancio di un AssertionError) nel caso in cui tale condizione risulti falsa. Ad esempio l'istruzione:

assert a + b > 0;

provocherà la terminazione del programma qualora la somma dei valori a e b sia uguale o inferiore a zero. In prima istanza, la semantica dell'assert si riconduce ad una forma compatta per espressioni del tipo:

if(!(a+b>0))
throw new AssertException();

Da un punto di vista tecnico, il costrutto delle assert prevede la possibilità di disabilitare in blocco il controllo delle condizioni: come vedremo più avanti, le assert vengono usate essenzialmente in fase di test e debugging: durante la normale esecuzione, è possibile disabilitarle, eliminando in tal modo l'overhead legato alla loro gestione. Ma esiste anche una differenza assai sottile sul piano filosofico, che rende l'assert un qualcosa di completamente diverso da qualunque altro costrutto presente in Java. Contrariamente a quanto avviene con i costrutti standard dei linguaggi imperativi, una assert non rappresenta un ordine, ma un punto di vista: essa indica una condizione che il programmatore ritiene debba essere vera in un determinato momento dell'esecuzione di un programma. La violazione di tale condizione causerà la terminazione del programma, dal momento che si è verificato qualcosa che il programmatore non aveva previsto. Mai e in nessun caso una assert potrà contenere direttive che influenzino la normale esecuzione del programma.

Come configurare Eclipse o MyEclipse per compilare le assert
Nella versione 3.1 o successive di Eclipse (Per MyEclipse dalla versione 6.0), è necessario accedere al menù Window -> Preferences -> Java -> Compiler e settare per quanto riguarda il gruppo JDK Compliance il Compiler Compliance Level su 1.4 o 5.0 in base alla versione desiderata e selezionare le seguenti voci :

Compiler Compliance Level: 1.4 (o 5.0)
Use default compliance settings : non Selezionata
Generated .class files compatibility: 1.4 (o 5.0)
Source compatibility: 1.4 (o 5.0)
Disallow identifiers called 'assert': Error
.....

In questo modo eclipse dopo aver eseguito il rebuild del progetto riconoscerà tali costrutti e vi permetterà di utilizzarli e compilarli.

Recuperare un oggetto Javascript senza problemi (in popup, frame, etc..)

2008-12-02T13:06:00.000+01:00

Chiunque ami o odi Javascript può trovarsi ad un problema del tipo : "Litigare con la gerarchia degli oggetti oggetti del documento per poterne individuare uno" come ad esempio window.parent.window.opener.document..... A volte questo lavoro è talmente arduo da indurre il programmatore a ridurre la propria pazienza in brandelli.
La perdita di tempo può notevolmente aumentare quando ad esempio si utilizzano popup o frame.
Però una soluzione esiste....

Il sottoscritto non adora dover incorrere 2 volte nello stesso problema, così mi sono creato una funzione alla quale dare in pasto il nome dell'oggetto da recuperare e il nome del primo oggetto non nullo da cui far partire la nostra ricerca.
Ecco il codice :

function takeObject(){                                                             
 objReceived = searchElement("window","objtoFind"); 
 if (objReceived == null){
  alert ('non trovato');
 }else{
  alert(objReceived.value);
 }
}

var ArrayFramesToJump = ["onbeforeunload","onafterprint","top",
 "location","parent","offscreenBuffering","frameElement",
 "onerror","screen","event","clipboardData","onresize","defaultStatus",
 "onblur","window","onload","onscroll","screenTop","onfocus","Option",
 "length","onbeforeprint","frames","self","clientInformation","external",
 "screenLeft","opener","onunload","document","closed","history","Image",
 "navigator","status","onhelp","name"];

String.prototype.endsWith = function(str)
{return (this.match(str+"$")==str)}

Array.prototype.contains = function (element) {
for (var i = 0; i < this.length; i++) {
if (this[i] == element) {
return true;
}
}
return false;
}


function searchElement (lastNotNull,divName){
 
 eval ("var last = "+lastNotNull+";");
 // DEBUG : alert(lastNotNull);
 if (last){
  // document (non posso concatenare 2 document)
  if (!lastNotNull.endsWith("document")){
   eval("var docum = "+lastNotNull+".document;");
   if (docum!=null){
    if (docum.getElementById(divName)!=null){
     alert (lastNotNull+".document.getElementById('"+divName+"')");
     return docum.getElementById(divName);
    }else{
     var objReceived = searchElement(lastNotNull+".document",divName);
                                        if (objReceived !=null){
      return objReceived;
     }
    }
   }
  }
  // parent (evito di avere 2 parent per non incorrere in problemi ma
  // potenzialmente è possibile che ce ne siano 2)
  eval("var par = "+lastNotNull+".parent;");
  if (lastNotNull.indexOf('parent') == -1){
   if (par!=null){
    var objReceived = searchElement(lastNotNull+".parent",divName);
    if (objReceived !=null){
     return objReceived;
    }
   }
  }
  // window (non posso concatenare 2 window
  eval("var windo= "+lastNotNull+".window;");
  if (!lastNotNull.endsWith("window")){
   if (windo!=null){
    var objReceived = searchElement(lastNotNull+".window",divName);
    if (objReceived !=null){
     return objReceived;
    }
   }
  }
  // opener
  eval("var ope= "+lastNotNull+".opener;");
  if (ope!=null){
   var objReceived = searchElement(lastNotNull+".opener",divName);
   if (objReceived !=null){
    return objReceived;
   }
  }
 
 // tutti i frame fratelli
  if (lastNotNull.endsWith("parent")){
   eval("var frameset= "+lastNotNull+".frames;");
   if (frameset){
    // se esiste il frameset
    for (var framecurr in frameset) {
     if (!ArrayFramesToJump.contains(framecurr)){
      var currframeObj = frameset[framecurr];
      if (currframeObj!=null){
       // se ho intercettato il frame
       var objReceived = searchElement(lastNotNull+".frames['"+framecurr+"']",divName);
       if (objReceived !=null){
        return objReceived;
       }
       }
     }
    }
   }
 }
 }
 return null;
}

// richiamo la funzione 
takeObject();

Come si può notare la funzione esegue ricorsivamente la ricerca dell'oggetto, senza ingappare in loop infiniti visto che in Javascript ad esempio è possibile utilizzare window.window oppure window.parent.window.parent.
Il risultato è il riferimento all'oggetto nel caso venga trovato o null per un esito negativo della ricerca.
Spero sia utile a farvi risparmiare un sacco di tempo.

Terminale colorato su Mac Os X

2008-11-30T19:20:00.000+01:00

Potrebbe risultare "simpatico" perchè di utilità ha ben poco, rendere il terminale di Mac Os X colorato come potete trovarlo su diverse distro di Linux.

Il primo passo da eseguire è editare il file /private/etc/bashrc con il seguente comando :

nano /private/etc/bashrc

Basterà quindi appendere in coda al vostro file le seguenti righe :

case $TERM in
xterm* | aterm | rxvt | screen )
PROMPT_COMMAND='echo -ne "\033]0;${PWD/$HOME/~}\007"'
;;
* )
;;
esac

PS1='\[\e[33m\]\u\[\e[36m\]@\[\e[31m\]\h\[\e[32m\]:\W\[\e[0m\]> '

alias ls='ls -G'
LSCOLORS='gxbxcxdxexegedabagabce'
export LSCOLORS

Salvate il file e riavviate il terminale. Otterrete come risultato il vostro terminale colorato.
Naturalmente i colori potrete modificarli a vostro piacimento nel seguente modo :
Per cambiare i colori bisogna modificare l'assegnazione di LSCOLORS, dove ogni coppia di due lettere corrisponde all'effetto che otterrete sull'oggetto(1: colore testo - 2: colore sfondo) a cui si riferisce secondo questo elenco:

a nero
b rosso
c verde
d marrone
e blu
f magenta
g ciano
h grigio chiaro
A nero matto, solitamente visualizzato come grigio scuro
B rosso matto
C verde matto
D marrone matto, solitamente visualizzato come giallo
E blu matto
F magenta matto
G cyan matto
H grigio chiaro matto; sembra color panna
x sfondo o scritta del colore prefefinito

Per quanto riguarda le posizioni :

1. directory
2. link simbolico (alias)
3. socket
4. pipe
5. eseguibile
6. blocco speciale
7. carattere special
8. eseguibile con setuid bit impostato
9. eseguibile con setgid bit impostato
10. directory scrivibile da altri, con sticky bit
11. directory scrivibile da altri, senza sticky bit
12. Quindi prendendo la seguente 'gxbxcxdxexegedabagabce' si ottiene:

gx bx cx dx ex eg ed ab ag ab ce

ed interpretandola con l'oggetto che va a puntare risulta:

1) directory -> gx (g = ciano | x = sfondo di default) -- ottengo le directory colorate di ciano
2) link simbolico -> bx (f = rosso | x = sfondo di default) -- ottengo gli alias di colore rosso

e così via, ricordando che la prima lettera è il colore della scritta mentre la seconda si riferisce al colore dello sfondo. Se io per esempio (qui sopra) al posto di "gx" mettessi "bf" otterrei "scritta rossa su sfondo magenta".

Inviare file come allegato mediante il Finder di Mac Os X

2008-11-27T23:03:00.000+01:00

La potenza di Mac Os X come OS risiede proprio nella caratteristica di riuscire ad eseguire qualunque operazione con un numero di click davvero minimi. E' un OS davvero incredibile, ma nella sua incredibilità alcune funzionalità sembrano mancare, come ad esempio la possibilità di Inviare un file come allegato di una mail mediante il menù contestuale (quello che si ottiene mediante la pressione del tasto destro del mouse).

Per questo motivo ho creato uno script mediante cui, una volta aggiunto, è possibile selezionare uno o più file tramite il finder, premere il tasto destro del mouse e trovare sotto la voce Automator -> Invia tramite Mail.
Quello che bisogna fare sono i seguenti passi:
Aprire Automator
Creare un nuovo Script ad Hoc
Incollare il seguente script :

on run {input, parameters}
 tell application "Mail"
  set new_message to make new outgoing message with properties {visible:true}
  repeat with theItem in input
   set selectedItem to (theItem) 
   tell content of new_message
    make new attachment with properties {file name:selectedItem} at after last paragraph
   end tell
  end repeat
 end tell
 return input
end run

Scegliere dal menù Archivio->Registra come plugin
Inserire come nome : Invia come allegato di posta elettronica
Scegliere nella combobox "Plugin in" la voce : Finder.

Adesso avrete questa funzionalità anche con Mac Os X.

Interpetare il Javascript incluso in un DIV mediante innerHTML con Ajax

2008-11-25T21:11:00.000+01:00

Una classica modalità di utilizzo di Ajax è quella in cui in maniera asincrona viene chiamata una pagina (jsp,aspx,php,..) la quale alla fine della propria esecuzione restituisce al controller Ajax l'html ottenuto.
Nella maggiorparte dei casi si tende ad utilizzare tale html per visualizzare nella pagina chiamante il risultato ottenuto in un DIV senza dover ricaricare la pagina.
Un problema in cui si incorre in questa tipologia di approccio è rappresentato dall'interpretazione da parte del browser del javascript che può essere contenuto in questa pagina inclusa all'interno del DIV.
Il problema stà nel fatto che il browser, carica i javascript man mano che carica la pagina, quando in maniera asincrona si và a "riempire" un div mediante la proprietà innerHTML, il browser non si preoccupa di caricare i javascript contenuti.

A volte, quando non si ha la necessità di dover generare gli script in maniera dinamica, è possibile ovviare a tale problema includendo il codice all'interno della pagina principale. In altri casi è necessario costruire gli script in maniera dinamica, quindi può essere davvero utile adottare la seguente strategia per poter risolvere il problema.
Il sorgente seguente rappresenta la pagina principale.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
    <title>Pagina senza titolo</title>
    <script type="text/javascript" src="../js/libreria.js"></script>
<script language="javascript" type="text/javascript">
// <!CDATA[

function Button1_onclick() 
{
    //faccio la richiesta alla pagina php o jsp che restituisce
    //<p>Ciao</p><_script language=\"javascript\">alert('pippo')</_script>
    ajax("a.asp", onload);
    function onload()
    {
        //t contiene la risposta
        var t = this.request.responseText;
        
        //execJS esegue javascript contenuto in t e restituisce
        //t senza javascript
        t = execJS(t);
        
        //finalmente metto t 'pulito' dento il div
        $("div1").innerHTML = t;
        
    }
}



// ]]>
</script>
</head>
<body>
    <input id="Button1" type="button" value="button" onclick="return Button1_onclick()" />
    <div id="div1"></div>
</body>
</html>

La funzione javascript execJS è definita così:

function execJS(t)
{
    var p1 = 0, p2 = 0, p3 = 0, p4 = 0;
    p1 = t.indexOf("<" + "script", 0);
    if(p1 == -1) return t;
    
    p2 = t.indexOf(">", p1 + 7) + 1;
    p3 = t.indexOf("<" + "/script>", p2);
    p4 = p3 + 9;
    
    var c = t.substring(p2, p3);
    var s = document.createElement("script");
    s.type = "text/javascript";
    s.text = c;
    document.getElementsByTagName("head")[0].appendChild(s);
    
    t = t.substring(0, p1) + t.substr(p4);
    return execJS(t);

}

Inserire solo numeri in un Input Text

2008-11-25T15:59:00.000+01:00

Ecco un piccolo javascript tramite il quale permettere ad una textbox di accettare solamente cifre durante la digitazione.

function isNumberKey(evt){
   var charCode = (evt.which) ? evt.which : event.keyCode
   if (charCode > 31 && (charCode < 48 || charCode > 57))
      return false;

   return true;
}

Questo script può essere utilizzando in maniera semplicissima all'interno del tag HTML nel seguente modo:

<input type="text" name="codice" maxlength="7" size="8" onkeypress="return isNumberKey(event)">

Stampare in Javascript il contenuto di un DIV

2008-11-25T13:07:00.000+01:00

Ecco un utile funzione per stampare il contenuto di un solo div mediante la funzione window.open di javascript.

Il codice da utilizzare è il seguente:

<script>
function printDiv()
{
 var a = window.open('','','width=300,height=300');
 a.document.open("text/html");
 a.document.write(document.getElementById('foo').innerHTML);
 a.document.close();
 a.print();
}
</script>
<div id="foo">stuff to print</div>
<input type="button" onclick="printDiv()" value="print div">

Come clonare un oggetto Java

2008-11-25T09:51:00.000+01:00

Un giorno mi sono imbattuto in un problema alquanto strano, in cui magari si sarà imbattuto chi, come me, ha iniziato a programmare in linguaggi come C o C++ in cui la referenza agli oggetti e il relativo passaggio parametri per valore o per riferimento essendo esplicito era facilmente gestibile.
In Java tutti gli oggetti vengono passati per riferimento, tranne alcuni come le Stringhe ad esempio, per cui ci si può imbattere nell'utilizzo di uno stesso bean in più contesti. Il problema si presenta nel caso in cui venga modificato il valore di qualche proprietà del bean in una parte remota del codice, quindi in tutti i contesti lo stesso viene utilizzato presenterà tali informazioni variate. In alcuni casi è necessario quindi eseguire una copia dell'oggetto. Per questo ci torna utile il metodo Clone.

Il metodo clone per gli Object è di tipo protected, quindi richiamare il metodo clone su un qualsiasi oggetto porta ad un problema di compilazione. E' necessario in primo luogo ridefinire il metodo clone , in secondo luogo implementare l'interfaccia Clobeable in modo tale da non incorrere in un eccezione di tipo CloneNotSupportedException. Il codice corretto risulta quindi:

class A implements Cloneable {
        private int x;
        public A(int i) {
            x = i;
        }
        public Object clone() {
            try {
                return super.clone();
            }
            catch (CloneNotSupportedException e) {
                throw new InternalError(e.toString());
            }
        }
        public int getx() {
            return x;
        }
    }
    
    public class CloneDemo3 {
        public static void main(String args[])
          throws CloneNotSupportedException {
            A obj1 = new A(37);
            A obj2 = (A)obj1.clone();
            System.out.println(obj2.getx());
        }
    }

Javascript, aggiungere options ad una selectbox

2008-11-10T20:09:00.001+01:00

Una problematica classica di chiunque utilizzi javascript è quella di dover aggiungere delle option alle selectbox.
E' possibile facilitarsi il compito creando delle opportune funzioni alle quali passando l'id della select box e un elenco (in questo caso map da cui recuperare le opzioni da inserire nella select box esistente aggiorna la textbox senza dover ricaricare la pagina.
Queste funzioni sono utilissime qualora si stessero utilizzando framework Ajax come ad esempio Dwr. In tal caso è sufficiente richiamarle come postback di una chiamata asincrona mediante Ajax.

Ecco un esempio di un metodo che svolge questo compito:

 // metodo per aggiornare qualsiasi tipo di elenco di options
 // per id si intende l'id della selectbox
 function addOptionValues(_id,_map){ 
     var sel = document.getElementById(_id);
     var opt = null;
     if(sel != null){
         for(var prop in _map) {
             opt=document.createElement("option");
             opt.setAttribute("value",prop);
             opt.appendChild(document.createTextNode(_map[prop]));
             sel.appendChild(opt);
         }
     }
 }

Una possibile estensione è la seguente, in cui oltre a specificare l'elenco delle opzioni da aggiungere, ne seleziona una specifica il cui valore viene passato in input :

// metodo per aggiornare qualsiasi tipo di elenco di options selezionandone una
 // per id si intende l'id della selectbox
 function addOptionValuesSel(_id,_map,selez){
  var sel = document.getElementById(_id);
     var opt = null;
     if(sel != null){
         for(var prop in _map) {
             opt=document.createElement("option");
             opt.setAttribute("value",prop);
             if (prop == selez){
              opt.setAttribute("selected","selected");
             }
             opt.appendChild(document.createTextNode(_map[prop]));
             sel.appendChild(opt);
         }
     }     
 }

Recuperare parametri da QueryString con Javascript

2008-11-10T20:03:00.000+01:00

In Javascript può essere utile un metodo per recuperare un determinato parametro da QueryString. Vediamo come poter scrivere una funzione javascript che invocata con il nome del parametro ci restiruisce il valore associato.

// recuperare parametro query string
function queryString(parameter) { 
  var loc = location.search.substring(1, location.search.length);
  var param_value = false;

  var params = loc.split("&");
  for (i=0; i< params.length;i++) {
      param_name = params[i].substring(0,params[i].indexOf('='));
      if (param_name == parameter) {
          param_value = params[i].substring(params[i].indexOf('=')+1)
      }
  }
  if (param_value) {
      return param_value;
  }
  else {
      return false; //Nel caso in cui nn ci siano parametri
  }
}

Contare righe di codice di un progetto Java

2008-11-09T15:58:00.001+01:00

Potrebbe tornare utile, forse più per questioni di esaltazione personale che per reale utilità, uno script mediante il quale avere un elenco delle righe di codice di un determinato progetto.

Il seguente script oltre a fornire un elenco completo dei files, con relativo numero di codice, esegue anche la somma degli stessi.

find . \( -name '*.java' -o -name '*.jsp' \) -print0 | xargs -0 wc -l

E' possibile modificare il riferimento al path cambiando il "." dopo il comando con qualsiasi percorso assoluto o relativo.
E' inoltre possibile adattarlo a qualsiasi linguaggio, cambiando i filtri relativi all'estensione del file "*.java" o "*.jsp".

Come creare un Singleton in Java o Php

2008-11-07T21:50:00.000+01:00

Il Singleton è un design pattern creazionale, il suo scopo è assicurare che una classe abbia una sola istanza e fornire un punto di accesso globale a tale istanza. Questo può essere usato ad esempio per caricare delle informazione da database e gestirle durante tutto il flusso dell'applicazione senza doverle necessariamente ricaricare. Un suo utilizzo ponderato può renderne l'utilizzo davvero vantaggioso.

Guardiamo un esempio di Singleton in Java. Il codice presenta un metodo opzionale : invalidate
che invalida la prima istanza della classe, forzandone la creazione di una nuova istanza nel successivo accesso alla classe.

public class Singleton {
 private static Singleton instance;
 
 public static Singleton getInstance(){
  if (instance == null) instance = new Singleton();
  return instance;
 }
 
 public static void invalidate(){
  instance = null;
  // si possono invalidare eventuali altre proprietà della classe
 }
 
 private Singleton(){
  // qui si eseguono le eventuali operazioni di inizializzazione delle informazioni necessarie
 }
}

Ecco un implementazione alternativa in PHP.

/**
* Semplice implementazione del design pattern singleton.
* Data la struttura sintattica di PHP non è possibile sfruttare l'ereditarietà
* per poter riutilizzare il pattern, se non utilizzando piccoli stratagemmi sintattici.
*/
class MySingleton
{
   /**
   * La variabile statica privata che conterrà l'istanza univoca
   * della nostra classe.
   */
   private static $instance = null;
   
   /**
   * Il costruttore in cui ci occuperemo di inizializzare la nostra
   * classe. E' opportuno specificarlo come privato in modo che venga
   * visualizzato automaticamente un errore dall'interprete se si cerca
   * di istanziare la classe direttamente.
   */
   private function __construct()
   {
      // ... codice ...
   }
   
   /**
   * Il metodo statico che si occupa di restituire l'istanza univoca della classe.
   * per facilitare il riutilizzo del codice in altre situazioni, si frutta la
   * costante __CLASS__ che viene valutata automaticamente dall'interprete con il
   * nome della classe corrente (ricordo che "new $variabile" crea un'istanza della classe
   * il cui nome è specificato come stringa all'interno di $variabile)
   */
   public static function getInstance()
   {
      if(self::$instance == null)
      {   
         $c = __CLASS__;
         self::$instance = new $c;
      }
      
      return self::$instance;
   }
}

java.lang.IllegalThreadStateException problema restart di un thread java

2008-11-02T22:30:00.000+01:00

In alcuni casi è necessario dover gestire un numero di thread paralleli considerevole.
Si noti che in queste situazioni si presenta un deterioramento delle prestazioni dovuto principalmente al costo computazione di creazione e distruzione dei thread.
In questi casi è opportuno sviluppare una strategia tale da riuscire a riutilizzare i thread senza crearne altri. Il problema è che in Java, dopo aver creato un thread non è possibile riavviare la propria esecuzione mediante il metodo start().

Ecco un esempio di come creare un thread, escogitando un metodo per poterne gestire il "re"start.

public class MyThread extends Thread{ 
 public Integer semaforoThread = new Integer(0);
 // metodo run
 public void run(){
  try{
   while(true){
    // codice da far eseguire al thread
    ....
     
    synchronized(semaforoThread){
     semaforoThread.wait();
    }
   }
  }catch(InterruptedException e){
   System.out.println("Problemi con il thread : "+e.getMessage());
  }
 }
 // metodo per far ripartire il thread
 public void restart(){
  synchronized (this.semaforoThread) {
   this.semaforoThread.notify();
  }
 }
}

Questo è il codice per poter utilizzare tale thread :

MyThread thread = new MyThread();
thread.start();
....
// si intende restartare il thread
thread.restart();

Riconoscere funzionalità e verisione dei browser con javascript

2008-10-31T12:07:00.001+01:00

Chiunque abbia mai utilizzato un linguaggio di scripting client side come Javascript ad un livello medio-avanzato, si sarà trovato di fronte al problema della compatibilità del codice scritto da parte del motore javascript del proprio browser.
In questo caso è stato sicuramente necessario distinguere diversi comportamenti in base alle diverse funzionalità attive nel browser.

Ecco un esempio di distinzione di tali funzionalità e versioni del browser.

// recupero le informazioni del browser
var AgntUsr=navigator.userAgent.toLowerCase();

// controllo se il browser utilizza i dom
var DomYes=document.getElementById?1:0;

// controllo se il browser è firefox
var NavYes=AgntUsr.indexOf('mozilla')!=-1&&AgntUsr.indexOf('compatible')==-1?1:0;

// controllo se il browser è explorer
var ExpYes=AgntUsr.indexOf('msie')!=-1?1:0;

// controllo se il browser è opera
var Opr=AgntUsr.indexOf('opera')!=-1?1:0;

// controllo se si tratta di una versione di opera maggiore o uguale alle 6
var Opr6orless=window.opera && navigator.userAgent.search(/opera.[1-6]/i)!=-1 //DynamicDrive.com added code

// controllo se viene utilizzato il modello dom di firefox
var DomNav=DomYes&&NavYes?1:0;

// controllo se viene utilizzato il modello dom di explorer
var DomExp=DomYes&&ExpYes?1:0;

// controllo se si utilizza una versione di firefox che non utilizza i dom 
var Nav4=NavYes&&!DomYes&&document.layers?1:0;

// controllo se si utilizza una versione di exlorer che non utilizza i dom
var Exp4=ExpYes&&!DomYes&&document.all?1:0;

// controllo se la versione di explorer è la 7
var ie7 = ExpYes&&typeof document.body.style.maxHeight != "undefined"?1:0;

// controllo se la versione di explorer è la 6
var ie6 = ExpYes&&!ie7?1:0;

Naturalmente chi volesse segnalare altri generi di controlli lo faccia e questi verranno aggiunti.

Problema di Out Of Memory di Eclipse o MyEclipse su Mac OS X

2008-10-16T23:53:00.000+02:00

Recentemente ho avuto un problema di Out of Memory con MyEclipse 6.0 su Mac OS X.
Così come su altre piattaforme e con altre versioni di Eclipse per poter ovviare a questo problema è necessario editare il file eclipse.ini aumentando la dimensione massima dell' heap e la PermGen size.
Su mac tale file è un pò nascosto infatti bisogna modificare il file Eclipse.app/Contents/MacOS/eclipse.ini. Per poter accedere con il Finder è necessario cliccare con il tasto destro sul file eclipse.app e scegliere "mostra contenuto pacchetto" quindi entrare nella cartella Contents > MacOS e modificare il file eclipse.ini. In particolare il parametro XX:MaxPermSize è possibile aumentarlo fino a 256m

Ecco il mio file .ini


-vmargs
-Dosgi.splashLocation=/Applications/MyEclipse 6.0/eclipse/MyEclipseSplash.bmp
-showsplash
org.eclipse.platform

-Xdock:icon=../Resources/Eclipse.icns
-XstartOnFirstThread
-Xms512m
-Xmx1024m
-XX:MaxPermSize=256m
-Xdock:name=MyEclipse
-Dorg.eclipse.swt.internal.carbon.smallFonts

Spero di esservi stato utile anche questa volta.

Ottenere il numero di righe recuperate da un ResultSet

2008-10-13T22:35:00.000+02:00

Una domanda che prima o poi uno sviluppatore Java si pone è : come posso recuperare il numero di risultati di una query da un java.sql.ResultSet.
La risposta potrebbe sembrare non banale, ma lo è in quanto di default i ResultSet vengono istanziati in maniera sequenziale, ma ciò può essere modificato mediante un opportuna dichiarazione, con cui è possibile accedere ai dati in maniera non sequenzioale. E' possibile infatti muoversi anche in senso opposto, oppure accedere direttamente ad una riga.

Vediamo un esempio di codice:

PreparedStatement pstmt4 = medpConnection.prepareStatement(
    "SELECT * FROM USERS",
    ResultSet.TYPE_SCROLL_INSENSITIVE, 
    ResultSet.CONCUR_READ_ONLY);

Vediamo ora come si può recuperare il numero di righe ottenute come risultato dalla query:

ResultSet rs4 =  pstmt4.executeQuery();
rs4.last();
int numberList = rs4.getRow();
rs4.beforeFirst();

In questo modo si posiziona il ResultSet in ultima riga ottenuta, si recupera il numero della riga e si riposiziona il ResultSet nella posizione iniziale, cioè prima del primo risultato.
In tal modo è possibile utilizzare il ResultSet in un semplicissimo ciclo del tipo:


while (rs4.next()) {
...
}

Eseguire un unica istanza di un'applicazione Java

2008-10-10T15:39:00.000+02:00

Tempo fa mi sono imbattuto nel dilemma su come gestire in Java l'esecuzione di una sola istanza di una determinata applicazione, la rete mi è stata d'aiuto proponendomi una serie di soluzioni.
Una soluzione trovata è quella di recuperare tale informazione dall'elenco dei Thread in esecuzione, ma a parer mio è la peggiore.

Un altra soluzione è quella di istanziare un Server Socket su una determinata porta nel main dell'applicazione, nel caso in cui tale porta sia stata già Bindata, significa che si tratta della seconda istanza della stessa applicazione.

Una terza la soluzione, la migliore a pare mio è quella Unix Like in cui si esegue il lock su di un file durante l'esecuzione e sbloccare il lock al termine della stessa.

Di seguito l'esempio sul mio esempio di implementazione :

public class JustOneLock {
    private String appName;
    private File file;
    private FileChannel channel;
    private FileLock lock;

    public JustOneLock(String appName) {
        this.appName = appName;
    }

    public boolean isAppActive() {
        try {
            file = new File(System.getProperty("user.home"), appName + ".tmp");
            channel = new RandomAccessFile(file, "rw").getChannel();
            try {
                lock = channel.tryLock();
            } catch (OverlappingFileLockException e) {
                // il file è già loccato
                closeLock();
                return true;
            }

            if (lock == null) {
                closeLock();
                return true;
            }

            Runtime.getRuntime().addShutdownHook(new Thread() {
                    // distrugge il lock quando la JVM viene chiusa
                    public void run() {
                        closeLock();
                        deleteFile();
                    }
                });
            return false;
        }
        catch (Exception e) {
            closeLock();
            return true;
        }
    }

    // metodo per chiudere il lock sul file
    private void closeLock() {
        try { 
            lock.release();  
        }catch (Exception e) {  
            
        }
        try { 
            channel.close(); 
        }
        catch (Exception e) {  
        }
    }
    
    // metodo per cancellare il file di lock
    private void deleteFile() {
        try { 
            file.delete(); 
        }
        catch (Exception e) { 
        }
    }
}

Vediamo ora come utilizzare tale classe :

JustOneLock ua = new JustOneLock("JustOneId");
 
if (ua.isAppActive()) {
    System.out.println("Applicazione già in esecuzione. ");
}else {
    // caso in cui si tratta della prima istanza dell'applicazione
        System.out.println("Applicazione eseguita");
}

Spero che questo esempio sia stato utile. Alla prossima

Centrare a video una componente AWT o SWING

2008-10-09T12:33:00.001+02:00

Ecco un semplice hint per centrare a video un qualsiasi componente Swing o Awt come ad esempio un frame.

public static void centra(Component componente){
   Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
   componente.setLocation((int) (dim.getWidth() - componente.getWidth()) / 2,
   (int) (dim.getHeight() - componente.getHeight()) / 2);
}

N.B. Il meotod accetta un oggetto di tipo Component che non è altro che la classe da cui derivano le componenti Awt e Swing.
Si potrebbe quindi creare un metodo apposito per ogni tipo di componente, altrimenti accettare in input un Component e gestire in maniera generica ogni tipo di oggetto che ne deriva.

Server RMI + Registry + Client Rmi

2008-10-06T20:33:00.000+02:00

Java Remote Method Invocation (Java RMI) non è altro che una tecnologia Java per la gestione degli oggetti distribuiti. Nell' RMI i metodi di un oggetto remoto possono essere invocati dal client ubicato anche su un altra istanza di Java Virtual Machine.
La potenza è proprio nel fatto di poter recuperare un istanza ben precisa di oggetto senza avere a disposizione l'implementazione di tale classe e invocarne i metodi mediante lo stub messo a disposizione dal server.

Ho utilizzato RMI per un progetto universitario e la mia difficoltà è stata quella di recuperare informazioni chiare e dettagliate su come realizzare un Server in grado di istanziare un Registry.
Il Registry non è altro che una sorta di elenco telefonico che converte una determinata stringa (ES: rmi://localhost/nomeOggetto ) in una vera e propria istanza di tale oggetto remoto.
Esaminiamo i package che ci fornisce Java per tale architettura:

import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;

Passiamo alla vera e propria implementazione :

public class Runner{
    public static int DEFAULT_PORT = 6669;
    
    // main
    public static void main(String[] args) throws RemoteException{
        int port = DEFAULT_PORT;
        if (args.length>0){
            try{
                port = Integer.parseInt(args[0]);
            }catch(NumberFormatException ex){
                System.out.println("Formato utilizzato per il numero di porta non valido ");
            }
        }
        try{
            Registry registry = LocateRegistry.getRegistry(port);
            bindObjectInRegistry(registry);
        }catch(RemoteException ex){
            System.out.println("Registry non raggiungibile ");
            try{
                Registry registry = LocateRegistry.createRegistry(port);
                System.out.println("Creato registry in ascolto sulla porta : "+port);
                bindObjectInRegistry(registry);
            }catch(RemoteException e){
                System.out.println("Problemi nel creare il registry");
            }
        }
    }
    /***
     * Metodo che esegue il bind di un oggetto su un registry passatogli in input
     * 
     * @param registry            : registry allocato
     * @throws RemoteException    : eccezione remota
     */
    private static void bindObjectInRegistry(Registry registry) throws RemoteException{
        CentralizedSrvIF remoteReference = 
            (CentralizedSrvIF) UnicastRemoteObject.exportObject(new CentralizedSrv());
        registry.rebind(CentralizedSrvIF.SHAREDOBJECTNAME, remoteReference);
        System.out.println("Oggetto registrato");
    }
}

Osserviamo che il server tenta di linkarsi al registry e nel caso in cui non trova un istanza dello stesso lo istanzia su una porta di default (nel caso in cui non venga specificata da riga di comando).
Attenzione CentralizedSrvIF non è altro che l'implementazione dell'interfaccia dell'oggetto remoto come da esempio :

public interface CentralizedSrvIF extends Remote{
    // nome dell'oggetto remoto
    public static final String SHAREDOBJECTNAME ="chatRoomManager";
    // metodo per entrare in una chatRoom
    public UserID[] joinChat(String chatRoomName, String userName, Integer port) throws UserAlreadyExistException,RemoteException,UnknownHostException;
    // metodo per abbandonare la chatroom
    public void leaveChat(String chatRoomName, UserID theUser) throws RemoteException;    
}

La relativa implementazione è una classica implementazione custom dei metodi specificati nell'interfaccia.
Passiamo ora all'implementazione del client :

public class ChatClient {
    public static final String SHAREDOBJECTNAME ="chatRoomManager";
    
    try{
            
            // connetto al server e recupero l'oggetto 
            String name = "rmi://"+host+":"+portRmi+"/"+SHAREDOBJECTNAME;
            System.out.println("Bindato oggetto : "+name);
            Remote obj = Naming.lookup(name);
            CentralizedSrvIF chatServer = (CentralizedSrvIF)obj;
            System.out.println("Connesso al server");
            ....
            // chiamo il metodo remoto
            UserID[] sdd = chatServer.joinChat(chatRoomName, userName, new Integer(port));
            System.out.println("Connesso alla chatRoom : "+chatRoomName);
            // rebindo l'oggetto salvandone le modifiche
            Naming.rebind(name, obj);
        }catch(MalformedURLException e){
            System.out.println("Problema con l'url : "+e.getMessage());
        }catch(IOException e){
            System.out.println("Problema in input/output :"+e.getMessage());
        }catch(NotBoundException e){
            System.out.println("Problema con il lookup : "+e.getMessage());
        }catch(UserAlreadyExistException ex){
            System.out.println("Problema : "+ex.getMessage());
        }
    }
}

Prestare particolare attenzione al metodo Rebind, con esso si sostituisce l'istanza bindata mediante il registry, sovrascrivendo lo stato dell'oggetto con il nuovo stato dell'istanza corrente.
Spero che questo esempio sia servito a chiarire i vostri dubbi nei confronti dell' RMI.

Thread Concorrenti in Java

2008-09-28T10:47:00.000+02:00

In alcuni casi, quando ci si trova nella situazione in cui vengono eseguiti diversi task in sequenza, ciascuno dei quali è indipendente dagli altri, e si ha la necessità di dover ridurre i tempi di elaborazione, strutturare il coidice in maniera tale da eseguire thread paralleli può essere una soluzione.
Nel mio esempio si ha la necessità di eseguire 3 chiamate a WebServices, che come ben sapete sono chiamate sincrone (bloccano il processo chiamante fino ad una risposta o un failure), quindi il tempo totale di esecuzione è dato da :

_{n_task}
  ∑     ExecTime(i)
 ⁱ⁼⁰

Introducendo una strategia di gestione mediante thread paralleli si può ridurre il tempo di esecuzione al :

_{n_task}
  Max(ExecTime(i))
 ⁱ⁼⁰

Supponiamo di modificare il codice di una classe ClassSample inserendo tra le proprietà le seguenti 3 dichiarazioni:

public Integer cont = new Integer(0);
public Integer sincronizzatore = new Integer(0);
public static final int NUM_THREAD = 3;

La variabile cont rappresenta il contatore dei thread che hanno già terminato la propria esecuzione.
La variabile sincronizzatore rappresenta l'oggetto che funge da sincronizzatore.
La variabile statica NUM_THREAD che rappresenta il numero di thread che verranno eseguiti (tale numero è statico ma può dipendere dal contesto)

A questo punto è necessario definire i Thread, nel mio esempio assumiamo che i thread siano delle chiamate a servizi Web che come ben sapete sono chiamate bloccanti :

class Servizio1Thread extends Thread { 
        /***
         * Metodo run per avviare il thread
         */
        public void run() { 
            // Parte thread Ws
            RisultatoServizio risultatoServizio = chiamoServizio(parametro1,parametro2);
            controllaSemaforo();
            
        }
    }

Definiamo la funzione che controlla l'esecuzione di tutti i Threads

>/***
 * Metodo controllore dei thread completati. Nel caso in cui
 * siano stati completati tutti i thread invoca una notifica al thread
 * principale che è temporaneamente in stato di wait
 */
public void controllaSemaforo (){
    synchronized (sincronizzatore){
        logger.debug("processi chiusi "+(cont.intValue()+1)+"/"+NUM_THREAD);
        if (cont.intValue()+1<NUM_THREAD){
            cont = new Integer(cont.intValue()+1);
        }else{
            logger.debug("notifico al thread principale");
            sincronizzatore.notifyAll();
        }
    }
}

Ora passiamo all'implementazione del Thread principale, che si occuperà di lanciare i 3 Thread paralleli e attenderne il completamento prima di continuare con il normale flusso di esecuzione.

//Thread 1 
Servizio1Thread myFirstThread = new Servizio1Thread ();
myFirstThread.start();
//Thread 2 
Servizio2Thread  myRirThread = new Servizio1Thread ();
myRirThread.start();
//Thread 3 
Servizio3Thread  myWsThread = new Servizio1Thread ();
myWsThread.start();

try{
    
    // blocco sincronizzato per attendere i risultati
    synchronized(sincronizzatore) {
        //Fermo il thread principale
        sincronizzatore.wait();
        // Hanno finito i thread che hanno sbloccato l'esecuzione del Thread principale
    }
    // qui continua il normale flusso di esecuzione
}catch(InterruptedException ex){
    System.out.println("Eccezione : "+ex.getMessage());
}

Naturalmente si può giocare con le chiamate in maniera opportuna all'operazione che si intende eseguire. Spero che tale soluzione velocizzerà le vostre applicazioni. Alla prossima!

Problemi plugin Maven4MyEclipse nella gestione di un progetto Java su MyEclipse 6.5 GA

2008-09-27T21:10:00.000+02:00

L'ultima versione di Myclipse, in particolare la 6.5 GA include nella propria Relese un plugin proprietario per Maven(Maven4MyEclipse).
Nel caso in cui si voglia creare un nuovo progetto con il supporto di Maven, non si verifica nessun tipo di problema nell'includere nel classpath le librerie referenziate importate mediante il vostro pom.xml.

Il problema sorge quando importate un progetto Java già esistente, in tal caso switchare tra apache maven plugin e maven4myeclipse presenta un incompatibilità delle informazioni contenute all'interno dei files: .classpath and .project .

La soluzione ottimale è la seguente, almeno finchè gli sviluppatori rilascieranno un altra versione, magari con un bugFix per una capability così importante.

Innanzitutto editare il file .project che dovrà presentarti con la seguente struttura. N.B : il tag

<buildCommand>
   <name>org.maven.ide.eclipse.maven2Builder</name>
   <arguments>
   </arguments>
</buildCommand>

Inoltre rimpiazzare l' org.apache maven nature con :

<nature>com.genuitec.eclipse.maven.maven2Nature</nature>

Nel file .classpath aggiungere la entry ;

<classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/>

Inserire un CLOB

2008-09-27T07:17:00.000+02:00

Come alcuni sapranno, in una pl/sql il numero massimo di caratteri consentiti per una variabile è di 32.000 e questo può risultare un problema quando ad esempio si esporta una riga contenente un CLOB e si vuole reinserire il contenuto del campo di tipo clob mediante pl/sql.

Per questo ho escogitato un workaround non flessibilissimo, ma che funziona.

DECLARE
lob_loc       CLOB;
amount       INTEGER;
writeAmount    BINARY_INTEGER;
intermediaField CLOB;
newData CLOB;
primaParte VARCHAR2(4000);
lunPrimaParte INTEGER;
secondaParte VARCHAR2(4000);
lunSecondaParte INTEGER;
terzaParte VARCHAR2(4000);
lunTerzaParte INTEGER;
BEGIN

  DBMS_LOB.createtemporary(intermediaField, true); 
  primaParte := 'testo prima parte';
  secondaParte := 'testo seconda parte';
  terzaParte:= 'testo terza parte';
  lunPrimaParte := length(primaParte);
  DBMS_LOB.write(intermediaField, lunPrimaParte, 1, primaParte);
  lunSecondaParte := length(secondaParte);
  DBMS_LOB.writeappend(intermediaField, lunSecondaParte, secondaParte);
  lunTerzaParte := length(terzaParte);
  DBMS_LOB.writeappend(intermediaField, lunTerzaParte, terzaParte);    

  SELECT CAMPOCLOB INTO lob_loc FROM TABELLAESEMPIO
  WHERE NUMEROCLOB = 18
  FOR UPDATE;

  /*cancello il contenuto del CLOB */
  amount := DBMS_LOB.getlength(lob_loc);
  IF amount > 0 THEN
     DBMS_LOB.erase(lob_loc, amount, 1);
  END IF;
  writeAmount := DBMS_LOB.getlength(intermediaField);
  DBMS_LOB.copy(lob_loc, intermediaField, writeAmount, 1, 1);

END;

My First Blog

2008-09-21T23:25:00.000+02:00

Sul web sono pubblicati blog di molteplici categorie ormai, la rete è colma di wiki, pubblicazioni, portali dove si può trovare la soluzione a qualsiasi tipo di problema.

Questo blog vuole essere una sorta di raccoglitore di tutte quelle che sono le esperienze vissute sul campo da uno sviluppatore smanettone.

L'obiettivo è quello (così come avrete sicuramente letto nel sottotitolo del blog) di condividere le mie esperienze con gli altri in maniera tale da poter evitare sprechi di tempo inutili.

Durante la mia giornata è routine ormai quella di ricercare informazioni sulla rete, per alcuni utenti è davvero una droga: un infinità di informazioni messe a disposizione da un numero di fonti impressionante.

Nella stessa maniera in cui molti blogger hanno inconsapevolmente risolto miei problemi, mi auguro di poter risolvere i problemi di molti altri...

Chiunque sia interessato a comunicare articoli da pubblicare è pregato di contattarmi.

Spero di aver espresso quella che è l'idea dietro questo "inedito" blog.