Organisation application Swing

Bonjour,

Je suis actuellement en train de développer une application pour gérer des contacts en Swing. Cette application s'apparent à un CRUD (Create Read Update Delete). Elle possède une frame principal qui contient un JDesktopPane. Les autres écrans dérivent de JInternalFrame. Je développe sous Eclipse avec le Gui Builder "WindowBuilder Pro".

Je suis confronté à un problème au niveau du découpage. J'aimerai séparer la partie métier de la partie présentation, mais j'ai un fort couplage de la partie métier dans la partie présentation. J'ai lu beaucoup d'articles sur ce sujet (MVC, design pattern) sans avoir pu trouver une solution.

Connaissez-vous des astuces, des conseils à m'apporter pour avoir une application bien structuré plutôt qu'un "plat de spaghettis..."

Merci par avance

Moi je procède de la sorte pour découper mes applications. Cependant c'est une méthologie personnelle, à voir si cela te conviendra.

Je créé un package métier qui va mettre à jour les données persistantes.

fr.monApp.model.versionXXX.ContactManager
-- load
-- create
-- update
-- delete

Je créé un package service qui va appeler le package métier. Ce service peut être un simple controller ou bien du RMI, du REST, enfin ce qu'on veut...

fr.monApp.service.controller.versionXXX.ContactService
-- load
-- create
-- update
-- delete

fr.monApp.service.rest.versionXXX.ContactService
-- load
-- create
-- update
-- delete


Je créé le package qui va contenir mon application, le gui, les écran, cela peut du swing, une appli web, une applet...

fr.monApp.swing.versionXXX.mainFrame
fr.monApp.swing.versionXXX.LoadPopup
fr.monApp.swing.versionXXX.ContactViewFrame

C'est perfectible, je gère facilement les versions, les composants sont rééutilisables, en tout cas je m'en sors assez bien de la sorte, en espérant que cela puisse t'aider.

C'est une bonne approche. Le découpage est bien pensé. Mais comment gères tu les dépendances entre la vue et le contrôleur ? C'est la vue qui possède une instance du contrôleur ou l'inverse ?

Je pense que tu as un fort couplage entre les différents packages de ton application.

Merci

C'est la vue qui décide quel service utiliser et le service appelle le modèle. Le service permet simplement de véhiculer l'information de différentes manières.

En gros

fr.monApp.swing.v10.mainFrame.initialize va initialiser le service fr.monApp.service.controller.v10.ContactService

fr.monApp.swing.v10.mainFrame.load va appeler la méthode load du service fr.monApp.service.controller.v10.ContactService

Et le service se contente juste d'appeler la couche persistante!

A noter que la version n'est pas toujours v10, l'IHM évolue plus souvent que la couche service et la couche persistante.

Par contre je ne vois pas comment peux-tu réduire au maximum les dépendances... Si tu as un code réeutilisable, tu réduis forcément le couplage entre les différents modules de ton application... Enfin si quelqu'un peut confirmer!

Bon courage!

j'ai bossé un peu le sujet :

http://www.developpez.net/forums/d77...s/#post4465035

j'ai fais quelque schéma et une présentation. Cela pourrait peut-être t'inspirer.

Merci pour ta réponse. Je pense que je vais m'inspirer de ton découpage.

Concernant mon problème de couplage, je vais m'inspirer du pattern MVC ou composite.

Je m'inspire aussi des framework J2EE Web (Struts, JSF,...)

J'ai un écran qui affiche une liste de contact et à partir de celui-ci je peux consulter ou modifier un contact. Le problème c'est que l'appel à l'écran consulter ou modifier est présent dans l'écran de la liste des contacts. J'aimerais éviter cette approche.

Merci

Super travail william44290

Je vais lire la documentation de ton framework.

Merci

J'ai fait une demande d'hébergement sur le site. Une publication des sources pourrait intervenir prochainement.

Si tu as des questions n'hésite pas.

Merci. Je serai ravi de pouvoir les consulter

Tu utilises un framework particulier dans ton framework (je pense à spring) ou utilises tu plutot des design pattern (MVC, Observer) ?

j'ai un peu honte mais je n'utilise pas de framework et pour les design patern je me suis documenté mais sans forcément en implémenter de manière canonique.

J'ai essayé de fabriquer un outils fonctionnel avec le moins d'apriori possible.

J'ai viens de tester une approche qui à l'air de fonctionner. C'est pas la meilleur mais elle a l'avantage d'éviter un couplage entre les différents éléments

Je crée une interface qui sera le pivot entre le communiquant et le communiqué

Code:

---

1 2 3 4 5

public interface TraitementListener { public void onSuccess(Object result); public void onFailure(Exception e); }

---

Ensuite je crée une méthode réalisant un traitement (ex requète BDD, ...)

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public void doSmth(TraitementListener l){ try{ //Si le traitement c'est bien déroulé, je renvois quelque chose l.onSuccess(object);//object : boolean, string, list, ... } catch(Exception e){ //Si le traitement a échoué, je renvois le message d'erreur l.onFailure(e); } }

---

Enfin, je met en place la structure dans la partie qui attends un traitement

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

... TraitementListener listener = new TraitementListener() { @Override public void onSuccess(Object result) { Object object = result; //Do smthg }   @Override public void onFailure(Exception e) { //Do smthg } }; ...

---

Voila cette solution résout en partie mon problème de couplage. Je me suis inspiré des traitements asynchrones de GWT.

Bonne soirée
:D