Cerca e Trova un JAR

Cerca e Trova un JAR
G.Morreale

Introduzione:

A volte quando si scaricano delle librerie, o semplicemente delle classi il pacchetto fornito non è comprensivo di tutte le dipendenze necessarie.
Nasce quindi l'esigenza, in questo ma anche in altri casi, di risalire al jar contenente una determinata classe.

La soluzione:

Non ricordo come mi sono trovato ad utilizzare un bel servizio online in grado di risolvere il problema di trovare, dato il nome di una classe, il nome del file jar che contiene tale classe al suo interno.

Il servizio è fruibile dal sito www.findjar.com

Esso quindi aiuta a risolvere le eccezioni:

• NoClassDefFoundError
• ClassNotFoundException

Esempio

Digitando ad esempio il nome della classe XMLSerializer

Si ottiene il seguente output:

[CLASS] org.kxml2.io.KXmlSerializer

[CLASS] org.xmlpull.v1.XmlSerializer

[CLASS] org.kxml2.wap.WbxmlSerializer

[CLASS] net.sf.json.xml.XMLSerializer

[CLASS] com.idoox.util.xml.XMLSerializer

[CLASS] oracle.xml.binxml.BinXMLSerializer

[CLASS] org.apache.ws.jaxme.JMXmlSerializer

[CLASS] org.vraptor.remote.xml.XMLSerializer

In questo caso non trovando un jar contenete la classe XMLSerializer, il sistema propone il nome, completo di package, di classi simili all'input digitato.

Se clicchiamo su org.kxml2.io.KXmlSerializer o su digitiamo tale valore come input, trattandosi, di un nome completo di package e corretto l'output propone i nomi dei JAR che contengono la specifica classe:

Containing JAR files:

kxml2.jar kxml2-2.1.8.jar

Conclusione

Un breve articolo per segnalarvi un sito semplice ma a volte molto utile.
Se volete segnalare servizi altrettanto interessanti lasciate pure un commento a questo post.

Captcha: Una JSP con controllo Immagine

Effettuare su pagine web controlli basati sulle immagini
G.Morreale

Introduzione:

Diverse e diverse volte sicuramente vi siete trovati davanti una pagina di registrazione, login, o download nella quale viene richiesta la digitazione dei caratteri presenti in un immagine.

Tale test ha lo scopo di verificare se l'utente è un essere umano e non un computer.

L'acronimo inglese CAPTCHA riassume in una parola il concetto appena esposto.

"Completely Automated Public Turing test to tell Computers and Humans Apart" (Test di Turing pubblico e completamente automatico per distinguere computer e umani)

Implementare tale controllo in una pagina JSP

Al fine di inserire tale controllo all'interno di una pagina JSP, è necessario l'uso di una libreria in grado di generare l'immagine e fornire in un qualche modo il dato generato sottoforma di variabile.

La libreria che viene utilizzata nell'esempio è scaricabile da:

http://code.google.com/p/kaptcha/

L'Esempio

Creiamo un progetto Web, e generiamo due pagine JSP:

• index.jsp - che contiene il controllo
• protetta.jsp - che è visualizzabile solo se l'utente riporta correttamente il contenuto dell'immagine su un campo di testo.

Aggiungiamo tra le librerie di progetto il jar scaricato dal precedente link.

Dividiamo ora l'esempio in due parti:

• La generazione dell'immagine
• Il controllo

La generazione dell'immagine

L'immagine è generata da una servlet la cui classe si trova all'interno della libreria katpcha.

Tale classe esattamente si trova nel seguente percorso:

com.google.code.kaptcha.servlet.KaptchaServlet

Bisogna però rendere disponibile la servlet configurando correttamente l'elemento e il suo mapping sul file xml.

Tale configurazione è fattibile inserendo le seguenti righe nel file web.xml

    <servlet>

        <servlet-name>Kaptcha</servlet-name>

        <servlet-class>com.google.code.kaptcha.servlet.KaptchaServlet</servlet-class>

    </servlet>

    <servlet-mapping>

        <servlet-name>Kaptcha</servlet-name>

        <url-pattern>/Kaptcha</url-pattern>

    </servlet-mapping>

Il primo nodo serve a dichiarare una servlet di nome Kaptcha corrispondente alla classe com.google.code.kaptcha.servlet.KaptchaServlet

Il secondo nodo invece serve a indicare su quale url deve rispondere la servlet.

