Anche se in versione beta, è finalmente disponibile la release 7 di Tomcat.

Tra le novità principali introdotte, c’è da sottolineare che questa nuova versione implementerà interamente le specifiche Java Servlet 3.0 (descritte in un precedente articolo), Java Server Pages 2.2 ed Expression Language 2.2.  In particolare, gli sviluppatori si sono soffermati sulle prestazioni e sulla sicurezza di Tomcat 7, requisiti fondamentali per ospitare applicazioni web. Nel caso in cui invece, si vuole determinare la presenza di memory leack, c’è anche la possibilità di avviare un’analisi sull’utilizzo della memoria.

E’ stata migliorata anche la gestione dei cookie, le comunicazioni asincrone ed il caricamento dei file. Da ricordare invece, che l’ambiente supporterà solo la Java Runtime Environmento 6.0.

Entro l’autunno Apache dovrebbe lanciare la versione definitiva.

Tomcat 7.0

La squadra di sviluppatori di GWT Java hanno realizzato il porting di Quake 2 su browser. Si tratta di un esempio di quello che ci aspetta in futuro: la realtà è che il motore Java ha ancora grandi potenzialità da esprimere.

GWT è una soluzione che permette l’utilizzo di applicazioni Web in ambiente Java: non a caso fa funzionare anche Google Wave.

Quake 2 su browser è un esempio del futuro 3D online. Da quando Google rilasciò nel 2008 una demo di Quake per Native Client (NaCl) è passato del tempo: un’occhiata al video pubblicato online non lascia dubbi.

Sun Microsystems Inc. ha annunciato la disponibilità di Java™ Platform Enterprise Edition 6 (Java EE 6).

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

Guava è una collezione di librerie Java non presenti in Google Collection Library anche se quest’ultima presto sarà incluso nel progetto. Al momento sono solo tre i namespace inclusi in tale progetto: com.google.common.primitives, com.google.common.io e com.google.common.util.concurrent. Queste librerie arricchiscono quelle Java con molte classi e API create dal gruppo di sviluppatori Google e utilizzate in molti dei loro progetti realizzati con tale linguaggio.

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

In questo articolo esamineremo e utilizzaremo la libreria open source Skype4Java, per interagire con Skype, uno dei programmi VoIP più diffusi al mondo. Questa libreria può essere concettualmente suddivisa in due parti: la prima, contenente le classi e le interfacce Java utilizzabili dal programmatore, e la seconda che comprende le librerie native, richiamate tramite tecnologia JNI (Java Native Interface), per la comunicazione a basso livello con il client Skype.

È 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

Dal blog ufficiale il Ceo di Sun annuncia in anteprima gli obiettivi del progetto nome in codice Vector: realizzare un App Store per mettere in contatto gli infiniti programmatori Java con il pubblico ancora più vasto degli utenti. Il modello di Apple applicato su scala infinitamente più grande e per gli applicativi su desktop.
Ha tutte le carte in regola per diventare l’App Store definitivo, il negozio online più vasto e in grado di coinvolgere un numero esteso di programmatori, per non parlare di un pubblico potenziale di oltre 1 miliardo di utenti, questa la popolazione stimata. Si tratta del progetto con il nome in codiceVector, rivelato direttamente da Jonathan Schwartz in un post sul blog ufficiale di Sun.

Da un articolo di Xueming Shen, si parla della modifica che ha interessato la codifica UTF-8 in JAVA.

Tale modifica riguarda in particolare il rifiuto della non-shortest-form. Infatti l’interpretazione di questa forma particolare di rappresentazione può essere utilizzata da exploit di vario tipo per ottenere dati sensibili. I dettagli inerenti questa problematica sono ben descritti in un corrigendum, ma vediamo molto brevemente cosa significa.

UTF-8 (Unicode Transformation Format, 8 bit) è una codifica dei caratteri Unicode in sequenze di lunghezza variabile di byte, creata da Rob Pike e Ken Thompson. UTF-8 usa gruppi di byte per rappresentare i caratteri Unicode, ed è particolarmente utile per il trasferimento tramite sistemi di posta elettronica a 8-bit.

UTF-8 usa da 1 a 4 byte per rappresentare un carattere Unicode. Per esempio un solo byte è necessario per rappresentare i 128 caratteri dell’alfabeto ASCII, corrispondenti alle posizioni Unicode da U+0000 a U+007F. Facciamo un esempio per capire meglio. Ecco, la rappresentazione della stringa ABC utilizzando un solo byte:

