Java EE – la principale piattaforma per lo sviluppo e il deployment di applicazioni web ed enterprise – possiede ora nuove caratteristiche che ne incrementano la flessibilità e permettono alle aziende di adottare, in alternativa alla piattaforma enterprise completa, specifici scenari applicativi per meglio rispondere ai requisiti dei singoli progetti . Java EE SDK è già stato scaricato più di 18 milioni di volte e le specifiche sono supportate da 28 licenziatari che commercializzano prodotti compatibili con Java EE. Gli sviluppatori possono scaricare Java EE SDK dall’indirizzo http://java.sun.com/javaee/downloads/index.jsp.

Java EE 6 offre una solida base per la continua crescita della tecnologia Java sia dal punto di vista degli sviluppatori che da quello dei solution provider. Le specifiche Java EE 6 introducono i Profile, un sistema che permette di adeguare la piattaforma ai singoli scenari applicativi. I Profile offrono un maggior grado di flessibilità a clienti, ISV e vendor di piattaforma, aiutandoli ad affrontare meglio mercati specifici.

Web Profile, per esempio, è un profilo “compatto” realizzato appositamente per gli scenari basati su applicazioni Web che non richiedono tutto il set di funzionalità della piattaforma Java EE completa. Abbinato a importanti miglioramenti delle specifiche esistenti e all’introduzione della tecnologia Enterprise JavaBeans™ (EJB) 3.1 Lite, Web Profile consente agli sviluppatori Web di realizzare applicazioni in maniera rapida e semplice senza doversi costruire e gestire uno “stack custom”. Inoltre, gli sviluppatori che dovessero necessitare della potenza della piattaforma tradizionale possono passare agevolmente dall’ambiente Web Profile alla piattaforma Java EE 6 completa. Ulteriori profili saranno definiti in futuro attraverso il Java Community Process per affrontare differenti scenari applicativi.

Java EE 6 definisce inoltre le sue capacità di estensibilità come un mezzo per abbracciare e supportare innovazioni e comunità esterne, consentendo ad esse di collegarsi – in maniera trasparente – alla piattaforma stessa. Java EE 6 specifica quindi un processo e un set di tecnologie che potranno essere rimossi da future release della piattaforma, permettendo a vendor e application provider di pianificare la migrazione verso le nuove tecnologie che saranno offerte dalle prossime versioni della piattaforma.

La nuova release di Java EE SDK mette a disposizione potenti tecnologie per lo sviluppo web ed enterprise che fanno leva sulla prima implementazione della piattaforma Java EE 6. Gli sviluppatori che hanno familiarità con il modello di programmazione di Java EE possono ora sfruttare i miglioramenti alla produttività e l’eccezionale facilità di sviluppo che contraddistinguono Java EE 6 per realizzare una vasta gamma di applicazioni per il Web e per i contesti enterprise.

Tra le novità introdotte vi sono: l’aggiunta delle tecnologie Context and Dependency Injection ed EJB 3.1 Lite, un modo più semplice per aggiungere EJB ai file .war delle applicazioni Web senza dover creare package ulteriori, la possibilità di trascinare col mouse i framework di terze parti nelle servlet attraverso web-fragments.xml, l’aggiunta di numerose annotazioni all’interno di tutta la piattaforma per semplificare la creazione di applicazioni, e la possibilità di integrare EJB all’interno di applicazioni indipendenti per agevolare le procedure di test. Un elenco completo di tutte le funzionalità di Java EE 6 è disponibile all’indirizzo: http://java.sun.com/javaee/.

Java EE 6 mette quindi a disposizione significativi miglioramenti in termini di produttività e facilità d’uso, mantenendo la compatibilità verso il basso con Java EE 5, e con in più il vantaggio di poter scegliere tra varie implementazioni. La reference implementation di Java EE 6 deriva dal progetto open source GlassFish(TM).

La Reference Implementation, il TCK e l’SDK di Java EE 6 sono già disponibili. Il nuovo SDK comprende documentazione e tool con i quali gli sviluppatori possono imparare a conoscere Java EE 6 e accelerare la creazione di nuove applicazioni enterprise. Il download è gratuitamente disponibile all’indirizzo http://java.sun.com/javaee/downloads/index.jsp.

