Newsgroup: it.comp.java
Titolo: architettura multistrato e ActionListener

devo realizzare un programma in Java avente architettura multistrato ( 
tipo MVC ma con diverse semplificazioni) e sto riscontrando qualche 
grattacapo con la suddivisione delle competenze tra i vari strati. ho un 
strato "applicazione" in cui saranno presenti tutte le classi di 
"controllo" e poi uno strato superiore che costituisce l'interfaccia del 
software.
ho realizzato tale interfaccia, però non so come gestire 
l'ActionListener associato alla finestra che ho creato.
infatti quando viene attivato l'actionListener, viene solitamente 
eseguito il codice al suo interno, però tale codice, contenendo tutta la 
logica di gestione delle azioni, nel mio caso dovrà trovarsi all'interno 
della classe di controllo e non in quella di interfaccia.
una possibile soluzione sarebbe quella di inserire l'actionListener 
nella classe dell'interfaccia e, al momento della decisione dell'azione 
da fare, far ritornare il controllo alla classe di controllo (che ha 
chiamato quella di interfaccia) passando una struttura con tutti i dati 
al suo interno.
questa soluzione mi sembra 1 pò sporca e quindi vorrei sapere se esiste 
qualcosa di + pulito o se mi consigliate altro visto che sono abbastanza 
inesperto in questo campo. grazie

 [...]
Potresti implementare il listener nello "strato di controllo": quando viene
lanciato l'evento è lo strato di controllo che esegue il codice opportuno,
eventualmente colloquiando con l'interfaccia della quale - naturalmente -
avrà piena visibilità.

 della classe di controllo e non in quella di interfaccia.
I metodi dell'action listener chiamano metodi di un manager in cui 
racchiudi la business logic.
Il listener giustamente come dici tu non può essere "spostato".

il prob è che non so come farlo. ora faccio l'esempio del login e la 
struttura è:
class CLogIn
{
	public CLogIn()
	{
		System.out.println("avvio controller login");
	}
 
	public void esegui()
	{
		System.out.println("Esegui è stato avviato");
		LogIn finestraLogIn = new LogIn();
		finestraLogIn.showWindow();
	}
}
class LogIn extends JFrame implements ActionListener
{
	public void actionPerformed(ActionEvent evento)
	{
		.....
	}
	public void showWindow()
	{
		System.out.println("creazione interfaccia login");
	}
}
(le due classi si trovano in due file distinti)
creo un'istanza di clogin e su questa si esegue il metodo esegui.
qui verrà creata l'istanza "finestraLogIn" su cui verrà eseguito il 
metodo "showWindow" per far apparire la finestra del login.
ora il mio problema è che, avendo due distinte classi per il controllore 
e per l'interfaccia, non so come poter inserire l'actionListener (ke ora 
sta nella classe interfaccia) all'interno della classe di controllo.
e se lo inserissi, come faccio a farlo richiamare quando viene eseguita 
un'azione sull'interfaccia?
grazie
gianluca ha scritto:


> [scusa se non riporto, troppo incasinato]
E' semplicissimo: metti il Listener nella classe di controllo; può
essere una classe interna, una classe anonima, la classe di controllo
stessa... dipende da come è meglio per te ma in sostanza quando
fai addActionListener() il listener non è nell'interfaccia ma nelle
classi di controllo! Tutto qua.
Nel tuo caso, per esempio:
CLogIn implements ActionListener {
    LogIn finestraLogIn = new LogIn();
    finestraLogIn.addActionListener(this);
omaggi

ti ringrazio per l'aiuto. un'altra domanda.
all'interno del metodo "showWindow" della classe LogIn io creo 
l'interfaccia (con i vari bottoni e campi).
se il metodo actionListener lo definisco, e quindi inserisco, 
all'interno della classe controllo CLogIn come faccio ad associare 
l'actionListener ai bottoni?
perchè prima facevo semplicemente
pulsanteOk.addActionListener(this);
quindi ora nella classe controllo non posso fare riferimento 
direttamente al pulsante poichè quello è definito all'interno della 
classe interfaccia.
ti ringrazio.
gianluca ha scritto:


ho risolto:
nella classe interfaccia ho creato un metodo che in base al parametro 
passatogli mi ritorna il rispettivo bottone, e quindi utilizzo tale 
metodo nella classe di controllo per avere il riferimento al bottone 
dell'interfaccia.
penso che sia un espediente abbastanza pulito e che rispetta la 
gerarchia utilizzata, che ne pensi?
foxmolder5 ha scritto:


 gerarchia utilizzata, che ne pensi?
Molto più semplice: se l'interfaccia prevede che la gestione degli
eventi sia affidata a classi esterne di controllo allora è più corretto
ed anzi del tutto naturale inizializzare l'interfaccia passandogli il
riferimento al listener. Per esempio passi il listener nel costruttore
o con un metodo di inizializzazione e poi l'associ in maniera del
tutto naturale ai bottoni.
Altro discorso è considerare invece se il codice "di controllo" deve
interagire con i bottoni od altri elementi dell'interfaccia: in questo
caso utilizzerai metodi appositi dell'interfaccia stessa su cui
naturalmente il codice di controllo ha visibilità diretta.

la classe controll gestirà l'interfaccia. il compito dell'interfaccia è 
solo quello di creare l'interfaccia e di fornire metodi per l'accesso 
alla stessa (come per esempio metodi per ottenere il valore di un 
determinato campo o box). in questo modo distinguo il + possibile 
l'interfaccia dal controllo e creo classi altamente riusabili.
gianluca ha scritto:
