Newsgroup: it.comp.java
Titolo: Sollevare eventi personalizzati

Come faccio in una mia classe a definire dei miei eventi e a sollevarli in
modo che altri oggetti li possano ricevere? Vorrei implementare un
meccanismo simile a quello usato dai componenti per sollevare i loro eventi
con i listener e tutto il resto. Il mio problema è sapere qual'è la via
giusta da seguire e quali parti del framework vanno utilizzate. Se non avete
vogli di impegnarvi in una risposta lunga mi accontento anche del link ad un
tutorial o simili.
Grazie, Rick.
PS: non sto sviluppando Javabeans o altre cose simili ma semplici oggetti
che devono poter notificare ad altri oggetti un cambiamento del loro stato.

C'e' gia' Observer/Observable, niente link, c'e' tutto nella javadoc
standard :-)
BYE

-- 
| Andrea Trentini
| SoftArchiLab - DISCo - Universita' di Milano Bicocca
| mailto:
Andrea....@disco.unimib.it
| 
http://www.atrent.it
| wrk 
+39-02-6448.7856
 | fax 
+39-02-6448.7839

 wrote in message
news:9r7au9$fsb$1...@lacerta.tiscalinet.it...


Ciao, provo a risponderti io.
Inizialmente hai bisogno dell'evento stesso da lanciare. L'evento, diciamo
così, è fondamentalmente un oggetto di trasporto di informazioni.
Un evento personalizzato può derivare direttamente dalla classe EventObject
dentro java.util, oppure da uno qualunque degli eventi tipici dei componenti
AWT come ad esempio ActionEvent. Nella sostanza comunque il tuo evento deve
esporre i metodi che servono ai "Listener" per elaborarli.
Un Listener è un oggetto che, come dice la parola stessa, rimane in ascolto
di determinati eventi che possono verificarsi. Un Listener dovrebbe
implementare
perlomeno l'interfaccia EventListener anche se questa è poi vuota. Ciò che è
importante è che questo oggetto Listener abbia un metodo che sia in grado di
elaborare eventi del tipo che interessa.
Infine è necessario che ci sia un oggetto in grado di "scatenare" gli
eventi. Questo oggetto è la "source" dell'evento, quello che dovrebbe essere
restituito dal metodo getSource dell'evento. La sorgente degli eventi non
deve implementare nessuna interfaccia specifica, ma deve possedere dei
metodi che permettano ai Listener di "registrarsi", ovvero di dare un
riferimento a sè stessi perché possano ricevere gli eventi. Il meccanismo si
completa così in questo modo: Il source "gira" per i fatti suoi e quando è
necessario lancia l'evento. Il lancio dell'evento non è altro che una
chiamata a tutti i Listener del metodo di cui sopra. Ed ecco che ogni
Listener riceve così gli eventi. Per rendere un po' + chiare le cose ti
faccio un esempio:
1) Anzitutto abbiamo un oggetto Event così definito:
public class MyEvent extends EventObject
{
    public Object getSource()  // Restituisce l'oggetto sorgente
    {
        ...
    }
    ... // Altri metodi custom
}
2) Poi abbiamo il Listener
public class MyListener extends EventListener
{
    public void performMyEvent( MyEvent e )        // Gestisce eventi
MyEvent
    {
        ...
    }
}
3) Infine il Source
public class MySource
{
    ArrayList listeners = new ArrayList();
    public void addMyListener( MyListener listener ) // Permette di
aggiungere "ascoltatori di eventi"
    {
        ...
        listeners.add( listener );
        ...
    }
    public void myMethod() // Metodo qualunque che lancia gli eventi
    {
        ...
        MyEvent e = new MyEvent();        // Nuovo evento...
        ...
        // Notifica degli eventi
        for ( int i = 0; i < listeners.size(); i++ )
        {
            listeners.get(i).performMyEvent( e );
        }
    }
}
Chiaramente da qualche parte nella classe dell'applicazione dovrà esserci un
pezzo di codice tipo:
MySource.addMyListener( new MyListener() );
Più o meno questo è tutto. Chiaramente ci sono (molti) altri dettagli come
la "consumazione" dell'evento etc., ma spero che sia chiaro il meccanismo di
funzionamento per "delega" degli eventi.
PS.: In realtà questo non è l'unico meccanismo possibile a Java, sul JDK 1.0
gli eventi erano gestiti per ereditarietà, ma il sistema è stato deprecato
perché era molto pesante ( tutti gli oggetti della gerarchia ricevevano gli
eventi ).
Spero di esserti stato d'aiuto anche se sicuramente il discorso è molto
ampio.
Ciao a tutti
Davide

 stato.
