Discussion :

[etiennegaloup]

Bonjour,

je cherche à déveloper une application mvc.
J'ai donc développer une classe model:

Code :

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

1
2
3
4
 
public class Model {
[..]
}

une classe Gui pour la vue. Dans cette classe il y a plusieurs classes internes pour différents éléments de mon interface graphique. (par exemple des formulaires de saisies)

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
 
public class Gui {
    private Model model;
 
    public Gui(Model model) {
        this.model=model;
        [..]
    }
[..]
    class NewClient {
         private JButton validNewClient;
         NewClient(){
             validNewClient=new JButton("Valider");
             validNewClient.setActionCommand("ValidNewClient");
             validNewClient.addActionListener(....); //J'aimerais l'ajouter à une instance de la classe Controller
         }
     }
[..]
    class NewFournisseur{
         private JButton validNewFournisseur;
         NewFournisseur(){
             validNewFournisseur=new JButton("Valider");
             validNewFournisseur.setActionCommand("ValidNewFournisseur");
             validNewFournisseur.addActionListener(....); //J'aimerais l'ajouter à une instance de la classe Controller
         }
    }
[..]

et une class Controller:

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
 
public class Controller implements ActionListener{
    private Model model;
    private Gui vue;
 
    public Controller(Model model,Gui vue) {
         this.model=model;
         this.vue=vue;
         [..]
    }
 
    public actionPerformed(ActionEvent e) {
         //Traitement
    }
}

et une classe Main

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public class Main {
    Model model
    Gui vue;
    Controller controller;
 
    public Main(){
        model=new Model();
        vue=new Gui(model);
        controller=new Controller(model,vue);
    }
}

En faisant comme ceci, je pense respecter le design pattern mvc. Mais mon souci réside dans l'ajout des boutons de validations des formulaires dans l'écouteur d'action avec la méthode addActionListener.
En effet, je dois les ajouter dans une instance de Controller.
Le hic est que la vue ne possède pas de variables de classe Controller. Je pourrais l'ajouter mais dans ce cas, je ne respecte plus le design pattern mvc.

Comment puis-je faire d'après vous ?
Merci d'avance.
++

[bouye]

Hum en esperant ne pas trop faire de @#$ car je suis tres mal reveille ce matin...

Je pourrais l'ajouter mais dans ce cas, je ne respecte plus le design pattern mvc.

1) Pas forcement si les fonctionalites des divers entites sont bien separees et communiquent entre elles en suivant le pricipe du mvc. Apres a toi de voir si quand tu reutiliseras ton API/composant tu veux vraiment pourvoir changer de controller, de vue ou de modele n'importe ou, n'importe quand. En theorie c'est bien, mais en pratique en auras-tu l'usage ? Donc le travail supplementaire en vaut'il le cout.

D'un autre cote peut-etre voudras-tu aussi fournir un composant pret a l'emploi avec un comportement par defaut et donc un controlleur directement plugge dans le composant (mais que modifiable/remplacable ulterieurement).

2) Il t'est possible de definir une sorte de classe handle/point d'entree qui contient les references sur les divers sous-elements du modele MVC.

