Discussion :

[Pirokkk]

Bonsoir à tous,

Je suis confronté au problème suivant :

J'ai un programme qui est composé d'un menu (une classe étendue de JPanel à gauche), et d'un affichage principal (une classe étendue de JPanel à droite).
Une classe "Gestionnaire" principale va gérer le tout, en créant des instances de ces classes.

Lors de clics sur boutons du menu, on va décider d'afficher telle ou telle classe étendue de JPanel dans la partie de droite.

Imaginons qu'on ai un clic sur menu qui affiche une classe JPanel d'identification de l'administrateur. Il entre son login et son mot de passe. Au clic du bouton "Identifier", une action se produit (interne à la classe JPanel d'identification). L'action teste alors si l'utilisateur est reconnue ou pas. En cas de succès, le menu (classe JPanel de gauche) et l'affichage principal (classe JPanel de droite) doivent être changés dans le Gestionnaire principal.


Mais comment savoir que l'action sur "Identifier" à générer un succès dans mon Gestionnaire principal, au moment du clic ??
Bien entendu, il est important qu'il ne connaissent pas l'action, c'est à dire que l'action soit interne à la classe JPanel d'identification de l'administrateur, qu'elle ne soit créer qu'à l'appel de cette classe par le Gestionnaire.


Je pensais à utiliser Observer ou Observable, mais mes classes sont déjà étendues de JPanel, ce qui fou un bordel monstre si je dois étendre à Observer.
J'ai pensé aux threads également, mais vu le nombre de fenêtres, d'actions sur boutons, etc., ça ne sera pas possible...


C'est une question classique pour un programme qui à un menu et des affiches différentes en fonction des boutons du menu et des actions intérieures aux affichages !! Qu'en pensez-vous ??


Merci.

Pirokkk

[herve91]

Ton gestionnaire principal peut implémenter une interface Gestionnaire spécifiant les responsabilités dont il a la charge. Tu passes l'instance du Gestionnaire aux différents constituants de ton interface.
Par exemple :

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
interface Gestionnaire {
   void setUtilisateur(Utilisateur utilisateur);
 
   // autres méthodes du gestionnaire
}
 
Gestionnaire gestionnaire = new GestionnaireImpl();
AppMenu menu = new AppMenu(gestionnaire, ...);
PanelPrincipal panel = new PanelPrincipal(gestionnaire, ...);
 
public class AppMenu {
  private Gestionnaire gestionnaire;
 
  public AppMenu(Gestionnaire gestionnaire, ...) {
     this.gestionnaire = gestionnaire;
     ...
  }
 
  // méthode appelée lors de l'appui sur le bouton "Identifier"
  private void identificationPerformed(ActionEvent ev) {
    Utilisateur utilisateur = null;
 
    // test login, passwd
    // création de l'objet Utilisateur
    ...
 
    if (utilisateur != null) {
       gestionnaire.setUtilisateur(utilisateur);
    }
  }
}

[Pirokkk]

Merci herve91 c'est pas mal ça !

Mais j'aimerais pousser la chose encore plus loin, c'est à dire pouvoir me passer un jour du Gestionnaire, ou plutôt le remplacer, afin d'adapter chacune de mes fenêtres à d'autres projets. Ce qui veut dire que je ne veux pas que mes classes d'affichages ou de menu connaissent le Gestionnaire.

En gros, je veux que mon Gestionnaire observe mes classes JPanel, mais que celles-ci ne le connaissent pas. Elles doivent justes faire des actions, et au moment de ses actions, prévenir l'"inconnu" (qui est ici le Gestionnaire) qu'il y a eu un changement !! Mes classes d'affichages savent donc juste qu'il y a quelqu'un à prevenir, mais ne savent pas qui. Ce qui fait qu'au final, le code ne changera pas pour elle, mais seulement pour un Gestionnaire ou un autre, qui dira : "je veux observer les changements d'un tel ou de deux tel" !

[herve91]

Oui c'est bien la seconde possibilité, je me demandais juste s'il était utile d'aller aussi loin dans l'utilisation du pattern Obervateur, il est raisonnable de penser qu'il y aura un et un seul observateur pour un ensemble donné de classes d'affichage. Par exemple, pour le panel de login, le gestionnaire de connexion, pour un panel de listage de fichier, le gestionnaire de fichier, etc.
A la limite tu peux définir autant d'interfaces Gestionnaire pour séparer les fonctionnalités :

Code :

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

1
2
3
4
5
6
7
8
9
interface GestionnaireUtilisateur {
   void setUtilisateur(Utilisateur utilisateur);
   ...
}
 
interface GestionnaireFichier {
   void ouvrirFichier(String nom);
   ...
}

et maintenir un GestionnaireFactory en charge de délivrer l'implémentation d'un gestionnaire, en fonction de sa classe par exemple.

Sinon, pour en revenir à la seconde partie de ton message, il est nécessaire de prévoir un système de notification d'événements. Regarde à cette page pour la création de listeners.

[Pirokkk]

Ton lien vers le tuto est impec !!

J'ai trouvé un truc pendant ce temps, qui y ressemble :

Que penses-tu d'un PropertyChangeListener pour le Gestionnaire, et des firePropertyChange pour les classes "écoutées" (mes classes JPanel d'affichages qui génèrent des actions) ??

C'est exactement ce que je cherche, et c'est déjà implémenté. Il me semble que le lien auxquels tu me renvois propose quelque chose de similaire à implémenter par soi-même non ?

[herve91]

L'intérêt du PropertyChangeListener c'est qu'il est déjà cablé dans JComponent, tu n'as pas à écrire toi-même ton propre système de notification d'événements.
C'est un système plus générique (donc moins typé) que ce qui est proposé dans la FAQ, la contre-partie est que c'est sans doute un peu moins "lisible" (enfin ça dépend des goûts !) :

Code :

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

firePropertyChange("utilisateur", null, utilisateur);

contre

Code :

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

fireIdentificationPerformed(new IdentificationEvent(this, utilisateur));