Meilleure approche pour séparer Model, View et Controller

Question

Je pense à la meilleure approche pour séparer Model View et Controller-for Java et Eclipse, si cela fait une différence.

Je avais l'intérieur de son propre package séparé MVC de chaque type, mais je suis commence à penser que ce n'est pas la meilleure approche:

• com.company.client (controleur)
• com. company.client.model

• com.company.client.view

• com.company.another (controleur)

• com.compa ny.another.model

• com.company.another.view

• com.company.yetAnother (controleur)

• com.company.yetAnother.model
• com.company.yetAnother.view

(prendre beaucoup de paquets différents, chacun avec son propre point de vue et le modèle)

Je pensais à l'utilisation:

• com.company.client
• com.company.another

• com.company.yetAnother

• com.company.model.client

• com.company.model. un autre

• com.company.model.yetUn autre

• com.company.view.client

• com.company.view.another
• com.company.view.yetAnother

J'ai même pensé à mettre le contrôleur, le modèle, et vue dans différents projets . Peut-être que ce serait encore plus modulaire, et je serais plus sûr que la vue n'utilise pas le contrôleur, par exemple (comme le projet de contrôleur inclurait la vue, mais pas l'inverse).

Alors, quelle est la meilleure approche pour séparer M, V et C?

(considérer le Web et des applications de bureau, pas seulement web)

Answer 1

La Quête Graal! Vous avez matrice bidimensionnelle avec des couches verticales (MVC) et horizontales (règles métier) ...

• Je n'ai pas trouvé une réponse stricte
• Votre première approche semble bon parce modulaire orienté (peut-être involontaire)
• Pour une petite application de votre seconde mais peut-être acceptable

Pour moi, la réponse est un mot: dépendances
Continuez à chercher dans "package design/strategy"; "Granularité"

Quelques lectures

• http://techdistrict.kirkk.com/2009/08/05/modularity-patterns/
• http://techdistrict.kirkk.com/2010/04/22/granularity-architectures-nemesis/

Je vous recommande fortement celui-ci:

• http://www.jgoodies.com/articles/patterns-and-binding-old.pdf

GOOD LUCK!

Answer 2

Êtes-vous seulement concerné par « séparation » du modèle, vue et le contrôleur dans la mesure où la dénomination et les paquets aller? Cela semble être tout ce que vous demandez.

je tends à mettre mes paquets en tant que tel:

• com.company.app.domain - classes de modèle de domaine pour l'application, simplement JavaBeans (accesseurs seulement, très peu si toute logique). Ceci est utilisé comme "le modèle" dans toute l'application et utilisé par chaque couche de mon application.
• com.company.app.service - Classes de niveau de service de l'application, contenant la logique métier.
• com.company.app.web.controllers - Classes de contrôleur pour ma webapp. D'autres classes spécifiques au Web sont placées dans divers autres sous-ensembles de web.
• com.company.app.dao - OAC interfaces pour accéder aux classes de modèle de domaine - par exemple pour récupérer un utilisateur à partir de la base de données, etc.

Dans chacun de ceux-ci, les paquets sont parfois ventilés par zone de l'application ou en petits groupes basé sur la fonctionnalité, tout ce qui semble approprié.

Answer 3

Je pense qu'il est également important de considérer comment vous souhaitez utiliser le fait que vous avez éclaté des modules séparés dans votre base de code. C'EST À DIRE. Quel type d'utilitaire autre que la qualité de code de base envisagez-vous d'exploiter en fonction de votre schéma d'emballage?

La plupart des applications sur lesquelles je travaille respectent la structure d'empaquetage suivante: * .domain, * .service.subservice, * .dao, * .web.controllers. Cela fonctionne bien pour le suivi des dépendances cycliques dans la base de code et/ou les dépendances qui s'écoulent dans le mauvais sens (contrôleur frappant le dao sans l'indirection d'un service). Il fournit également une structure d'emballage très simple qui est utile et non contraignante. Toutefois, cela se décompose lorsque l'on examine les évaluations automatisées de l'impact des dépendances. J'utilise actuellement DependencyFinder avec un peu de code personnalisé pour comparer deux fichiers jar avant QA. DependencyFinder va tirer toutes les méthodes modifiées et leurs dépendances de premier niveau associées. Le code personnalisé doit être lancé pour mapper les méthodes/classes modifiées aux fonctions métier et cracher un fichier grammaire graphviz pour rendre un graphe de dépendances et de dépendances basé sur la fonction métier pour le contrôle qualité. Nous essayons actuellement d'utiliser les résultats de l'outil pour la planification de tests de régression intelligente, en particulier pour les défauts de production qui passent à la production sans un test de régression complet de plusieurs semaines.

La structure de répertoire que vous proposez rendra le second cas beaucoup plus facile. Cependant, j'ai également constaté que la plupart de mon équipe de développement ne s'occupe pas du tout des dépendances, donc l'utilité du vérificateur d'auto-dépendance peut varier :)

