Discussion :

[PHPulserz]

Je suis en train de développer une application avec un ami et on se demande si c'est bien de faire comme ça.

On a étudié le pattern observer et on a remarqué que celui-ci faisait une liaison entre modèle (observable) vue (observateur).
Est-ce que le pattern observateur peut être mis en place entre la vue et le contrôleur.

Exemple: j'ai un panel contenant une progressbar, quand celle-ci est terminée, on notifie le contrôleur comme quoi la progressbar est terminée et il peut afficher le panel accueil.

Donc la question: Pattern observer entre vue et contrôleur? est-ce une bonne chose?

[ruscov]

En fait c'est l'inverse que tu devrais faire. L'observer est ton panel et l'observable est ton contrôleur.
Et c'est à chaque changement dans ton contrôleur que ton jpanel va être mis à jour.
Ton controleur à une liste d'observer qui contient ton Jpanel (pas oublier de l'ajouter dans la liste des observer de ton observable. Et a un moment, où un changement est effectué, tu dois lancé un notifyObserver (ou un truc du style) qui va signaler que JPanel doit se mettre à jour.

[PHPulserz]

Ok merci de ta réponse pour appuyer mon message je vous délivre comment nous avons procéder un morçeau du projet

Vues de la progressbar (Observable)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
package vues;
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.util.ArrayList;
 
import javax.swing.JPanel;
import javax.swing.JProgressBar;
 
import observer.ConnexionObservable;
import observer.ConnexionObservateur;
 
 
public class PanneauJProgressBar extends JPanel implements ConnexionObservable
{
	private static final long serialVersionUID = 1L;
 
	// Déclarations des variables
	private JProgressBar pbar = new JProgressBar();
	private final int MINIMUM = 0;
	private final int MAXIMUM = 100;
	private Moteur monMoteur = new Moteur();
 
	// Variable d'observation
	private ArrayList<ConnexionObservateur> mesObsConnexion = new ArrayList<ConnexionObservateur>();
 
	/**
         * Implémentation du constructeur concernant le panneau de la JProgressbar
         * @param pControleurConnexion = On récupère notre controleur de connexion
         */
	public PanneauJProgressBar()
	{
		this.pbar.setMinimum(MINIMUM);
		this.pbar.setMaximum(MAXIMUM);
		this.pbar.setStringPainted(true);
		this.pbar.setForeground(new Color(67, 97, 145));
		this.pbar.setPreferredSize(new Dimension(300,60));
 
		// Layout que l'on utilise
		this.setLayout(new GridBagLayout());
 
		// Objet servant à positionner les composants
		GridBagConstraints gbc = new GridBagConstraints();
 
		gbc.gridx = 0;
		gbc.gridy = 0;
		gbc.gridheight = 1;
		gbc.gridwidth = 1;
		gbc.fill = GridBagConstraints.BOTH;
		this.add(pbar, gbc);
	}
 
	public void progression()
	{
		this.monMoteur.start();
	}
 
	private class Moteur extends Thread
	{
		public void run()
		{
			for(int i = MINIMUM; i <= MAXIMUM; i++)
			{
				try
				{	
					Thread.sleep((int)(MAXIMUM * 2 / (i + 1)));
				}
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}
				pbar.setValue(i);
			}
			notifierObservateur();
		}
	}
 
	/**
         * Méthode qui enregistre un observateur
         */
	public void ajouterObservateur(ConnexionObservateur obs) 
	{
		mesObsConnexion.add(obs);
	}
 
	/**
         * Méthode qui supprime un observateur
         */
	public void supprimerObservateur(ConnexionObservateur obs) 
	{
		int i = mesObsConnexion.indexOf(obs);
		if(i > 0)
		{
			mesObsConnexion.remove(i);
		}
	}
 
	/**
         * Méthode qui notifie un observateur
         */
	public void notifierObservateur() 
	{
		for(int i=0;i<mesObsConnexion.size();i++)
		{
			mesObsConnexion.get(i).actualiserChargement();
		}
	}
}

Le contrôleur (Observateur)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
package controleurs;
 
import java.awt.BorderLayout;
import java.sql.Connection;
 
import modeles.Patients;
import modeles.Proteines;
import modeles.Utilisateurs;
import observer.ConnexionObservateur;
import vues.Fenetre;
import vues.PanneauBanniereBottom;
import vues.PanneauBanniereTop;
import vues.PanneauConnexion;
import vues.PanneauJProgressBar;
 