Sun Microsystems

Spulciando un’overview vediamo un po’ di feature, che possono tornare utili ai nostri progetti. Un esempio è l’introduzione della classe CharMatcher per manipolare caratteri all’interno di una stringa come la funzione CharMatcher.is(‘-’). Le stringhe sono sempre manipolabili con la classe Joiner, che può legare una sequenza di numeri separati da uno o più caratteri scelti con la seguente riga di codice:

Per la separazione di stringe troviamo la classe Splitter in grado di separare parti di stringa da un testo complesso molto meglio di quanto faccia la funzione split() di Java:

Per ciò che riguarda l’I/O, le classi ByteStreams, CharSequence e Files promettono di leggere le righe di un file in modo molto stringato. Sotto infatti vediamo un esempio di routine in grado di contare le righe di un file:

Anche le primitive non sono esenti da novità con l’introduzione di classi come Ints, Longs o Bytes

.

In attesa della versione 1.0, il rimando è ai javadoc ufficiali.

Guava, una collezione di librerie Java da Google

CodeRun, per programmare online

Cosa significa in parole povere che lo scambio dati tra client e server avviene in background?

Vuol dire che lo scambio dati tra client e server permette l’aggiornamento dinamico della pagina web senza che quest’ultima venga ricaricata e senza dover richiamare una nuova pagina ma, soprattutto, è da sottolineare che non bisogna attendere che sia stata ultimata la richiesta per poterne effettuare altre.

Ajax non è un linguaggio di programmazione ma un insieme di tecnologie, vediamo quali sono:

1. HTML/XHTML/CSS per il markup;
2. DOM (Document Object Model) manipolato attraverso un linguaggio ECMAScript come JavaScript;
3. XMLHttpRequest per lo scambio asincrono dei dati tra client e server;
4. XML come formato per lo scambio dati. Non è obbligatorio e al suo posto si può scegliere un altro formato come JSON o anche semplice testo.

Le applicazioni web che fanno uso di Ajax necessitano di browser di ultima generazione che supportino tale tecnologia.

Tutti i principali browser come FireFox, Internet Explorer, Google Chrome, Opera e Safari supportano Ajax ma è buona norma testare i propri applicativi per verificare la compatibilità.

Abbiamo detto che le chiamate Ajax avvengono in background e, ottenuta la risposta, viene modificata solo una porzione della pagina (di solito un elemento HTML come il DIV).
Questo potrebbe anche rappresentare un problema per l’utente che, una volta effettuata la chiamata, vede la pagina web “immobile” ignaro che la richiesta di informazioni è comunque stata inviata al server.

Per ovviare a questo problema è opportuno dedicare un elemento della pagina (un div è sicuramente indicato) alla descrizione dell’interazione. Questo si può realizzare con un semplice testo o con un loader (magari una GIF come quelle scaricabili da ajaxload.info) che “visivamente” mostra all’utente che è in corso uno scambio dati.

Vediamo tecnicamente come possiamo modificare dinamicamente il contenuto di una pagina web tramite il metodo innerHTML del DOM.

Supponiamo che nella nostra pagina web ci sia un div con ID univoco “content”:

<div id=”content”>
Mio div
</div>

Possiamo modificare il contenuto del div utilizzando la seguente funzione:

function modifica() {
document.getElementById(“content”).innerHTML =
“Contenuto del div modificato”;
}

Richiamiamo la funzione tramite un button:

<input type=”button”
value=”Modifica” onclick=”javascript:modifica()” />

Modificando dinamicamente lo stile del div possiamo inventarci una funzione che mostri o nasconda il suo contenuto:

function hideshow() { 

var element = document.getElementById("content");

if (element.style.visibility == 'hidden') {

element.style.visibility = 'visible';

element.style.display = 'block';

} else {

element.style.visibility = 'hidden';

element.style.display = 'none';

}

}

Richiamiamo la funzione con un altro button:

<input type="button" value="Hide/Show"
onclick="javascript:hideshow()" />

Adesso vediamo come realizzare una interazione “avanzata” inviando una richiesta ad una pagina server-side (nel nostro esempio scritta in PHP) ed ottenendo una risposta in formato testo.