La servlet è quindi ora configurata, è quindi possibile effettuare già il deploy dell'applicazione (es. su localhost) e richiamare l'url Kaptcha al fine di generare un immagine (es. prova con http://localhost/ContextPathProgetto/Kaptcha).

L'output dovrebbe essere simile a questo:

Quindi il codice della pagina index.jsp potrebbe essere simile al seguente:

<%@page contentType="text/html"%>

<%@page pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

   "http://www.w3.org/TR/html4/loose.dtd">

<html>

    <head>

        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

        <title>Esempio Captcha</title>

    </head>

    <body>

    <h1>Esempio Captcha</h1>

    <img src="Kaptcha" alt=""/>    

    <br />

    <form action="protetta.jsp">

        <label>Ricopia correttamente il testo: </label><br />

        <input type="text" name="kaptcha" value="" />

    </form>   

    </body>

</html>

Banalmente viene richiamata la servlet per generare l'immagine e viene mostrata all'utente una textbox per inserire il valore.

Il metodo action richiama la pagina protetta nella quale inseriremo il controllo.

Il controllo

Partiamo dal presupposto che la servlet Kaptcha non appena genera l'mmagine inserisce il corrispettivo testo all'interno di una variabile di sessione.

Tale variabile di sessione è identificabile dalla chiave com.google.code.kaptcha.Constants.KAPTCHA_SESSION_KEY

Quindi adesso credo risulti ovvio come chiudere il cerchio effettuando il controllo tra il testo digitato e quello generato.

Non si fà altro che ottenere il parametro GET o POST inserito dall'utente e confrontarlo con quello inserito dalla servlet Captcha nella sessione.

In caso di controllo positivo si procede tenendo conto che l'utente è un essere umano, in caso contrario si richiede la digitazione del testo o si  ridirige il client verso una pagina di errore.

Riassumendo il tutto con del codice sorgente:

<%@page contentType="text/html"%>

<%@page pageEncoding="UTF-8"%>

<%

//ottenimento del valore generato dal captcha sottoforma di String

String kaptchaExpected = (String) session.getAttribute(com.google.code.kaptcha.Constants.KAPTCHA_SESSION_KEY);

//estrazione input dell'utente

String kaptchaReceived = request.getParameter("kaptcha");

//Matching

if (kaptchaReceived == null || !kaptchaReceived.equalsIgnoreCase(kaptchaExpected))

{

  response.sendError(500, "Non hai ricopiato correttamente il testo nell'immagine");

  return;

}

%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

    <head>

        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

        <title>Pagina Protetta dal Controllo</title>

    </head>

    <body>

        <h1>Pagina Protetta dal Controllo</h1>                

    </body>

</html>

Conclusione

Questo è un esempio base, le applicazioni e le varianti sono diverse, ma il concetto resta invariato.

Riguardo la libreria utilizzata per la generazione dei codici è possibile effettuare delle customizzazioni sull'immagine generata(vedi http://code.google.com/p/kaptcha/wiki/ConfigParameters ).

SVN Branch

Svn Branch con Netbeans
G.Morreale

Introduzione:

Il branch serve a creare delle linee di sviluppo parallele.

Se, ad esempio, sviluppiamo un software e a un certo punto viene richiesto di implementare una feature sperimentale ma vogliamo mantenere la versione principale disponibile per gli altri sviluppatori che ogni tanto si trovano a risolvere dei bug.

In questo caso si crea un branch e si implementa la feature sperimentale sul branch stesso. Gli altri sviluppatori, che lavorano sulla linea principale, non saranno "disturbati" dalle modifiche effettuate sul branch riguardanti la feature sperimentale richiesta.

Se alla fine si decide di rendere la feature sperimentale disponibile sulla linea principale si procede con un operazione di merge, al fine di fondere la linea principale con il branch.

La linea principale prende il nome di Trunk (tronco)

Le linee parallele sono i branch.

Netbeans e i Branch.

(Articolo relativo a Netbeans 6.1)

Netbeans consente di interagire con svn attraverso un integrazione nell'ide.

I comandi da utilizzare per lavorare con i branch sono

• CopyTo - Copia l'intero progetto o un singolo file/package su un altra directory(creando il branch).
• SwitchTo - Serve a indicare con quale branch (o trunk) si intende lavorare.
• Merge Changes - Serve a fondere diversi branch(o trunk).

Esempio

(L'esempio presuppone la configurazione di svn sul proprio netbeans ide - vedi http://subversion.netbeans.org/faq/index.html)

Creiamo un progetto java qualsiasi.

Tasto destro sul progetto - Versioning - Import into Subversion Repository

Impostare url, nome utente e password.

Riguardo la repository folder: cliccare su browse, scegliere la directory il cui nome corrisponde a quello del progetto, cliccare su "Into new folder" e creare la directory trunk. Conferma l'operazione.

Si è creata la linea principale.

Adesso procediamo creando il branch.

nota:

Ogni operazione: copy to, switch to copy, update, commit può essere relativa all'intero progetto o a un singolo elemento(File ad esempio)

Tasto destro su un file di progetto sul quale si intende effettuare il branch e i relativi test.

Scegliere Subversion -> Copy To, 

Cliccare su browse, Creare cliccando su "Into new folder" la directory branches nello stesso livello di trunk, Creare un altra directory all'interno con il nome del branch (es. branch1), Confermare cliccando su ok.

Con quest'ultima operazione si è creato il branch, ovvero una linea di sviluppo parallela equivalente a quella attuale, ma al momento l'ide effettuera tutte le varie operazioni (Es. update, commit) sul trunk e non sul branch.

Per attivare il branch quindi, usare il comando Switch to Copy sul file spostato sul branch e selezionare il branch precedentemente creato.

Da ora in poi si lavora sul branch e non sulla linea principale.

nota:

Tale operazione è stata effettuata sul singolo file, quindi le operazioni svn sul file sul quale si è finora operato saranno effettuate sul branch, mentre gli altri file continueranno a lavorare sul trunk

Per capire su quale branch si lavora, è possibile attivare la visualizzazione del branch, cliccando su View -> Show Versioning label.

E' possibile adesso effettuare delle modifiche sul file(es. scrivendo "modifica branch 1").

Effettuare il commit.

Effettuare lo switch copy to sulla linea principale e verificare che la modifica riportata sul branch1 non è presente.

Per verificare l'operazione di merging del branch con la linea principale è possibile usare il comando "Merge Changes"

Selezionare il branch1 e cliccare su merge.

Adesso il file in questione conterrà anche le modfiche del branch.

Conclusione

Vi invito a leggere http://svnbook.red-bean.com/ al fine di approfondire le varie nozioni relative a questo utilissimo tool per il controllo di versione.

Riferimento:

http://svnbook.red-bean.com/en/1.1/ch04.html#svn-ch-4-sect-1

Java - Passaggio Valori

Java - Passaggio Valori
G.Morreale

Introduzione:

Questo è un argomento base, ma spesso c'è parecchia confusione circa il passaggio dei valori in Java.

Proprio di recente ho letto un articolo http://www.javaranch.com/campfire/StoryCups.jsp

che tratta l'argomento attraverso delle similitudini, è proprio basandomi su tale testo che vorrei fare un pò di chiarezza a riguardo.

Supponiamo che le variabili siano dei cassetti di un mobile (Il mobile potrebbe essere paragonato all'heap)

I cassetti essenzialmente contengono due tipi di "cose"

1. oggettini vari (penne, lampadine, libri)
2. telecomandi (tipo quello della tv o dello stereo per intenderci)

Gli oggettini sarebbero i dati primitivi (byte, short, int, float, double).

Tali oggetti sono contenuti in cassetti di dimensione variabile, le penne infatti sono contenute dai cassetti grandi 15 cm2, mentre i libri sono contenuti da cassetti un pò più capienti allo stesso modo in cui i byte necessitano variabili da 8 bit mentre gli int necessitano 32 bit di spazio.

Quando viene chiamato un metodo passando un data primitivo, viene aperto ("allocato") un nuovo cassetto vuoto e all'interno viene copiato il dato(NON travasato).

Tale metodo si chiama "passaggio per valore".

I telecomandi invece sono contenuti in cassetti di ugual dimensione.

I telecomandi servono a comandare, come scrivevo prima tra parentesi, oggetti vari come la tv, lo stereo il dvd recorder etc. etc.

Bene, la tv, lo stereo etc. sono gli oggetti java (es. new Date()) e i telecomandi servono a "utilizzare" tali oggetti.

In questo caso quando viene chiamato un metodo e viene passato l'oggetto viene aperto("allocato") un nuovo cassetto e all'interno viene messa una copia del telecomando in grado di "comandare", "utilizzare" lo stesso oggetto del telecomando originale.

esempio:

public void foo(Date val)

{

/*val avrà una copia del riferimento(telecomando) in grado di gestire l'oggetto new Date() come avviene per now.*/

}

Date now = new Date();

foo(now);

Quindi si hanno due telecomandi differenti che gestiscono la stessa tv.

Modificando - val - non si andrà ad intaccare il riferimento di now e viceversa, però utlizzando attraverso val i metodi dell'oggetto Date si potrà modificare l'oggetto e anche now sarà al corrente di tali modifiche.

import java.util.Date;

public class Main

{

    public static void main(String[] args)

    {

        Date now = new Date();

        System.out.println("Now - prima di foo - " + now.toString());

        Prova prova = new Prova();

        prova.foo(now);

        System.out.println("Now - dopo foo - " + now.toString());

    }

}

class Prova

{

    public void foo(Date val)

    {

        val.setTime(0);

               val = null;

    }

}

Quindi l'output del precedente esempio sarà

Now - prima di foo - Thu Oct 02 15:27:57 CEST 2008

Now - dopo foo -     Thu Jan 01 01:00:00 CET 1970

Ciò dimostra che attraverso copie diverse dei telecomandi(riferimenti) si agisce sullo stesso oggetto.

All'interno di foo l'assegnamento 

val = null

dimostra come i riferimenti siano stati passati per valore, quindi sono copie diverse.

now non può modificare il valore di val e viceversa ma entrambi possono modificare il valore dello stesso oggetto a cui puntano.

Oggetti Immutablii

Nel caso in cui gli oggetti trattati dai riferimenti(telecomandi) siano immutabili

Le classi Immutable sono read-only cioè non ci sono metodi SetField. I dati della classe sono definiti per sempre nel costruttore (e ovviamente sono privati). Esempio di classi Immutable sono String e Integer.
Si evitano così problemi di accesso concorrente ai dati della classe, poiché non ci sono metodi che modificano lo stato dell'oggetto dopo la sua creazione.

L'output del seguente esempio necessita di alcune considerazioni

public class Main

{

    public static void main(String[] args)

    {

        String now = new String("ABC");

        System.out.println("Prima di Foo " + now.toString());

        Prova prova = new Prova();

        prova.foo(now);

        System.out.println("Dopo Foo " + now.toString());

    }

}

 class Prova

{

    public void foo(String val)

    {        

        val = val + "D";

        val = null;

    }

}

Nel momento in cui il valore now viene preso in considerazione dal metodo foo, val conterrà una copia del riferimento che punterà alla stringa "ABC", ma quando si eseguirà

  val = val + "D";

essendo String un oggetto immutabile verrà creato un nuovo oggetto contenente "ABCD", val quindi punterà a tale oggetto e non più a quello vecchio.

Però essendo val una copia del riferimento di now, now non sarà modificato e quindi continuerà a puntare verso l'oggetto "ABC".

Quindi l'output del precedente esempio sarà

Prima di Foo ABC

Dopo Foo ABC

Come usare il debugger in Netbeans

Usare il debugger.
(E' il momento di abbandonare System.out.println(".."))

Il Debugger consente di analizzare il flusso del programma, istruzione dopo istruzione, ad esempio analizzando lo stato delle variabili, lo stack delle chiamate e i thread in esecuzione.

Anche nella programmazione su dispositivi mobili il debugger è di certo uno strumento preziosissimo.

Di seguito cercherò di dare delle indicazioni su come usare questo strumento con Netbeans 5.5.1.

Il punto in cui decidiamo di fermare il codice per analizzare lo stato della jvm (ad esempio le variabili) si chiama Breakpoint.
L'inserimento di un breakpoint avviene cliccando sulla parte grigia che precede l'editor di testo di netbeans:

La linea di codice viene evidenziata!

Per avviare la midlet e analizzarla con il debugger bisogna premere F5.
Non appena il flusso del programma arriva al breakpoint, l'esecuzione si blocca e il colore della linea evidenziata cambia.

In questo istante è possibile conoscere l'attuale valore delle variabili

• Passandoci di sopra con il mouse
• Leggendo il tab sottostante "Local Variables" (solo per le variabili locali)
• Premendo CTRL+F9 e analizzando l'espressione proposta.

Se qualche variabile risulta di particolare interesse durante l'analisi di debugging allora possiamo aggiungere su di essa una Watch.
Per aggiungere una Watch basta selezionare la variabile, anche senza debugging attivo, e premere CTRL+Maius+F7.
Da questo momento durante il debugging tutte le variabili "Watch" vengono raggrupate nel tab "Watches".

Se siamo interessati a conoscere lo stato del sistema all'istruzione di codice successiva è sufficente premere F8, F7, o CTRL+F7

• F8 indica l'avanzamento all'istruzione successiva.
• F7 indica l'avanzamento all'istruzione successiva. Se tale istruzione è un metodo l'esecuzione si fermerà alla prima istruzione interna al metodo
• CTRL+F7 Se siamo entrati all'interno di un metodo con F7, e non siamo più interessati all'analisi interna del metodo e vogliamo ritornare al livello esterno della chiamata questa è l'opzione giusta.

Questi concetti basiliari sono adattabili anche per altri ambienti di sviluppo e linguaggi di programmazione.

Nello sviluppo su Java ME è possibile effettuare il debugging sull'emulatore usando semplicemente il WTK, per quanto riguarda invece il debugging sui dispositivi, bisogna verificare se il produttore mette a disposizione un SDK con relativa funzionalità per il debugging (ad esempio come avviene per SonyEricsson).