/**
 * Classe qui sert de controleur à la connexion de l'application
 * @author Coquette Rémy & Lefèvre Kevin
 */
public class ControleurConnexion implements ConnexionObservateur
{
	// Déclaration des variables
	private Fenetre fenetre ;
	private PanneauConnexion panneauConnexion ;
	private PanneauBanniereTop panneauBanniereTop ;
	private PanneauBanniereBottom panneauBanniereBottom ;
	private PanneauJProgressBar panneauJProgressBar ;	
	private Utilisateurs utilisateur ;
	private static Connection CONNEXION ;
 
	/**
         * Implémentation du constructeur concernant le contrôleur de connexion
         * @param pUtilisateurs = Paramètre faisant référence au modèle de l'utilisateur
         * @param pConnexion = On récupère la connexion
         */
	public ControleurConnexion(Utilisateurs pUtilisateur,Connection pConnexion)
	{
		CONNEXION = pConnexion;
 
		this.utilisateur = pUtilisateur;
 
		this.fenetre = new Fenetre();
		this.panneauBanniereTop = new PanneauBanniereTop();
		this.panneauBanniereBottom = new PanneauBanniereBottom();
		this.panneauConnexion = new PanneauConnexion();
 
		this.panneauConnexion.ajouterObservateur(this);
 
		this.fenetre.add(panneauBanniereTop,BorderLayout.NORTH);
		this.fenetre.add(panneauConnexion,BorderLayout.CENTER);
		this.fenetre.add(panneauBanniereBottom,BorderLayout.SOUTH);
	}
 
 
	/**
         * Méthode pemerttant de vérifier l'authentification d'un utilisateur
         */
	public void actualiserAuthentification(boolean pChoix,String pLogin, String pPassword) 
	{
		if(pChoix)
		{
			this.panneauJProgressBar = new PanneauJProgressBar();
			boolean result = this.utilisateur.connexionUtilisateur(pLogin,pPassword);
			if(result)
			{
				this.panneauConnexion.setResult(result);
				this.fenetre.remove(this.panneauConnexion);
				this.fenetre.remove(this.panneauBanniereTop);
				this.fenetre.remove(this.panneauBanniereBottom);
				this.fenetre.add(this.panneauJProgressBar,BorderLayout.CENTER);
				this.fenetre.validate();
				this.panneauJProgressBar.ajouterObservateur(this);
				this.panneauJProgressBar.progression();
			}
			else
			{
				this.panneauConnexion.setResult(result);
			}
		}
		else
		{
			this.fenetre.dispose();
		}
	}
 
	/**
         * Méthode pemerttant d'afficher le panneau d'accueil
         */
	public void actualiserChargement() 
	{
		this.fenetre.remove(this.panneauJProgressBar);
		this.fenetre.validate();
		this.fenetre.repaint();
		new ControleurAccueil(this.fenetre,this.utilisateur,new Patients(CONNEXION),new Proteines(CONNEXION));
	}
}

et voici les deux interfaces:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
package observer;
 
public interface ConnexionObservable 
{
	public void ajouterObservateur(ConnexionObservateur obs);
	public void supprimerObservateur(ConnexionObservateur obs);
	public void notifierObservateur();
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
package observer;
 
public interface ConnexionObservateur 
{
	public void actualiserChargement();
}

Donc, il y a des choses à modifier ?

[Gugelhupf]

En fait c'est l'inverse que tu devrais faire. L'observer est ton panel et l'observable est ton contrôleur.

L'Observable est le Modèle, pas le Controleur.

Son objectif et de diminuer les dépendances entre les couches Modèle et Vue (oui parce qu'entre les deux tu as le Contrôleur).
Une fois que tu as effectuée ta modification dans le Modèle, l'évènement doit être répercutée dans les toutes les Vues via le notifyObservers().
Le pattern Observer est bien lorsque tu n'as qu'une donnée à modifier (méthode update(String message) ).
Personnellement, le pattern Observer possède plusieurs inconvénient selon moi, si par exemple tu as un Observable (un panel) auquel tu veux modifier plusieurs label, tu es obligé de créer une classe pour chaque label (monlabel1 extends label, monlabel2 extends label etc...) et les distinguer avec l'opérateur instanceof, ou pire si tu veux mettre à jour une autre information qu'un label, tu va utiliser un paramètre update(Object o), créer plusieurs classes pour chaque famille d'objet à mettre à jour, et les différencier avec des instanceof.