e utilizzandone due:

Quest’ultimo è proprio un caso di non-shortest-form, poiché rappresentiamo con una sequenza ridondante un carattere Unicode che andrebbe bene anche usando la sua forma più breve. Per avere altri esempi riportiamo il seguente stralcio di codice in grado di mettere a confronto la non-shortest-form con due byte e il carattere rappresentato.

Il corrigendum citato evita il crearsi di questa situazione, specificando qual è la shortest form da usare e impedendo il verificarsi di più non-shortest-form. Ciò previene possibili vulnerabilità dovute a questa differente codifica. Tale nuova interpretazione della codifica UTF-8 è compatibile con le ultime versioni Java: JDK7, Open JDK 6, JDK 6 update 11 e successive, JDK5.0u17 e 1.4.2_19. Chi fosse invece curioso di vedere la sua interpretazione in codice, ecco un confronto tra la nuova e la vecchia versione della classe UTF_8.

Modifiche nella codifica UTF-8 in Java

Il meccanismo della serializzazione consente di salvare oggetti Java all’interno di file (File di tipo ByteCode) oppure di trasmetterli in rete come informazioni a se stanti.

L’utilità di questo meccanismo è ovvia: poter salvare lo stato interno degli oggetti in un file per poterlo recuperare in un secondo momento, oppure poter trasmettere informazioni aggregate nella rete in un solo colpo senza doversi preoccupare di scinderle in informazioni primitive da trasmettere separatamente.

Cerchiamo di capire come può tornarci utile la serializzazione: supponiamo di avere una classe chiamata Record che rappresenta l’informazione di un dipendente. La struttura di questa classe, potrebbe essere la seguente:

public class Record {
private String nome;
private String cognome;
private Date dataNascita;
private int livello;
public Record(String nome, String cognome, Date dataNascita) {
this.nome = nome;
this.cognome = cognome;
this.dataNaschta = dataNascita;
livello = 0;
}
... // Altri metodi per recupero e
... // settaggio informazioni
}

Durante l’esecuzione del nostro programma potremmo avere una lista (un ArrayList, un Vector o quant’altro) che viene popolata mano a mano che vengono aggiunte le informazioni sui dipendenti. Questa lista, quindi, conterrà tante istanze della classe Record quanti sono i dipendenti che sono stati codificati. Sarebbe opportuno che, alla fine della giornata, quando l’applicazione viene chiusa non venissero perse tutte queste informazioni. Sarebbe ancora più bello non dover salvare queste informazioni all’interno di semplici file di testo (o file XML), che chiunque può andare liberamente a modificare.

Entra in gioco, quindi, la serializzazione: possiamo dire al nostro programma di andare a salvare in un file particolare, tutte le istanze della classe Record che sono state create. Questo file non sarà leggibile all’occhio umano, ma sarà codificato in ByteCode. Per fare questo, è sufficiente modificare leggermente l’intestazione della classe Record affinchè essa implementi l’interfaccia Serializable:

public class Record implements Serializable {

L’interfaccia Serializable, come si può vedere dalla documentazione, non prevede alcun metodo. E’, quindi, un’interfaccia vuota, che serve solo al compilatore per capire che quell’oggetto va trattato in modo particolare. Quello che viene fatto al bytecode della classe esula dagli scopi di questo articolo, ma in buona sostanza si può dire che viene aggiunto un campo nascosto chiamato “serialVersionUid“, che serve a contraddistinguere la versione della classe e a marcarne la serializzabilità.

Fatto questo, è possibile salvare ciascuna istanza della classe Record all’interno di un file. Per farlo è sufficiente costruire un ObjectOutputStream su di un file e salvarci dentro le istanze utilizzando il metodo writeObject(). Ecco un esempio, che salva tutti gli oggetti Record contenuti in un ipotetico Vector di dipendenti, chiamato appunto “dipendenti”:

public void salvaDipendenti() {
try {
// Apriamo il file
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("dipendenti.dat")
);

// Dopo vedremo il perché di questa linea
oos.writeObject( new Integer(dipendenti.size()) );

// Salviamo tutti i record
for(int i=0; i<dipendenti.size(); i++) {
oos.writeObject( (Record) dipendenti.elementAt(i) );
}

// Chiudiamo il file
oos.close();
} catch (Exception e) {
e.printStackTrace();
}
}