Vediamo prima la pagina PHP (file.php):

<?php

$utente = $_GET['utente'];

if ($utente=="rossi") echo "Salve sig. Rossi";

else echo "Non ti conosco";

?>

La pagina riceve una variabile “utente” in modalità GET e controlla che il suo contenuto sia “rossi”. In caso affermativo stampa la frase “Salve sig. Rossi” altrimenti la frase “Non ti conosco”. La risposta verrà inserita nel div con ID univoco “content” tramite Ajax:

var ajax = initAjax();

if (ajax) {

ajax.open("get", "file.php?utente=" + utente, true);

ajax.setRequestHeader("connection", "close");

ajax.onreadystatechange = function() {

var response="";

if (ajax.readyState == 0) response =
"Inizializzazione in corso..."; 

if (ajax.readyState == 1) response =
"content","Connessione avviata...";

if (ajax.readyState == 2) response =
"content","Invio dati in corso..."; 

if (ajax.readyState == 3) response =
"content","Ricezione dati in corso..."; 

if (ajax.readyState == 4 && ajax.status==200) {

response = ajax.responseText;

} 

else response =
"Operazione fallita! Errore numero " + ajax.status;

document.getElementById("content").innerHTML = response;

} 

ajax.send(null);

} 

else alert('Ajax non supportato!');

Dopo aver inizializzato l’oggetto Ajax (potete visionare il codice completo nei files a corredo dell’articolo) che, tra l’altro, ci permette di verificare che Ajax sia supportato dal browser, abbiamo effettuato la chiamata asincrona inviando il contenuto della variabile utente e ricevendo una risposta che abbiamo scelto di memorizzare nella variabile response.

Tutto questo servendoci del metodo Open (il cui terzo parametro impostato su true specifica che la chiamata è asincrona) e successivamente del metodo Send.

Niente di troppo complicato ma soffermiamoci un attimo sulla funzione onreadystatechange.

Questa funzione si preoccupa di controllare lo stato dell’interazione restituendo un numero intero (readyState) che identifica in ogni istante lo stato della richiesta.

Nel caso avessimo voluto effettuare la richiesta in POST avremmo dovuto modificare lo script nei metodi Open e Send e specificare tramite headers i valori da inviare.

ajax.open
("post", "file2.php", true);

ajax.setRequestHeader
("content-type", "application/x-www-form-urlencoded");

ajax.send
("utente=" + utente);

Richiamando il file PHP file2.php:

<?php

$utente = $_POST['utente'];

if ($utente=="rossi") echo "Salve sig. Rossi";

else echo "Non ti conosco";

?>

Fonte: Come creare applicazioni interattive con Ajax

Usare meno “var”

Come sappiamo, per dichiarare una variabile occorre usare la keyword var, ma per gruppi di variabili, è consigliabile usarla una sola volta e raggruppare una lista di nomi:
view plaincopy to clipboardprint?

1. // tante var
2. var v1 = 1;
3. var v2 = {};
4. var v3 = function() {
5. // function code
6. };
7.
8. // una var
9. var v1 = 1,
10. v2 = {},
11. v3 = function() {
12. // function code
13. };

// tante var
var v1 = 1;
var v2 = {};
var v3 = function() {
// function code
};

// una var
var v1 = 1,
v2 = {},
v3 = function() {
// function code
};

Usare shortuct pointers per i namespace prolissi

Perché ripetere sempre lo stesso namespace quando possiamo avvalerci dei puntatoti locali, il cui namespace è completamente sotto il nostro controllo? Questo migliora di molto l’esito della compressione:
view plaincopy to clipboardprint?

1. function() {
2. MyLib.Utilities.Events.add('el1', 'click' function() {/* function code */});
3. MyLib.Utilities.Events.add('el2', 'click' function() {/* function code */});
4. MyLib.Utilities.Events.add('el3', 'click' function() {/* function code */});
5. }());
6.
7. // shortcut pointer
8. (function() {
9. var evts = MyLib.Utilities.Events;
10. evts.add('el1', 'click' function() {/* function code */});
11. evts.add('el2', 'click' function() {/* function code */});
12. evts.add('el3', 'click' function() {/* function code */});
13. }());

