Introduzione

La Sun ha rilasciato le specifiche per il suo nuovo modello di componente di nome Java Beans. Ma in cosa consiste un modello di componente ? Si può pensare ad un componente come alla realizzazione della tecnologia di un macro oggetto. In generale un componente è un "cosa" riusabile, componibile, che fu disegnata, costruita ed impiegata per soddisfare una determinata necessità. Tipici componenti che molti usano oggi possono includere ogni cosa come il proprio lettore e-mail o il pezzo di browser che disegna la pagina web JavaBeans estende il concetto di Java di "scrivere una volta e girare ovunque" cercando ancora una volta di venire incontro agli sviluppatori in modo da rendergli la vita più facile, fornendo una sorta di codice "congelato" pronto per l'uso quando ce ne sia la necessità. Questo codice è in grado di girare su ogni OS e entro ogni ambiente applicativo. In pratica un Java Beans consiste in : "Un componente riusabile contenente software che può essere manipolato visualmente in un ambiente generatore di tool" Questo copre un gran numero di possibilità. Gli ambienti generatori di tool possono includere generatori di pagine Web, generatori visuali di applicazioni, generatori di interfacce GUI, o generatori di applicazioni server. Ma tali generatori possono anche consistere in un semplice editor di documenti che include dei beans all'interno del documento stesso. In pratica i Java Beans possono essere componenti semplici come bottoni e sliders o componenti sofisticati come viste di database. Alcuni Java Beans possono non avere un'apparenza GUI loro, ma possono essere composti insieme visualmente usando un generatore di applicazioni. Alcuni ambienti generatori possono operare interamente visualmente permettendo la connessione diretta dei Java Beans insieme. Altri generatori possono aiutare gli utenti a scrivere in maniera corretta le classi Java che interagiscono con un insieme di beans. Altri generatori possono fornire dei semplici linguaggi script che permettono la generazione di un insieme di beans.. I Java Beans potranno variare nelle funzionalità supportate ma avranno in comune i seguenti punti: - Un supporto per l'introspezione cosi' che i generatori di tool possono analizzare come lavora un bean - Un supporto per la personalizzazione cosi' che in un generatore di applicazioni l'utente può personalizzare l'apparenza e il comportamento di un bean - Un supporto per gli eventi con un semplice simbolismo di comunicazione (cioè un aiuto tipo wizard) che può essere usato per collegare tra di loro i bean (tipo : l'azione su di un bean comporta un effetto su di un altro bean). - Un supporto per le proprietà usabili sia per la personalizzazione che per la programmazione. - Un supporto per la persistenza, in modo che dopo che un bean è stato personalizzato in un'applicazione esiste la possibilità di conservare il suo nuovo stato mediante il suo salvataggio su disco.

Esempi di utilizzo di Java Beans.

Notare che un bean può essere usato sia da un generatore di tool che direttamente dal programmatore ; cioè tutte le chiavi API relative a eventi, proprietà, e persistenza sono state disegnate per essere utilizzate sia direttamente dal programmatore che dal generatore di tool. Per chiarire meglio il concetto secondo il quale un Java Beans può essere usato sia in un generatore di tool che in una applicazione Java scritta a mano, riportiamo la traduzione di 2 esempi presenti nelle specifiche dei Java Beans fornite da Javasoft, il primo esempio illustrante l'uso di componenti Java Beans in un generatore di tool , e il secondo l'uso degli stessi in un Applet scritta a mano. Negli esempi si fa uso della terminologia "oggetto serializzato" : si tratta di una tecnica che usa dei meccanismi per salvare oggetti su file, semplicemente salvando una rappresentazione dell'oggetto, e poi fornendo un costruttore o un meccanismo in grado di ricreare l'oggetto dal file. Questi file hanno estensioni ser e gli oggetti contenuti vengono detti "serializzati". Inoltre si fa uso di alcune classi e alcuni metodi presenti nelle Java Beans 1.0 API fornite dalla Sun per costruire Java Beans :
1. Beans. Classe appartenente al package java.beans che fornisce alcuni metodi per leggere le caratteristiche generali del bean.
1.1. Beans.instantiate(ClassLoader, String). Metodo che legge in un bean da un oggetto serializzato.
2. Introspector. Classe, appartenente al package java.beans, che fornisce una maniera standard per i tools di apprendere tutto circa le proprietà, gli eventi e i metodi supportati dallo specifico Java Bean.
2.1. Introspector.getBeanInfo. Metodo che impara tutto sulle proprietà, i metodi e gli eventi del Java bean e restituisce le informazioni sotto forma di un oggetto BeanInfo.
3. Customizer. Interfaccia, appartenente al package java.beans, che fornisce una applicazione di aiuto GUI per creare un modello del Java Bean (si pensi ai vari wizard presenti in alcuni ambienti di sviluppo che mediante una serie di pannelli grafici aiutano gli sviluppatori a creare l'oggetto di cui hanno bisogno).
4. BeanInfo. Interfaccia, appartenente al package java.beans, che fornisce i metodi per reperire informazioni circa sulle proprietà, i metodi e gli eventi del Java bean in esame.
5. ActionListener. Interfaccia appartenente al package java.awt.event (nuova libreria API del jdk java 1.1.) che ha il compito di intercettare gli eventi action.
5.1. ActionListener.actionPerformed(ActionEvent). Metodo che viene invocato quando si erifica un evento action.
6. Button. Classe appartenente al package java.awt (nuova libreria API del jdk java 1.1.) che gestisce il componente bottone.
6.1. Button.addActionListener(ActionListener). Metodo che permette di registrare l'evento action riguardante il bottone nello specifico intercettatore di eventi action ActionListener).
7. ActionEvent. Interfaccia appartenente al package java.awt.event (nuova libreria API del jdk java 1.1.) che riunisce tutti i metodi che gestiscono le informazioni sugli eventi action.
8. ClassLoader. Classe, appartenente al package java.awt.event (nuova libreria API del jdk java 1.1.) che può essere usata per definire una politica di caricamento delle classi java nell'ambiente runtime.
9. Class. Classe, appartenente al package java.awt.event (nuova libreria API del jdk java 1.1.) L'istanza di una classe Class rappresenta l'oggetto più astratto tra i vari formati Java
9.1. Class.getClassLoader(). Metodo che ritorna la classloader caricata dalla specifica Class. Ritorna null se questa Class non è stata caricata da una classloader.

Uso di un generatore di applicazione per costruire un Applet

In questo scenario un utente usa un generatore di applicazioni per creare un applet. Questo prodotto genera vari pezzi di codice sorgente e fornisce all'utente dei modelli in generale visuali (template) corrispondenti a varie funzionalità nelle quali l'utente può digitare il proprio codice sorgente. Riportiamo tutti i passi che l'utente deve seguire per sviluppare la sua applet (in questo esempio si fa riferimento ai metodi e alle classi presenti nelle API JavaBeans fornite da JavaSoft) :

1. Comprare i tools.

L'utente compra ed installa un generatore di applicazioni Java di nome per esempio "WombatBuilder". L'utente compra alcuni componenti Java Bean. Egli ottiene quindi un floppy contenente dei beans in un file JAR. Supponiamo che questi componenti includano un "Button" per la creazione dei bottoni e un "DatabaseViewer" per la gestione delle viste di un database. L'utente inserisce il floppy nella macchina e clicca sulla voce di menù di WombatBuilder "Add bean...". Poi copia i bean nella sua collezione di bean. (WombatBuilder può sia analizzare i beans a questo punto per imparare tutto circa i loro attributi, oppure aspettare fino a quando i beans non sono usati).

L'utente crea una nuova applet chiamata e gli da' il nome "Foobaz" in WombatBuilder. Inizialmente viene creato un Applet vuoto (modello Applet). WombatBuilder crea un file Foobaz.java. L'utente seleziona un "button" dal menu dei beans di WombatBuilder e lo trascina sul modello dell'applet. WombatBuilder usa "new Button()" per allocare una nuova istanza. WombatBuilder aggiunge il nuovo bottone come elemento contenuto nella classe Foobaz class. L'utente seleziona un "database viewer" dal menu dei beans di WombatBuilder e lo trascina sul modello dell'applet. Poiché il database viewer è un bean piuttosto complesso esso può essere rappresentato da più stati di inizializzazione. WombatBuilder quindi usa il metodo Beans.instantiate per leggere in un'istanza di oggetto a più stati (serialized object). Poi aggiunge il nuovo database viewer come elemento contenuto nella classe Foobaz class.

L'utente seleziona il bottone e chiede a WombatBuilder di editarlo. WombatBuilder usa il metodo Introspector.getBeanInfo per ottenere un oggetto BeanInfo descrittivo del bean e scopre che questo bean non ha un Customizer (cioè non ha un bean come strumento di aiuto per la sua personalizzazione). Così usa le informazioni presenti in BeanInfo circa i nomi delle proprietà di lettura/scrittura del bean e genera una semplice tabella contentente i nomi delle proprietà e i loro correnti valori.. L'utente allora interviene sulla tabella delle proprietà modificandole a suo piacimento per cambiare l'apparenza del bottone. Non appena viene richiesto l'aggiornamento dell'applet questo viene propagato all'indietro fino al bean. L'utente seleziona il database viewer e chiede a WombatBuilder di editarlo. Usando Introspector.getBeanInfo, WombatBuilder scopre che il database viewer possiede un proprio bean Customizer class. WombatBuilder istanzia un oggetto della classe customizer e gli chiede di personalizzare il componente. Il customizer del database viewer attiva una serie di finestre di dialogo che guidano l'utente attraverso i passi di selezione del nome di un database e di identificazione di tabelle e records da visualizzare. Il customizer del database viewer usa un insieme di package di metodi privati per inizializzare lo stato del bean database viewer.

L'utente ora decide di usare il bottone per agire sul database viewer. Esso seleziona il button sulla maschera e richiama la voce di menù "events" del WombatBuilder per visualizzare i suoi eventi, dopo di che seleziona l'evento "action". WombatBuilder crea un modello corrispondente al metodo "Foobaz.button1Action" e lancia un text editor in modo che l'utente può digitare il codice sorgente relativo al metodo. L'utente digita il codice sorgente. Per esempio in questo caso semplicemente richiama il metodo "update" che serve per aggiornare il database. Così viene automaticamente generato il seguente codice:

 

class Foobaz extends WombatBuilderApplet {

        public Button button1;

        public DatabaseViewer databaseViewer1;
 
 

        void button1Action(java.awt.event.ActionEvent evt) {

        databaseViewer1.update();

        }

}
 

Inoltre, dietro la scena, WombatBuilder crea una classe per connettere il button all'applet Foobaz. Il codice potrebbe essere il seguente :

class Hookup1234 implements java.awt.event.ActionListener {

        public Foobaz target;

        public void actionPerformed(java.awt.event.ActionEvent evt) {

        target.button1Action(evt);

        }

}


WombatBuilder crea una nuova istanza di Hookup1234 class e riempie il suo campo "target" field con il target applet. Poi prende l'oggetto sul quale si vuole attivare l'evento e lo registra con il metodo "addActionListener". Questo completa il tutto.

L'utente decide che il progetto è finito e da il comando "make it so". WombatBuilder usa la serializzazione di Java per memorizzare l'oggetto Foobaz in un file Foobaz.ser. Anche le istanze dei 2 bean (button1 e databaseViewer1) vengono memorizzate nel file Foobaz.ser. WombatBuilder genera poi del codice di inizializzazione per icostruire l'evento.WombatBuilder crea un file Foobaz.jar contenenti i file .class necessari all'applet inclusa la classe hookup1234 .class file and the .class che serve ai beans.Poi genera una semplice pagina HTML page che usa il tag applet er caricare il file Foobaz.ser dal file Foobaz.jar.

L'utente testa l'applet nel suo web browser di nome per esempio SpaceWars. Quando visita la pagina html l'applet è inizializzata dalla lettura del suo stato serializzato nel Foobaz.ser dentro il file Foobaz.jar. Poi le varie classi sono caricate prelevandole dal file Foobaz.jar. Come risultato si ha un applet che gira e attiva l'evento associato database viewer quando si interviene sul bottone.
 

In questo scenario usiamo alcuni componenti Java beans in un Applet scritto a mano. This scenario è abbastanza simile alla costruzione in un Appplet di un semplice componente AWT, ed è inteso illustrare come i beans possono essere usati senza particolari tools.

1. Caricare i tools.

L'utente scarica e installa il JDK, nel quale si trova il compilatore javac.
L'utente nota alcuni componenti Java Bean su una pagina web per esempio "Dave's Freeware Components Page". Allora tramite ftp scarica un file jar contenente i beans che gli interessano. L'utente usa il comando "jar" per estrarre il contenuto del file jar e lo mette in una sua qualsiasi directory "classes". Le classi includono un componente "Button" e un componente "DatabaseViewer".

L'utente inizia a digitare il codice per la nuova Applet. Nel metodo "init" crea un dave.Button e un dave.DatabaseViewer. Per il dave.Button esso può semplicemente usare "new". Invece, il dave.DatabaseViewer ha alcuni stati serializzati, così l'utente deve usare Beans.instantiate per leggere nell'oggetto serializzato.

class MyApplet extends java.awt.Applet

  {

        public void init()

        {

          btn = new dave.Button();

          add(btn);

             try  {

                 ClassLoader cl = Class.forName("dave.DatabaseViewer").getClassLoader();

                 dbViewer = Beans.instantiate(cl, "dave/DatabaseViewer.ser");

                 add(dbViewer);

             }

             catch (Exception ex)

                 {

                 throw new Error("Non si può costruire l'oggetto dbViewer");

             }

       }

       private DatabaseViewer dbViewer;

       private Button btn;

}

L'utente decide di intervenire sull'apparenza e il comportamento dei componenti, così aggiunge nel metodo MyApplet.init le chiamate ad alcuni metodi di impostazione delle proprietà dei Beans e precisamente :
 
 

   btn.setBackground(java.awt.Color.red);

e

4. Collegamento dei beans

L'utente decide di usare il bottone per accedere al database viewer. Il bottone focalizza i suoi eventi nell'interfaccia java.awt.event.ActionListener. Poiché egli ha una sola applet con un solo bottone decide di costruire la classe MyApplet implementando direttamente ActionListener e aggiunge il metodo "actionPerformed" richiesto dall'interfaccia ActionListener:

                dbViewer.update(); // esegue un'azione sul DB viewer.

        }

Dopo di che per poter agganciare l'evento al momento dell'azione sul bottone, l'utente aggiunge nel metodo MyApplet.init l'istruzione: btn.addActionListener(this);

L'utente decide che ha finito. Allora compila MyApplet.java e aggiunge la classe risultante MyApplet.class file nella sua directory delle classi. Egli crea una pagina HTML per il test dove inserisce il tag appet con riferimento a MyApplet con lo specifico codebase.

L'utente testa l'applet nel suo web browser SpaceWars. Quando visita la pagina html l'applet è inizializzata dal metodo MyApplet.init. Il metodo MyApplet.init esegue un "new" del bean Button e usa Beans.instantiate per leggere il bean DatabaseViewer non inizializzato. Il metodo init allora chiama i vari metodi setXXX per personalizzare i beans e il metodo button.registerActionListener per agganciare gli eventi del bottone.
Come risultato si ha un applet che gira e attiva l'evento associato database viewer quando si interviene sul bottone. Qui' c'è il codice dell'applet scritta a mano :

 

class MyApplet extends java.awt.Applet implements java.awt.event.ActionListener

        {

        // Inizializzazione dell'Applet.

                public void init()

                {

                        btn = new dave.Button();

                        add(btn);

                        try

                        {

                            ClassLoader cl = Class.forName( "dave.Button").getClassLoader();

                            dbViewer = Beans.instantiate(cl, "dave/DatabaseViewer.ser");

                            add(dbViewer);

                        }

                        catch (Exception ex)

                        {

                        throw new Error("Non si può costruire l'oggetto dbViewer");

                        }
 
 

                        btn.setBackground(java.awt.Color.Red);

                        dbViewer.setURL("jdbc:msql://aardvark.eng/stuff");
 
 

        // Aggancia al bottone l'evento che è stato previsto.

                        btn.addActionListener(this);

                }
 
 

        // Metodo che cattura l'action events dal bottone.

                void actionPerformed(java.awt.event.ActionEvent evt)

                {

                        dbViewer.update(); // esegue un'azione sul DB viewer.

                }

                private DatabaseViewer dbViewer;

                private Button btn;
 
 

        }

Borland JbuilderPer quanto riguarda la realizzazione pratica dei Java Beans possiamo dire che Borland International Inc. ha annunciato a WASHINGTON il 30 ottobre 1996 il suo nuovo programma JBuilder Partner per venditori di software creatori di componenti Java Beans. Borland ha lanciato il suo Partner Program in seguito all'annuncio fatto da JavaSoft divisione software della Sun Microsystems di aver ultimato le specifiche per Java Beans. JBuilder è il nuovo nome di Latte, l'ambiente di sviluppo professionale per Java della Borland e fornisce un ottimo supporto per il modello a componenti Java Beans. Questo programma è stato disegnato per aiutare il programmatore nello sviluppo e nei test dei Java Beans costruiti e permette l'uso di predefiniti componenti da assemblare nella propria applicazione. Si possono anche acquistare componenti da altri venditori o costruirne dei nuovi da sé per ottimizzare lo sviluppo di un processo e poter così riusare la sua funzionalità. I componenti JavaBeans scritti dagli sviluppatori una volta sola possono essere usati per farli girare ovunque. Gli sviluppatori potranno quindi usare tali componenti per creare applicazioni che potranno girare in COM, OpenDoc, e LiveConnect della Netscape. Inoltre tali applicazioni saranno indipendenti dalla piattaforma, potranno così girare indifferentemente su PC, Macintosh, UNIX, network computer, o su ogni altra piattaforma che supporti Java. Si possono trovare informazioni presso il sito http://www.borland.com

Symantec Visual Café

Un'altro ambiente di sviluppo da prendere in considerazione è Symantec Visual Café 1.0. Esso è accessibile immediatamente per Windows 95, NT 3.51 e NT 4.0. La versione per Macintosh sarà disponibile presto. Si possono trovare informazioni presso il sito http://cafe.symantec.com. Visual Café è un ambiente di sviluppo visuale che permette di costruire velocemente sofisticate applicazioni usando i componenti JavaBeans. La nuova tecnologia include una programmazione a 2 vie, la visualizzazione rea
 
 

Conclusione

Insomma sembra proprio che oggi gli sviluppatori abbiano i mezzi per la prima volta nella storia dell'informatica, di realizzare il loro grande sogno : "Codice portabile, riusabile, semplice, supportato da ambienti di sviluppo generatori di tool, che facilitando la scrittura di applicazioni, limitano anche gli eventuali errori di programmazione". Abbiamo ancora molta strada da fare, ma il futuro è promettente ed eccitante...
 
 

	MokaByte rivista web su Java MokaByte ricerca nuovi collaboratori Chi volesse mettersi in contatto con noi può farlo scrivendo a mokainfo@mokabyte.it