Le design pattern Observer

Afin d'avoir une mise à jour régulière des données, nous utiliserons un Thread. Ce thread incrémentera une valeur, dans notre cas un entier, puis s'endormira pour un temps donné.

Nous allons donc créer une classe contenant un entier nommé count :

public class CounterJob {
	private int count;
	public CounterJob() {
		super();
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}
}

Cet objet étant l'élément sur lequel vont se synchroniser les vues il doit donc pouvoir être observé. Pour cela, notre classe doit hériter de la classe java.util.Observable. Nous obtenons donc la signature suivante :

public class CounterJob extends Observable

Comme nous l'avons dit précédemment, les changements sur notre donnée seront effectués grâce à un thread, puisque la classe hérite déjà d'une classe nous implémentons alors l'interface Runnable (du package java.lang).

public class CounterJob extends Observable implements Runnable

L'interface Runnable nous oblige à implémenter la méthode run(). Dans cette méthode nous allons incrémenter la valeur de l'attribut count puis bloquer l'exécution du thread durant 1,5 seconde.

public void run() {
try {
		while (!Thread.currentThread().isInterrupted()) {
			this.setCount(this.getCount() + 1);
			Thread.sleep(1500);
		}
	} catch (InterruptedException e) {
	}
}

Le principe du pattern Observer impose à la donnée observée de signaler à tous ses observateurs qu'un changement est survenu. Pour cela, nous allons utiliser deux méthodes : setChanged() et notifyObservers(Object o) toutes deux contenues dans la classe Observer. Afin de ne pas oublier de faire ces deux étapes à chaque modification de l'attribut count, nous allons donc modifier le setter de la façon suivante :

public void setCount(int count) {
	this.count = count;
	this.setChanged();
	this.notifyObservers(this.getCount());
}

L'utilisation de la méthode setChanged() est obligatoire car lorsque les observateurs vont vérifier si un changement est intervenu, ils feront appel à la méthode hasChanged(). Si hasChanged() renvoie false, ils n'appliqueront pas les mises à jour que vous avez faites. Enfin, il est possible de d'avertir un observateur spécifique (méthode notifyObserver(Observer obs) ou de tous les prévenir, chose que nous faisons ici.

Il existe deux écritures de la méthode notifyObserver(). La première ne prend aucun paramètre et se contente d'avertir l'observateur qu'une modification a été faite. La seconde écriture prend un paramètre de type Object. Cette écriture nous permettra d'envoyer la donnée modifiée. L'avantage à ce niveau est que l'observateur n'est pas fortement dépendant de l'observé (seul le type de la donnée observée, ici un entier, les lie).

Le gros avantage dans l'utilisation du pattern Observer est que l'on peut créer une multitude d'observateurs différents. Ils n'auront aucun lien entre eux et pourront avoir des tâches complètements différentes. Pour illustrer ce point, nous allons créer deux observateurs, le premier un TableModel (que nous utiliserons dans un JTable) et le second sera une fenêtre (héritage sur JFrame). Afin de créer un observateur, il faut obligatoirement implémenter l'interface java.util.Observer. Chaque observateur doit définir ses propres actions lorsqu'une modification survient. Cette définition se fera dans l'implémentation de la méthode upate(Observable obs, Object obj).

II-B-1. Le TableModel▲

Le table model que nous allons créer est une spécialisation du DefaultTableModel. Il va contenir une liste de String ainsi qu'un DateFormat qui sera utilisée pour composer les données affichées dans la table (une date suivie de la donnée Observable). Voici la signature de la classe :

 

Sélectionnez

public class ObsTableModel extends DefaultTableModel implements Observer

Comme nous l'avons dit précédemment, chaque observateur doit redéfinir la méthode upate(). Pour ce tableModel, lorsqu'une modification survient, nous allons mettre à jour la liste des données et rafraîchir la table.

 

Sélectionnez

@Override
public void update(Observable obs, Object obj) {
Date date = new Date();
this.getValues().add(new String(this.getFormat().format(date)+ " " + obj));
this.fireTableDataChanged();
}

Dans cette méthode, nous récupérons la nouvelle valeur grâce au paramètre obj (ce paramètre est transmit par l'observé lorsqu'il appelle notifyObservers(Object o) ).

Notre table (contenue dans la fenêtre principale de l'application) ressemblera à :

II-B-2. La JFrame▲

Le second observateur sera une spécialisation de JFrame contenant un label (JLabel) dont le texte sera mit à jour à chaque appelle de la méthode update().

Voici la signature de la classe :

 

Sélectionnez

public class ViewFrame extends JFrame implements Observer

Ainsi que la méthode update :

 

Sélectionnez

@Override
public void update(Observable o, Object obj) {
this.getLabel().setText("Value="+obj);
}

Voici la fenêtre secondaire :

Comme vous pouvez le voir sur les captures d'écran ci-dessus, notre MainFrame est composée de deux boutons. Le premier nous permet de lancer et stopper le thread de compte et le second affichera la fenêtre secondaire.

II-C-1. Le ThreadManagerActionListener▲

public Thread getThread() {
if (this.thread == null) {
		this.setThread(new Thread(this.getCounterJob()));
	}
	return thread;
}

public CounterJob getCounterJob() {
if (this.counterJob == null) {
	this.counterJob = new CounterJob();
this.counterJob.addObserver(this.getMainFrame().getObsTableModel()
	this.counterJob.addObserver(this.getMainFrame().getViewFrame());
	}
	return this.counterJob;
}

@Override
public void actionPerformed(ActionEvent arg0) {
	if (this.getThread().isAlive()) {
		this.getThread().interrupt();
		this.getMainFrame().getBtnStart().setText("Start Thread");
		this.setThread(null);
	} else {
		this.getMainFrame().getBtnStart().setText("Stop Thread");
		this.getThread().start();
}
}

II-C-2. Le ShowViewFrameListener▲

@Override
public void actionPerformed(ActionEvent ae) {
	if(this.getViewFrame().isVisible()){
		if(ae.getSource() instanceof JButton){
			JButton btn = (JButton) ae.getSource();
			btn.setText("Show ViewFrame");
		}
	} else {
		if(ae.getSource() instanceof JButton){
			JButton btn = (JButton) ae.getSource();
			btn.setText("Hide ViewFrame");
		}
	}
	this.getViewFrame().setVisible(!this.getViewFrame().isVisible());
}