function() {
MyLib.Utilities.Events.add('el1', 'click' function() {/* function code */});
MyLib.Utilities.Events.add('el2', 'click' function() {/* function code */});
MyLib.Utilities.Events.add('el3', 'click' function() {/* function code */});
}());

// shortcut pointer
(function() {
var evts = MyLib.Utilities.Events;
evts.add('el1', 'click' function() {/* function code */});
evts.add('el2', 'click' function() {/* function code */});
evts.add('el3', 'click' function() {/* function code */});
}());

Concatenare i file prima della compressione

Una buona regola è inoltre quella di concatenare i file in un unico file prima di eseguire la compressione. Questo permette di riutilizzare i namespace più corti scelti in precedenza dal compressore, senza la necessità di usarne di nuovi nel caso di nuove variabili globali (i compressoreinon hanno la capacità di ricordare le informazioni tra più file).

Variabili al posto di oggetti

Quest’ultima regola è molto soggettiva: se da un lato ottimizza la compressione, dall’altro può incidere notevolmente sulla qualità del nostro codice. Essa si traduce nell’utilizzare le semplici variabili al posto delle proprietà degli oggetti: questo perchè molti compressori non sono attualmente in grado di ridurre e dunque rinominare le proprietà degli oggetti.

Fonte: Ottimizzare la compressione del Javascript

Sempre basato sul tracciamento oculare è lo studio recentemente svolto da CXPartners. Sotto esame il comportamento di un gruppo di utenti alle prese con i moduli di registrazione di eBay, Yahoo Mail, GMail e Hotmail.

La sintesi dei risultati consiste in 10 linee guida. Le label? L’ideale è posizionarle verticalmente rispetto al campo corrispondente e quando ciò non sia possibile è consigliabile piazzarle, ben evidenziate in grassetto, sul lato sinistro. Evitare poi di distribuire i campi su più di una colonna; per situazioni in cui si inseriscano due input di testo sulla stessa riga (classico il caso della coppia nome/cognome) è opportuno fare in modo che siano ben ravvicinati e che siano raggruppati sotto una sola label.

Interessante poi l’osservazione sui campi obbligatori. Il consiglio, in base alle osservazioni svolte, è di non usare l’asterisco come indicazione di una compilazione obbligatoria, ma di rendere esplicito il fatto che un campo è opzionale attraverso un’indicazione testuale.


Fonte: Uno studio sull’usabilità dei form

