sorry ero al tel. allora vediamo un po, nei commenti ho aggiunto cosa non va bene
b.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
// il metodo actionPerformed è eseguito nell'EDT
status.setText("Stato: Esecuzione...");
b.setEnabled(false);
p4.setEnabled(false);
// creare questo thread che fa il lavoro (ontologyPopolation) e startarlo qui dentro, ossia nell'EDT, NON è corretto. Devi usare un background thread come ti ha detto PGI-Bis
Thread t = new Thread() {
public void run() {
try {
po.ontologyPopolation(getPathFashion(), getPathMondrian(), getPathOntology());
} catch (Exception e) {
e.printStackTrace();
}
SwingUtilities.invokeLater(new Runnable() {
public void run() {
status.setText("Stato: Caricamento completato");
// b.setEnabled(true);
}
});
}
};
t.start();
}
});
Io procederei così.
1) Partiamo dalla classe con il metodo che fa l'elaborazione tosta. Quella classe la dichiari in modo che extends Observable
2) Aggiungi un metodo tipo questo (nel mio caso è protected perchè sta in una superclasse):
/**
* Set this Observable's state as "changed" and notify its Observers.
*/
protected void changedState(int counter) {
setChanged();
notifyObservers(counter);
}
Poi:
3) Aggiungo al metodo che "elabora" questa istruzione:
// notify the Observers that another configuration has been tested
super.changedState(counter++);
Fin qui dovrebbe essere abbastanza easy. Nota che per ora non ci sono riferimenti a swing, abbiamo toccato solo il Core della tua applicazione, che contiene la classe che fa il lavoro duro. Questo metodo continua ad essere valido anche con altre gui etc. Passiamo alla parte swing:
4) La mia classe che gestisce il lancio della computazione è dichiarata così:
public class FireComputationTask extends Task<Player, Void> implements Observer, PropertyChangeListener {
Player è il tipo che doInBackground ritornerà, può essere anche void in caso. Void è per i risultati intermedi. Implementa Observer quindi può registrarsi per ricevere notifiche dagli Observable che ascolta, e PropertyChangeListener alla fine è un Observable più specifico di Swing diciamo.
5) Copia lo stato della gui in variabili d'istanza di questa classe, ad es:
private final String indirizzo;
public FireComputationTask(String indirizzo)
this.indirizzo=indirizzo
(indirizzo ad es potrebbe essere passato al costruttore facendo jtextbox.getText();
6) metodo fondamentale, doInBackground()
/**
* Executed in a background thread to find out the best Player obtainable from this AbstractGearOptimization instance.
* @return the best Player obtainable from this AbstractGearOptimization instance
*/
@Override protected Player doInBackground() {
// register this to call propertyChange when progress changes via setProgress
this.addPropertyChangeListener(this);
// add this to the list of observers of the AbstractGearOptimization
this.goa.addObserver(this);
// 100 / the number of combinations to test represents the percentage value of every single test
this.percentage = (float)100/this.combinations;
//Initialize progress property.
super.setProgress(0);
System.out.println("["+DateFormat.format(new Date())+"] Starting the optimization using "+this.goa.getClass());
// call the compute method to fire the actual optimization computation and retrieve the best Player for the passed GearOptimizationAlgorithm
return this.goa.compute();
}
questo è il mio. Nota come registro l'oggetto corrente come listener sia per ascoltare Observable che per ascoltare i cambiamenti della variabile progress (mediante Task.setProgress()).
7) In quanto Observer, implemento update
public void update(Observable o, Object arg) {
super.setProgress(Math.min((Integer)arg*this.percentage/100, 100));
}
8) e in quanto PropertyChangeListener
public void propertyChange(PropertyChangeEvent evt) {
if ("progress".equalsIgnoreCase(evt.getPropertyName())) {
int progress = (Integer) evt.getNewValue();
// set the progress bar to the new progress value
this.jprogressBar.setValue(progress);
}
}
9) per finire, il metodo succeeded chiude il tutto
@Override protected void succeeded(Player result) {
// dispose the progress bar frame
this.progressBarFrame.dispose();
...
}
Ricordati che:
- doInBackground è eseguito in un background thread. La chiamata al tuo metodo calcolatore DEVE essere fatta qui dentro, e non puoi accedere ai componenti gui
- succeed è eseguito nell'EDT una volta che doInBackground è terminato, quindi qui puoi accedere ai componenti gui, ma non eseguire task
Naturalmente anche la soluzione di PGI è corretta, la differenza sta principalmente nel fatto che con l'adozione di Observer-Observable hai notifiche sul progress anche fuori da Swing, quindi che ne so domani vuoi fare un utility per usarlo via command line il tuo programma, e già hai tutto pronto.