Quello che ci rimane da vedere ora è come recuperare le informazioni salvate nel file. Come ci si può facilmente aspettare, tutto quello che dovremo fare è creare un ObjectInputStream che vada a leggere il file creato precedentemente. Ciascun oggetto salvato nel file contniene un’istanza della classe Record, tranne il primo: nel primo abbiamo inserito un oggetto Integer che ci serve per sapere quante istanze di Record ci sono nel file. Questo è un semplice trucco per evitarci troppi problemi in fase di lettura:

public void leggiDipendenti() {
try {
// Apriamo il file
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("dipendenti.dat")
);

// Leggiamo il numero di dipendenti salvati
int numDip = ((Integer) ois.readObject()).intValue();

// Ora usiamo questo numero in un ciclo for di letture
for(int i=0; i<numDip; i++) {
dipendenti.add( (Record) ois.readObject() );
}

// Chiudiamo il file
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
}

Come possiamo vedere da questi due esempi, un file ByteCode può contenere diversi tipi di oggetto (nel nostro caso, un Integer e tanti Record). L’importante è capire che possono essere salvati su file solamente “oggetti” e non tipi di dato primitivo (anche se questi possono essere presenti nell’oggetto che andiamo a serializzare), per ciascuno dei quali è prevista l’apposita classe wrapper. Quello da fare sempre, è di inserire come prima informazione, il numero di oggetti che saranno scritti successivamente. In questo modo sarà più facile recuperarli esattamente in futuro.

Non è, ovviamente, l’unico modo di procedere. Si può operare in modi differenti:

• Testando la fine del file: per far questo è necessario utilizzare il metodo available() che ritorna il numero di byte che è ancora possibile leggere senza interruzioni. Ovviamente è necessario utilizzarlo come condizione di un ciclo while, condizione che dovrà essere testata ad ogni lettura (e non è molto performante effettuare test sui file);
• Catturando una EOFException: questo implica di continuare a leggere finchè non viene sollevata questa eccezione. Ovviamente l’eccezione andrà gestita separatamente e l’intera struttura del blocco di lettura va rivista a questo scopo (visibilità delle variabili, ritorno da eccezione, ecc.).
• Calcolando il numero di oggetti a runtime: la procedura non è bellissima a vedersi, ma può funzionare. Si controlla da subito la dimensione del file; si legge il primo oggetto e si controlla quanti byte sono stati letti (dimnesione iniziale – valore di available() ); si stima quanti altri oggetti ci sono dividendo il valore di available() per il numero di byte letti all’inizio.

Insomma, ognuno si può inventare quello che vuole. Io credo che la soluzione più pulita sia quella di memorizzare come primo oggetto un intero che indica chiaramente quanti altri oggetti incontrerò nella lettura.

La serializzazione, come detto all’inizio, è di fondamentale importanza anche per la trasmissione delle informazioni in rete. Pensiamo, ad esempio, ad una chat, dove la comunicazione tra client e server avviene tramite lo scambio di messaggi. Vi saranno messaggi che rappresentano i veri e propri messaggi che gli utenti della chat si scambiano, ma vi sono anche messaggi di utilità per client e server: alcuni esempi sono la comunicazione del nome utente e la password, l’informazione sulla lista di utenti attivi, le comunicazioni di arrvo di nuovi utenti o abbandono di altri, ecc. Ciascun messaggio può essere rappresentato da una classe “Messaggio” che incapsula tutte le caratteristiche richieste e che rappresenta il protocollo di comunicazione tra client e server: tale classe andrà ovviamente serializzata.

Concludendo, quindi, la serializzazione è un processo molto importante e utile in tutti i casi in cui si debba tenere traccia dello stato degli oggetti o quando essi devono essere inviati nella rete. Tutto quello che è necessario fare è implementare l’interfaccia Serializable, tenendo presente che all’interno di classi che implementano Serializable possono essere inseriti solo oggetti di tipo primitivo o serializzabili a loro volta. La maggior parte delle classi del core Java sono già serializzabili e pure tutti gli array sono automaticamente serializzabili, quindi gran parte del lavoro è già stato fatto a monte.

- La serializzazione in Java

- Interface Serializable