È possibile scarircare la libreria e la documentazione del progetto dal sito ufficiale (https://developer.skype.com/wiki/Java_API).

Skype4Java ci permette è possibile effettuare moltissime operazioni, tra cui:

• Visualizzare e modificare le impostazioni del client (lingua, sfondi, proprietà)
• Visualizzare, aggiungere, modificare ed eliminare i contatti ed i gruppi
• Gestire il proprio profilo
• Avviare una sessione voce
• Avviare una sessione di chat
• Inviare SMS

La classe principale della libreria è com.skype.Skype. Questa classe ci fornisce numerosi metodi statici che ci permettono di recuperare moltissime informazioni: versione installata del client, lista dei gruppi, lista dei contatti, informazioni relative ai profili dei nostri contatti, e molte altre informazioni.

Alcuni esempi ci aiuteranno a prendere confidenza con questa libreria.

Skype.getVersion()

Profile profilo = Skype.getProfile();

System.out.println("ID:" + profilo.getId());
System.out.println("Sesso:" + profilo.getSex());
System.out.println("Città:" + profilo.getCity());
System.out.println("Stato:" + profilo.getStatus());

profilo.setCity("Napoli");

L’oggetto Profile restituito dal metodo getProfile(), contiene le informazioni relative al profilo dell’utente skype attivo sul client, compreso lo stato attuale dell’utente (In linea, Non al computer, Occupato). Le informazioni sono richiamabili mediante i classici metodi getter. È possibile anche modificare tali proprietà utilizzando i metodi setter.

Gli stati possibili di ciascun contatto sono i seguenti:

Friend[] contatti = Skype.getContactList().getAllFriends();

for (int i = 0; i < contatti.length; i++)
{
  Friend contatto = contatti[i];
  System.out.println(contatto.getId() + " " + contatto.getFullName());
}

Il metodo getContactList(), restituisce diverse informazioni sui contatti. Il metodo getAllFriends(), restituisce un array di oggetti Friend che contiene l’elenco completo di tutti i contatti. L’oggetto Friend, contiene tutte le informazioni sul profilo del contatto: id, nome, città, lingua, stato, email.

Skype.getContactList().addGroup("amici");

Il metodo addGroup() ci permette di aggiungere un nuovo gruppo.

Group amici = Skype.getContactList().getGroup("amici");

Friend contatto1 = Skype.getContactList().getFriend("nick1");
Friend contatto2 = Skype.getContactList().getFriend("nick2");

amici.addFriend(contatto1);
amici.addFriend(contatto2);

Per inserire i contatti all’interno di un gruppo occorre prima di tutto recuperare l’istanza del gruppo mediante il metodo getGroup(). Successivamente occorre recuperare l’istanza di ciascun contatto da inserire nel gruppo, mediante il metodo getFriend(), ed infine, richiamare il metodo addFriend() della classe Group.

Friend contatto = Skype.getContactList().getFriend("pippo");

if (null != contatto && contatto.getOnlineStatus().equals(User.Status.ONLINE))
  contatto.send("Ciao Pippo");
else
  System.out.println("Il contatto non è al PC. Il suo stato è '" + contatto.getOnlineStatus() + "'");

Ottenuta l’instanza dell’oggetto Friend, mediante il metodo getFriend(String) della classe ContactList, corrispondente al contatto che ci interessa, e verificato il suo stato, possiamo inviargli un messaggio via chat utilizzando il metodo send(String). Naturalmente, qualora il contatto richiesto non sia presente nella lista dei contatti, il metodo restituirà un riferimento null e quindi non sarà possibile inviargli un messaggio.

Friend contatto = Skype.getContactList().getFriend("pippo");

if (null != contatto && contatto.getOnlineStatus().equals(User.Status.ONLINE))
  contatto.call();
else
  System.out.println("Il contatto non è al PC. Il suo stato è '" + contatto.getOnlineStatus() + "'");

Con la stessa logica dell’esempio precedente, è possibile avviare una chiamata. L’unica differenza è il metodo della classe Friend da richiamare. Per inviare un messaggio di chat è necessario utilizzare il metodo send(String), mentre per inoltrare una chiamata, occorre utilizzare il metodo call().

Skype.sendSMS("134567890", "prova sms");

Mediante il metodo sendSMS() è possibile inviare un SMS direttamente ad un numero specifico.

Oltre alla classe Skype, la libreria Skype4Java, mette a disposizione anche la classe SkypeClient, mediante la quale è possibile interagire direttamente con il client. Ad esempio, è possibile aprire la finestra delle impostazioni, la finestra dei contatti, etc.

• SkypeClient.showSkypeWindow()
• SkypeClient.showProfileWindow()
• SkypeClient.showSearchWindow()

Per eseguire gli esempi proposti, è necessario includere nel proprio progetto la libreria specifica del sistema operativo. Nel pacchetto zip scaricabile dal sito ufficiale, infatti, sono inclusi i seguenti file jar:

• skype_linux.jar per i sistemi linux
• skype_osx.jar per MAC
• skype_win32.jar per Windows

Queste sono solo alcune delle funzionalità messe a disposizione dalla libreria Skype4Java, per iniziare a acquisire familiarità con la libreria.

Skype4Java, telefono e chat nelle applicazioni Java

La risposta in breve e’: basta definire un tipo che sara’ il tipo della variabile che conterra’ il cursore e lo stesso tipo sara’ il tipo di ritorno della funzione. Nello specifico:

nell’header del PACKAGE comune definiamo un tipo record:

TYPE ty_tipo_ritorno_rec IS RECORD (
nome       varchar2(100),
cognome    varchar2(100),
dt_nasc    date,
dt_ult_mod date
);

Quindi definiamo subito un’altro tipo che sara’ un cursore generico fatto pero’ come il record appena descritto sopra.

TYPE ty_cursore_ritorno IS REF CURSOR RETURN ty_tipo_ritorno_rec;

La funzione del package comune che ritorna il cursore sara’ cosi’ definita:

FUNCTION get_utente(p_cognome IN VARCHAR2)
RETURN ty_cursore_ritorno IS
/*variabile di ritorno*/
v_result ty_cursore_ritorno;
BEGIN
OPEN v_result FOR
SELECT
U.NOME
,U.COGNOME
,U.DT_NASC
,M.DT_ULT_MOD
FROM UTENTE U
,MODIFICHE M
WHERE U.ID_UTENTE = M.ID_UTENTE
AND U.COGNOME   = p_cognome;
RETURN v_result;
END;

Il package chiamante che utilizza la funzione definita sopra sara’ cosi’ fatto:

definiamo due variabili, una per il tipo cursore di ritorno e l’altra per

fare il fetch delle righe:

v_cursor     SCHEMA.NOME_PACKAGE_COMUNE.ty_cursore_ritorno;
v_cursor_rec SCHEMA.NOME_PACKAGE_COMUNE.ty_tipo_ritorno_rec;

quindi faremo:

v_cursor := SCHEMA.NOME_PACKAGE_COMUNE.get_utente('ROSSI');
LOOP
FETCH v_cursor INTO v_cursor_rec;
/*facciamo le operazioni che ci servono*/
dbms_output.put_line (v_cursor.nome);
EXIT WHEN v_cursor%NOTFOUND;
END LOOP;
CLOSE v_cursor;

Questo ci porta un notevole vantaggio: se il cursore del package comune viene ampliato per far fronte a nuove esigenze, al chiamante il cambiamento e’ trasparente.

L’unica cosa da fare per l’eventuale modifica del cursore e’ l’allineamento del tipo ty_tipo_ritorno_rec con i nuovi campi aggiunti/tolti.

Fonte: [Oracle] – Cursore come tipo di ritorno

<title>Risultato della ricerca per </title>

<p align="center">
Risultato della ricerca per: <b></b>
</p>

&lt;%
Const fsoForReading = 1

'Dimensioniamo il FileSytemObject
Dim objFSO
Set objFSO = Server.CreateObject("Scripting.FileSystemObject")

'Impostiamo la directory in cui cercare usando MapPath
'nel nostro caso impostiamo la root del sito
Dim objFolder
Set objFolder = objFSO.GetFolder(Server.MapPath("/"))

Dim objFile, objTextStream, ContenutoDelFile, FileTrovato
FileTrovato = False

'Leggiamo il contenuto di ogni file trovato nella directory
For Each objFile in objFolder.Files
If Response.IsClientConnected then
Set objTextStream = objFSO.OpenTextFile(objFile.Path,fsoForReading)
ContenutoDelFile = objTextStream.ReadAll

'Se nel contenuto del file è presente la stringa cercata...
'Stampo a video il link ed in nome del file
If InStr(1,ContenutoDelFile,CosaCercare,1) then
Response.Write "<a>" &amp; objFile.Name &amp; "</a><br>"
FileTrovato = True
End If

'Chiudo il file e proseguo nella ricerca
objTextStream.Close
End If
Next

'Se nessun file contiene il termine cercato...
if Not FileTrovato then Response.Write "Nessun risultato trovato..."

'Chiudo tutto...
Set objTextStream = Nothing
Set objFolder = Nothing
Set objFSO = Nothing
%&gt;

ASP: Motore di ricerca nel sito

TimeTask implementa Runnable, e per poterla utilizzare occorre importare il package java.util.TimerTask. Implementata la nostra classe erede di TimerTask, occorrerà schedulare i nostri job all’interno del main principale, per far ciò ricorreremo all’oggetto Timer.

Ma vediamo un esempio per capire meglio. Supponiamo di voler stampare ogni 5 secondi una stringa di saluto:

import java.util.Timer;
import java.util.TimerTask;
public class ttask extends TimerTask{
String stringa;
public ttask(){
stringa=”Ciao a tutti”;
}
public void run(){
System.out.println(stringa);
}
}

E la nostra classe main sarà:

public static void main(String[] args) {
Timer t=new Timer();
ttask tt= new ttask();
t.schedule(tt, 5000);
}

Fonte: Scheduling con Java