En essayant d'expliquer plus simplement on prend l'exemple d'un JButton. A priori on dirait que ButtonModel est le modele, et JButton est la vue/controlleur. C'est un peu moins simple car en fait JButton delegue sa vue a une BasicButtonUI. On pourrait dire
- donc JButton = controlleur + handle sur le composant.
- ButtonModel = modele.
- BasicButtonUI = vue (mais deleguee en fait c'est plus un renderer).

Avec un peu de boulot on pourrait completement detacher la partie controlleur du bouton dans une autre classe (ex ButtonController)... Note : ce n'est pas forcement le plus pratique.
Comme ca on pourrait completement modifier le comportement du bouton pour qu'il ne s'enfonce non pas par simple clic gauche, mais (soyons fous) par un drag dessinant un signe cabalistique avec le bouton droit en moins de 10s (trop joue a Castlevania sur DS moi).

Et voila ! L'utilisateur ne manipulerai que JButton et cette classe centralisee servirai a mettre en relation entre elles les classe modele vue et controlleur.

EDIT - vraiment pas reveille... c'est effectivement la methode que tu as choisit...

[bouye]

Tu devrais voir les topics suivants et les liens donnes par Gfx :
http://www.developpez.net/forums/viewtopic.php?t=384773
http://www.developpez.net/forums/viewtopic.php?t=424909

D'ailleurs toute personne ayant essaye d'implementer un MVC "pur" sait a quel point c'est difficile a mettre en pratique. Dans beaucoup de cas ca complique enormement pour un gain finalement pas toujours si evident

Quand le composant est complexe et lui-meme compose de sous-ensembles avec des comportements bien distincts (ton interface et tes boutons) ca devient effectivement assez complique de faire un controlleur unique pour l'ensemble de maniere "correcte".

dodo

[etiennegaloup]

Hello,

Apres a toi de voir si quand tu reutiliseras ton API/composant tu veux vraiment pourvoir changer de controller, de vue ou de modele n'importe ou, n'importe quand.

Si je mets un objet controller dans ma vue, qu'est-ce qui m'empêche de changer de controller, de vue ou de model n'importe quand ? Je ne comprends pas bien en fait.

Comment puis-je faire pour résoudre mon problème ?

Supposons que je ne mette pas d'objet controller dans ma vue. Pour ajouter mes boutons à ActionListener, je dois utiliser une fonction du type setListener(EventListener l).

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
 
public class Gui {
    private Model model;
    ActionListener listener;
 
    public Gui(Model model) {
        this.model=model;
        [..]
    }
 
    public void setActionListener(ActionListener l){
        listener=l;
    }
[..]
    class NewClient {
         private JButton validNewClient;
         NewClient(){
             validNewClient=new JButton("Valider");
             validNewClient.setActionCommand("ValidNewClient");
             validNewClient.addActionListener(listener);
         }
     }
[..]
    class NewFournisseur{
         private JButton validNewFournisseur;
         NewFournisseur(){
             validNewFournisseur=new JButton("Valider");
             validNewFournisseur.setActionCommand("ValidNewFournisseur");
             validNewFournisseur.addActionListener(listener);
         }
    }
[..]

Et les boutons validNewClient et validNewFournisseur ajoutent l'ActionListener listener.
Mais ces boutons sont initialisés à la création d'une nouvelle instance de Gui, c'est à dire avant que la méthode setActionListener ne soit appelé.
Donc je pense que ça ne va pas.

Ensuite, si je crée un objet controller dans la classe vue, je ne peux pas l'initialiser dans une méthode constructeur.
Sinon j'aurais quelque chose qui ressemble à ce qui suit:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public class Main {
    Model model
    Gui vue;
    Controller controller;
 
    public Main(){
        model=new Model();
        vue=new Gui(model,controller);
        controller=new Controller(model,vue);
    }
}

Et donc ça ne va pas non plus.

Comment puis-je faire d'après vous ?

Merci d'avance.
++

[mtaveau]

ça n'est peut-être pas très important, mais MVC n'est pas un design pattern, mais une architecture ou framework.

Pourquoi as-tu besoin d'ajouter les boutons de formulaires de saisie dans une classe controller ? Lors d'une action de l'utilisateur c'est les nouvelles données des variables qui le controller doit pouvoir traiter. Puis il informe la classe model qui met, elle, à jour toutes les vues.

[etiennegaloup]

ça n'est peut-être pas très important, mais MVC n'est pas un design pattern, mais une architecture ou framework

T sûr ? Car, j'ai toujours lu que MVC était un design pattern.

J'ajoute les boutons de formulaire dans le controller puis ce dernier appelle la méthode correspondante du modèle.
Le modèle est modifié et le notifie à la vue qui est mise à jour.
N'est-ce pas comme cela qu'il faut faire ?
Comment feriez-vous ?

++

[bouye]

Non-obstant toutes les betises pré-réveillon que j'ai pu écrire dans mon 1er post vendredi dernier pour cause de manque de sommeil : ta vue* est/semble être composée de plusieurs sous-MVC différents (à priori des boutons, et peut-être une table et/ou des champs d'édition, voir des combos, des listes ou des spinners, ...) ca devient super-dur au niveau global de suivre le MVC correctement et de bien tout séparer en entités distinctes de manière à faire un controlleur global.

*Déjà ce n'est plus une vue "pure".

Encore une fois : es-tu sur que tu auras besoin de changer le controller plus tard ? Cela vaut'il la peine de se casser la tête pour autant ?

En regardant les sources du JDK, essaie peut-être de voir comment fonctionnent les différentes UI délégates du JFileChooser qui est un composant complexe. C'est en effet ce qui se rapproche le plus de ton problème : suivant les Look n Feel, le JFileChooser est représenté de manière très différente et ne fonctionne pas du tout de la même manière. Pourtant il est fabriqué à partir de plusieurs composants Swing simples.

Au fait : Joyeux Noël, et Bonnes Fêtes !

[etiennegaloup]

En fait, je débute sous Java, et l'application que je cherche à développer est ma plus grosse application. Je me suis tourné vers MVC car je trouvais ça, au niveau conception, assez interessant. Je trouvais bien de séparer la partie données et de la partie interface graphique.
Comment développez-vous vos applications ?

ta vue* est/semble être composée de plusieurs sous-MVC différents (à priori des boutons, et peut-être une table et/ou des champs d'édition, voir des combos, des listes ou des spinners, ...)

Oui mais dans ce cas ça doit être équivalent pour toutes les vues développées en Java ? Non ? Parce qu'après tout, pour développer une vue, il faut utiliser des boutons, ou des tables ou des champs d'édition...

*Déjà ce n'est plus une vue "pure".

Quelle est la technique pour faire une vue pure ?

Au fait : Joyeux Noël, et Bonnes Fêtes

Joyeux Noël et bonnes fêtes à toi aussi.

++

[etiennegaloup]

Une idée ?

[etiennegaloup]

Bonjour à tous,

Encore une fois : es-tu sur que tu auras besoin de changer le controller plus tard ? Cela vaut'il la peine de se casser la tête pour autant ?

Non, je n'aurais pas forcément besoin de changer le controller plus tard. Dans ce cas, tu me conseilles de gérer les évènements des boutons, directement dans la classe de l'interface graphique ?

Comme je le disais précédemment, je débute, et j'éprouve quelques difficultés à réaliser une application plus conséquente. J'étais parti sur mvc car je trouvais cela pratique. Mais effectivement, cela n'a pas l'air si évident que ça.
Pour développer une application graphique, comment vous y prenez-vous ?
J'aurais surtout besoin de conseils, pour architecturer mon application. Est-ce qu'il existe un modèle de développement d'applications graphiques ? Est-ce que vous suivez toujours ce modèle lorsque vous développez ?

Merci pour vos conseils.
++