EoD SQL è una piccola API che aggancia queries SQL ad oggetti JAVA. Sono state progettate per essere compatibili con le API “Easy of Development“, che possono essere trovate nell’J2SE 1.6 beta. Il loro scopo principale è quello di mappare i ResultSet SQL agli oggetti JAVA. La maggior parte degli strati di OR mapping, provano a replicare la struttura del database in oggetti, dove l’EoD SQL scrive il codice SQL, mentre per facilitare l’accesso consente agli oggetti JAVA di mappare il ResultSet.

I vantaggi di Eod SQL:

Svantaggi:

La relesa EoD SQL 2.0 è disponibile a questo indirizzo.

Sun Microsystems ha annunciato il rilascio di JavaFX 1.0, una nuova piattaforma che permette di costruire “Rich Internet Applications” (RIA) per browser web e desktops. Sviluppatori e web designers possono sfruttare funzionalità e potenzialità della tecnologia Java con i RIAs per realizzare applicazioni per tutti i tipi di screens, da desktop e TV a browser e dispositivi mobili.

Andiamo ad approfondire le sue caratteristiche.

RIA per tutti i tipi di screens

JavaFx fornisce la possibilità di costruire applicazioni “rich client” che integrano “rich immersive media” come ad esempio audio e video, grafica, rich text e web services, per tutti i tipi di screens, dal desktop alla TV dal browser ai dispositivi mobili.

Creatività senza confini

JavaFx facilita l’integrazione di video, audio, grafica, animazioni e rich text. Le applicazioni possono combinare audio e video, grafica 2D con grafica 3D, trasformare prospettive e rich text, con convincenti effetti visivi e trasformazioni.

Sinergia tra sviluppori e designers

JavaFx permette a designers e sviluppatori di semplificare, unificare e rapidamente combinare grafica e media assets con il minimo sforzo. Riduce i tempi di produzione offrendo un intuitivo workflow developer-designer, consentendo ai designers, che utilizzano tools di grafica come Photoshop e Adobe Illustrator, di pubblicare i loro contenuti nei vari tipi di screens in modo intelligente, organizzato e semplificato.

Preservare gli investimenti Java

Gli sviluppatori Java possono preservare i loro investimenti riusando le librerie Java nelle applicazioni JavaFx. Permette infatti di importare qualsiasi classe Java, creare nuovi oggetti e chiamare metodi al suo interno.

Semplice linguaggio dichiarativo per cervelli creativi

Le applicazioni JavaFx sono scritte in JavaFx Script, un linguaggio progettato per sviluppatori web e designers tecnici che preferiscono programmare in un contesto visuale. Questo è un linguaggio di scripting semplice, dichiarativo e facile da imparare che permette agli sviluppatori di scrivere codice che corrisponde ai layout GUI (Grafical User Interface). JavaFx Script ha una potente caratteristica di legame con i dati, che è una semplice sintassi per sincronizzare lo stato di oggetti multipli, consentendo ai componenti GUI di cambiare automaticamente stato con il cambiamento di fondo dei dati.

Continuare ad usare skills e tools già esistenti

La JavaFX Production Suite contiene una suite di tools e plugin per Adobe Photoshop e Adobe Illustrator, consentendo ai designers di riusare i loro già esistenti skills senza dover imparare nuovi tools. Infatti possono semplicemente esportare la loro grafica dai loro tools al formato JavaFx.

Conversione in un click

I designers possono convertire i loro elementi grafici da Adobe Photoshop e Adobe Illustrator nel formato JavaFx con un singolo click. Il plugin infatti fornisce una preview del contenuto convertito permettendo di apportare modifiche prima della conversione finale. I designers lavorano con Scalable Vector Graphics (SVG), e con editors come Inkscape possono convertire i loro SVG nel formato JavaFx con il JavaFX Media Factory.

Tra le innovazioni principali introdotte in JavaFx c’è la piattaforma Java Drag-to-Install che permette di trascinare (drag-and-drop) l’applicazione dal browser al desktop. Questo permette agli utenti di spostare le applets che sono in esecuzione sul browser, direttamente sul loro desktop.

JavaFx 1.0 è disponibile per il download sul sito ufficiale (http://www.javafx.com) dove è possibile scaricare l’SDK, oppure una versione di NetBeans con il plugin integrato, con utili palette per la costruzione rapida di componenti JavaFX.