Quindi e' piu' corretto Observer/Observable, quello che tu proponi
serve a crearsi generatori di eventi (AWT/Swing)
personalizzati...
BYE


modo che altri oggetti li possano ricevere?
[CUT]
Qui
http://www.bruceeckel.com/Books/TIJ
e qui
http://java.sun.com/docs/books/tutorial/
c'è sicuramente del materiale interessante ed introduttivo (da cercare
un po') per la gestione eventi di AWT e Swing.
Il concetto generale si può ricondurre al Design Pattern "Observer" di
cui c'è implementazione in Java (anche) nelle interfacce/classi
Observer/Observable.
HTH
-- 
Ciao
	Fabrizio C.


Quello che ho descritto si compila benissimo senza importare classi di awt
né di Swing. Che poi molti eventi specializzati, per forza di cose, siano
utilizzati da componenti awt/swing mi sembra abbastanza ovvio, ma il
meccanismo è senz'altro indipendente, e tra l'altro è tranquillamente
replicabile anche senza utilizzare alcuna classe o interfaccia prestabilita
del JDK.
Ciao
Davide

 standard :-)
Per altre vie ho scoperto l'esistenza di questa tecnica e in effetti ho già
provato ad usarla. Il problema è che non si comporta esattamente come un
meccanismo di raising degli eventi ma è più dedicato alla notifica della
modifica delle proprietà di un oggetto. Dal mio punto di vista questa
tecnica ha dei limiti: se derivo la mia sorgente di eventi direttamente da
observable posso esporre un solo evento o meglio quando un observer si
registra riceverà poi tutte le tipologie di eventi che io deciderò di
sollevare (non posso dire addXXXObserver e addYYYObserver ma ho solo
addObserver e quando mi serve genero una notify a qui passo come argomento
l'evento che sto sollevando, però in questo modo l'observer si becca tutti
gli eventi, anche quelli che non gli interessavano); se invece fornisco la
mia classe con più di un oggetto Observable privato e con una serie di
metodi addXXXObserver, addYYYObserver garantisco ai miei observer la
possibilità di essere notificati solo degli eventi che gli interessano ma io
ho qualche problema nel generare la notifica poiché il metodo
notifyObservers funziona solo se prima è stato chiamato il metodo setChanged
dell'oggetto Observable che però è dichiarato protected (quindi devo
costruirmi una classe che deriva da Observable e rendere pubblico setChanged
e poi usare questa nell'oggetto che espone gli eventi).
Il meccanismo AWT mi sembra più pulito e quello che mi interessava sapere
era se esiste nel framework un qualcosa che consenta di semplificare la
gestione dei listener e la loro invocazione nel momento in cui l'evento
viene generato.
Grazie, Rick.

 ha scritto nel messaggio
news:9r8p1j$pls$1...@lacerta.tiscalinet.it...
....
Grazie per la lunga risposta ma a me interessava sapere proprio quei
dettagli che hai tralasciato perché come funziona il meccanismo l'ho capito
(vedi messaggio di risposta ad Andrea Trentini per maggiori chiarimenti).
Grazie mille ancora, Rick.