Answer 4

Voici un exemple utilisant une architecture en couches avec trois couches (demande , domaine, ui):

dans le modèle-vue-contrôleur (MVC) le modèle serait dans une couche inférieure, tel que com.company.myapp.domain. Toutes les autres couches peuvent accéder au modèle. Ensuite, la vue et le contrôleur seraient dans com.company.myapp.ui. Cela signifie que la classe Controller est toujours dans la même couche que View. Ne confondez pas le contrôleur MVC avec d'autres classes de contrôleur qui fournissent une logique d'application et résident dans la couche d'application. Par exemple un SalesController dans com.company.myapp.application, qui fournit des opérations système pour gérer les ventes.

Vous pouvez maintenant imaginer que le SalesController modifie certaines données de votre modèle (met à jour une Vente) et le modèle informe ensuite le Contrôleur MVC qui met à jour la Vue.

Remarque: Tous les modèles se trouvent dans le calque domain. Toutes les vues et tous les contrôleurs MVC se trouvent dans le calque ui. Les contrôleurs de logique métier sont dans la couche application. Vous pouvez bien sûr subdiviser ces trois couches si vous avez plusieurs classes avec des préoccupations différentes.

J'espère que cela aide.

Answer 5

En supposant que vous avez à traiter avec un projet non trivial, je pense que votre problème a deux aspects à considérer conjointement pour la mise en place de qualité architecture et code:

• nommant
• modularisation

pour nommer J'essaie d'avoir la plus grande cohésion dans chaque espace de noms et de suivre les Common Closure Principle et Common Reuse Principle.

Pour la modularisation, j'essaie d'utiliser un module pour chaque problème principal architectural du projet et nomme commodément ses paquets. MVC est un modèle de module de présentation qui vise à séparer le flux de commande du module de présentation, les modèles de données sur lesquels il repose et la logique liée à la vue.

Dans mon IDE Java (par exemple Eclipse) j'utilise un projet par module, donc le module web sera un projet et le module desktop sera un autre projet.Dans un projet Web, par exemple, j'ai un préfixe commun, tels que:

com.mycompany.app.web 

et il je un .controllers (ou actions) descendant, un descendant et fichiers .models ainsi de suite. Si j'utilise une base de données, je m'appuie sur un module DAO, un autre projet.

com.mycompany.app.web.models 
com.mycompany.app.web.actions 

Le module DAO n'a pas de présentation, donc il n'a pas d'approche MVC. Il persiste les objets de domaine, donc peut-être qu'il repose sur un module de domaine. Dans ces modules j'utilise préfixes comme ce qui suit:

com.mycompany.app.domain 
com.mycompany.app.dao 

J'essaie de ne pas confondre Modèle dans MVC avec l'application Domaine; ils ne sont pas la même chose.

Une autre erreur courante est de confondre Contrôleur avec Business Logic; logique métier doit être placé dans un module et partagé entre les modules de présentation, le contrôleur dans un espace de noms du module de présentation (web ou de bureau).

Un modèle (dans MVC, un modèle de vue) est un objet utilisé par une vue de montrer quelque chose à l'utilisateur: il peut contient un, une combinaison ou une collection de domaine objets. Le Le contrôleur utilise les modules disponibles (DAO, etc.) pour créer une vue Le modèle puis le passe à un Afficher.

Voir alors peut compter que sur son modèle (un seul, expressément créé par le contrôleur) et demander des modèles uniquement aux contrôleurs (la seule en mesure de construire des modèles). Afficher, en particulier pour les présentations Web, est souvent codé dans un mélange de langues, de sorte qu'une partie du code peut rester en dehors des conventions de dénomination.

Answer 6

Pensez à comment vous développez. Développez-vous par contrôleur/modèle/vue? Ou développez-vous par module. Les chances sont que vous développez sur un module et non sur une couche MVC. Donc, je pense que votre réponse est là. Essayez de garder vos noms de paquets aussi proches des modules que votre système représente (ce que vous faites déjà je suppose). Pas besoin de vous montrer des choix architecturaux dans vos noms de paquets.

L'affichage des noms de modules et des problèmes de domaine dans votre package crée une base de code maintenable et cohérente.