[MVC][Swing][EJB] - Est ce que je pars dans la bonne direction ?
Hello everybody !
Voilà, je suis en train de réaliser une appli qui mélange des ejb et du swing.
Pour la partie EJB, je n'ai pas trop de soucis, par contre, l'IHM de ces ejb, c'est un peu plus complexe :?
J'ai lu pratiquement tous les tutos concernant MVC appliqué à swing, et j'avouerai que chacun fais un peu comme il veut. Certains mélange, à mon sens, le controler et la view...
Donc j'ai essayé de récupérer ce que j'ai vu ici et là, et voilà ce que j'ai pondu:
Mon entity:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class Moniteur extends Individu implements Serializable {
[....]
}
public class Individu implements Serializable {
private Integer idIndividu;
private String nom;
private String prenom;
private Date dateNaissance;
private Adresse adresse;
[....]
} |
Mon model:
Code:
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
| public class MoniteurModel {
private AdresseModel adresseModel;
private EventListenerList listeners;
private Moniteur moniteur;
private String nom, prenom;
public MoniteurModel(){
listeners = new EventListenerList();
moniteur = new Moniteur();
adresseModel = new AdresseModel();
}
public void addMoniteurListener(MoniteurListener moniteurListener){
listeners.add(MoniteurListener.class, moniteurListener);
}
public void removeMoniteurListener(MoniteurListener moniteurListener){
listeners.remove(MoniteurListener.class, moniteurListener);
}
private MoniteurListener[] getMoniteurListeners(){
return listeners.getListeners(MoniteurListener.class);
}
public void notifyMoniteurListener(String propriete, Object oldValue, Object newValue){
for (MoniteurListener m : getMoniteurListeners()) {
m.moniteurProprieteChanged(propriete, oldValue, newValue);
}
}
public Moniteur getMoniteur(){
return moniteur;
}
public void setMoniteur(Moniteur m){
moniteur = m;
setNom(moniteur.getNom());
setPrenom(moniteur.getPrenom());
getAdresseModel().setAdresse(m.getAdresse());
}
public String getNom(){
return moniteur.getNom();
}
public void setNom(String nom){
Object oldValue = this.nom;
Object newValue = nom;
moniteur.setNom(nom);
notifyMoniteurListener("nom", oldValue, newValue);
}
public void setPrenom(String prenom){
Object oldValue = this.prenom;
Object newValue = prenom;
moniteur.setPrenom(prenom);
notifyMoniteurListener("prenom", oldValue, newValue);
}
public String getPrenom(){
return moniteur.getPrenom();
}
public AdresseModel getAdresseModel() {
return adresseModel;
}
public void setAdresseModel(AdresseModel adresseModel) {
this.adresseModel = adresseModel;
}
} |
Une partie de ma view:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| public class JMoniteurPanel extends javax.swing.JPanel implements MoniteurListener{
/** Creates new form JMoniteurPanel */
public JMoniteurPanel() {
initComponents();
}
public void moniteurProprieteChanged(String propriete, Object oldValue, Object newValue) {
if(propriete.equals("prenom"))
jtPrenom.setText(newValue.toString());
else if(propriete.equals("nom"))
jtNom.setText(newValue.toString());
}
[....]
// Variables declaration - do not modify
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JTextField jtNom;
private javax.swing.JTextField jtPrenom;
// End of variables declaration
} |
L'autre partie de la vue:
Code:
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 JFrameMoniteur extends javax.swing.JFrame {
/** Creates new form JFrameMoniteur */
public JFrameMoniteur() {
initComponents();
}
public JButton getCreateButton(){
return jbCreate;
}
public JMoniteurPanel getPanelMoniteur(){
return jMoniteurPanel1;
}
public JAdressePanel getPanelAdresse(){
return jAdressePanel1;
}
[.....]
// Variables declaration - do not modify
private view.JAdressePanel jAdressePanel1;
private view.JMoniteurPanel jMoniteurPanel1;
private javax.swing.JButton jbCreate;
// End of variables declaration
} |
Mon controler:
Code:
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
| public class MoniteurControler implements ActionListener{
public MoniteurModel model;
public JFrameMoniteur view;
public MoniteurControler(Moniteur m){
model = new MoniteurModel();
view = new JFrameMoniteur();
view.getCreateButton().addActionListener(this);
model.addMoniteurListener(view.getPanelMoniteur());
model.getAdresseModel().addAdresseListener(view.getPanelAdresse());
model.setMoniteur(m);
}
public void displayView(){
view.setVisible(true);
}
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand().equals("Create")){
System.out.println("Création..."+model.getAdresseModel().getRue());
}
else{
System.out.println("Action inconnu :/");
}
}
} |
Et enfin, le lancement de l'appli:
Code:
1
2
3
4
5
6
7
8
9
10
| public static void main(String[] args) {
Moniteur m = new Moniteur();
m.setPrenom("Paul");
m.setNom("DUPONT");
Adresse a = new Adresse();
a.setNumeroRue("6");a.setRue("Rue de la source");
m.setAdresse(a);
MoniteurControler mc = new MoniteurControler(m);
mc.displayView();
} |
Est ce que donc ma façon de procéder est la bonne ? Je vous demande, car ce n'est pas un tuto qui va me le dire....
Je gère les actions de la vue, dans le controler.
Le model prévient la vue lorsqu'il y a modification de celui ci...
Le soucis que je n'arrive pas à résoudre, c'est le lancement de la fenêtre (view = new JFrameMoniteur(); ) que je ne fais pas en utilisant SwingUtilities... est ce grave docteur ?
Vous avez une meilleur solution ?
Bien cordialement !
