[java] far comunicare due classi tramite eventi

[tulkas85]

ciao,

il problema di oggi è il seguente:

ho una classe che implementa la mia Gui.

ho una seconda classe che in determinate occasioni dovrebbe comunicare con la gui, in pratica dovrebbe fornirle una stringa con delle info, e la gui a questo punto genera un nuovo Jpanel con un elaborazione di queste info.

quello che non riesco a fare è la segnalazione alla gui.

io avevo pensato di generare un evento e di impostare un listener nella gui di questo evento.

è una strada fattibile ? come la realizzo in pratica ? ho provato con new actionevent e nella gui ho impostato un action performed ma non cattura l'evento !!


spero di aver spiegato il problema...

[Alex'87]

Prova il pattern Observer.

[tulkas85]

ok grazie è una forza questo observable

[tulkas85]

giusto per curiosità , ma volendo è possibile generare un evento in una classe, e catturarlo in un altra ?

[andbin]

Originariamente inviato da tulkas85
ma volendo è possibile generare un evento in una classe, e catturarlo in un altra ?

Ovviamente sì e anzi .... è la cosa che ha più senso ....

[Alex'87]

Originariamente inviato da tulkas85
giusto per curiosità , ma volendo è possibile generare un evento in una classe, e catturarlo in un altra ?

Certo!

Ti spiego un po' la struttura di una applicazione, così magari capisci.

Ho questa interfaccia, in pratica è un "listener" personalizzato:

package jcodecollector.listener;

import java.util.ArrayList;

import jcodecollector.common.bean.Snippet;
import jcodecollector.common.bean.Syntax;

public interface SnippetListener {
    public void snippetEdited(Snippet snippet, boolean isNew);
    public void categoryRenamed(String oldName, String newName);
    public void categoryRemoved(String name);
    public void snippetRenamed(String oldName, String newName);
    public void snippetRemoved(String name);
    public void categoriesUpdated(String selected);
    
   ...

Nel programma ho diverse classi interessate a sapere quando "succede qualcosa". Ad esempio, quando cancello uno snippet devo: 1. toglierlo dal JTree in cui è visualizzato 2. toglierlo dal database 3. aggiornare la barra di stato. Tutte queste classi implementano l'interfaccia postata sopra. Ho poi una classe "centrale" (State) che si occupa di memorizzare i vari listener:

public class State implements SnippetListener, CountListener {
    private ArrayList<SnippetListener> snippetListeners;

    ....
}

All'inizio del programma creo i vari oggetti "ascoltatori" e li passo allo State:

        State.getInstance().addSnippetListener(this);
        State.getInstance().addSnippetListener(snippetPanel);

Quando poi "succede qualcosa" non devo far altro che chiamare il corrispettivo metodo di State. Ad esempio, se viene rinominata una categoria chiamo

    public void categoryRenamed(String oldName, String newName) {
        for (SnippetListener listener : snippetListeners) {
            listener.categoryRenamed(oldName, newName);
        }
    }

In automatico tutti gli interessati (che a loro volta implementano l'interfaccia) verrano notificati di quello che è successo e agiranno di conseguenza.

Spero di essere stato chiaro, eventualmente chiedi pure :master:

[tulkas85]

mmm mi è un pò tutto oscuro...

prima di tutto questo snipper è un interfaccia esistente davvero ?

poi eventualmente come lancio un evento ?

tutti gli ascoltatori ricevono l'avviso dell'avvenuto evento ??

a me in pratica servirebbe avere un evento che posso generare quando mi pare, ed un solo listener che stia in ascolto per quell'evento ... c'è qualche classe java che faccia questa cosa ?

[andbin]

Originariamente inviato da tulkas85
a me in pratica servirebbe avere un evento che posso generare quando mi pare, ed un solo listener che stia in ascolto per quell'evento ... c'è qualche classe java che faccia questa cosa ?

Vorrei chiarirti alcune cose, visto che ti sembra tutto un po' "oscuro".

Il design pattern "Observer" e la gestione dei "listener" (che è una "specializzazione" particolare del pattern Observer) permettono sì di notificare "qualcosa" ad altri oggetti ma l'obiettivo e il concetto principale è anche quello di "disaccoppiare" le due entità "osservabile" e "osservatore".

Se non ti interessa "disaccoppiarli", puoi fare ad esempio:

class A {

        ....
        B b = new B(this);


    public void notifica() {
        ....
    }
}

class B {
    private A a;

    public B(A a) {
        this.a = a;
    }


        // da qualche parte quando devi notificare....
        a.notifica();
}

Con questo la classe B può notificare qualcosa ad A.
Questo non è il pattern "Observer" e nemmeno un "listener" ... è semplicemente un uso minimo/logico della OOP. Un oggetto ha un reference ad un oggetto di un'altra classe e quando necessario invoca un metodo su quel oggetto.... tutto qui.

Quale è il problema?? Il problema è nel "design". Le due classi A e B sono molto "accoppiate" tra di loro!!! La classe A deve istanziare B e passargli il suo reference e questo ancora ancora ok. Ma sopratutto B deve "sapere" di A e solamente un oggetto di tipo A può essere usato!

Se si volesse fornire un pochino di astrazione in più si potrebbe usare una interfaccia.

interface Notifica {
    void notifica();
}

class A implements Notifica {

        ....
        B b = new B(this);


    public void notifica() {
        ....
    }
}

class B {
    private Notifica n;

    public B(Notifica n) {
        this.n = n;
    }


        // da qualche parte quando devi notificare....
        n.notifica();
}

Ora B non è più "accoppiato" ad A. B "sa" solo di dover notificare un oggetto che implementa la interfaccia Notifica. Potrebbe essere un qualunque oggetto di qualunque classe. A lui non interessa più.
Questo, ancora una volta, non è un "Observer" e nemmeno un listener. Semplicemente è un livello di "astrazione" un pochino maggiore rispetto al caso precedente.


Il pattern "Observer" estende e aumenta ulteriormente il livello di astrazione, definendo un "design" in cui ci sono 2 interfacce, una che identifica un "soggetto" (o "osservabile") e una che identifica un "osservatore".
La interfaccia del soggetto descrive i metodi per aggiungere/rimuovere un osservatore e la interfaccia del osservatore descrive il o i metodi per la/e notifiche.
Quindi qualunque classe potrebbe essere un soggetto e qualunque classe potrebbe essere un osservatore.

[tulkas85]

ok, l'esempio che hai fatto con notifica() mi è chiaro, anche l'uso di observer ed observable, infatti questi ho utilizzato.

speravo che utilizzando i listener la cosa fosse più immediata.