Comment dois-je structurer une application Java, où dois-je placer mes classes?

J'ai vraiment comme Maven est Répertoire Standard De Mise En Page.

L'une des principales idées qui pour moi est d'avoir deux racines, l'une pour la production de code et un code de test comme suit:

MyProject/src/main/java/com/acme/Widget.java
MyProject/src/test/java/com/acme/WidgetTest.java

(ici, à la fois src/main/java et src/test/java sont source de racines).

Avantages:

• Les tests ont package (ou "par défaut") au niveau de l'accès à vos cours en cours de test.
• Vous pouvez facilement emballer seulement vos sources de production dans un BOCAL en laissant tomber src/test/java en tant que source de la racine.

Une règle de base à propos de la classe de placement et des paquets:

Généralement parlant, bien structuré projets seront libres de les dépendances circulaires. Apprendre quand ils sont mauvais (et quand ils sont pas), et d'envisager un outil comme JDepend ou SonarJ qui vous aidera à éliminer.

Où je travaille, nous sommes à l'aide de Maven 2 et nous avons une assez bonne archétype de nos projets. Le but était d'obtenir une bonne séparation des préoccupations, ainsi nous avons défini une structure de projet à l'aide de plusieurs modules (un pour chaque application "couche"):
- commune: commune code utilisé par les autres couches (par exemple, i18n)
- entités: les entités de domaine
- référentiels: ce module contient les daos les interfaces et implémentations
- services-intf: les interfaces pour les services d'e.g, UserService, ...)
- services-impl: les implémentations de services (à l'e.g, UserServiceImpl)
- web: tout ce qui concerne le contenu web (par exemple, css, jsp, jsf, pages, ...)
- ws: services web

Chaque module possède ses propres dépendances (par exemple, ils pourraient avoir jpa) et du projet (ainsi qu'ils appartiennent à la commune de module). Les dépendances entre les différents modules de projets clairement la part des choses (par exemple, le calque web dépend de la couche de service, mais ne savez pas au sujet de dépôt de la couche).

Chaque module dispose de son propre module de base, par exemple, si le dossier de demande est "com.foo.bar", alors nous avons:

com.foo.bar.common
com.foo.bar.entities
com.foo.bar.repositories
com.foo.bar.services
com.foo.bar.services.impl
...

Chaque module respecte le projet maven standard structure:

   src\
   ..main\java
     ...\resources
   ..test\java
     ...\resources

De tests unitaires pour une couche donnée facilement trouver leur place sous \src\test... Tout ce qui est spécifique au domaine a sa place dans les entités du module. Maintenant, quelque chose comme un FileStorageStrategy devrait aller dans les référentiels de module, puisque nous n'avons pas besoin de savoir exactement ce que la mise en œuvre est. Dans la couche de services, nous ne connaissons que le référentiel de l'interface, nous ne nous soucions pas de ce que la mise en œuvre spécifique est (séparation des préoccupations).

Il y a plusieurs avantages à cette approche:

• séparation claire des préoccupations
• chaque module est packageable comme un pot (ou une guerre dans le cas du module web) et permet ainsi de faciliter la réutilisation de code (par exemple, nous pouvons installer le module dans le référentiel et le réutiliser dans un autre projet)
• le maximum d'indépendance de chaque partie du projet

Je sais que ce n'est pas de répondre à toutes vos questions, mais je pense que cela pourrait vous mettre sur la bonne voie et pourrait s'avérer utile à d'autres.

Utiliser les paquets de groupe fonctionnalités liées ensemble.

Généralement le haut de votre arbre est votre nom de domaine inversé (com.domain.subdomain) pour garantir l'unicité, puis, généralement, il y aura un package de votre application. Ensuite subdiviser que, par ailleurs, de sorte que votre FileStorageStrategy peut aller, dire, com.domain.subdomain.myapp.storage, et alors il pourrait y avoir des implémentations spécifiques/sous-classes/que ce soit dans com.domain.subdomain.myapp.storage.file et com.domain.subdomain.myapp.storage.database. Ces noms peuvent être assez long, mais import les tient tous en haut de fichiers et IDEs peuvent aider à gérer cela.

Exceptions vont généralement dans le même package que les classes que de les jeter, donc si vous avait, disons, FileStorageException il serait aller dans le même package que FileStorageStrategy. De même, une interface qui définit les constantes serait dans le même package.

Il n'est pas vraiment une norme en tant que telle, il suffit d'utiliser le sens commun, et si tout devient trop sale, refactoriser!

Réponse courte: dessiner votre architecture du système en termes de modules, tiré côté-à-côte, avec chaque module découpée verticalement en couches (par exemple, la vue, le modèle, la persistance). Puis utiliser une structure comme com.mycompany.myapp.somemodule.somelayer, par exemple com.mycompany.myapp.client.vue ou com.mycompany.myapp.serveur.modèle.

En utilisant le haut niveau de packages pour l'application modules, dans la old-fashioned de l'informatique sens de la programmation modulaire, devrait être évident. Cependant, sur la plupart des projets, j'ai travaillé sur on finit par oublier de le faire, et se retrouver avec un désordre de paquets, sans que la structure de premier niveau. Cet anti-modèle montre généralement lui-même comme un paquet pour quelque chose comme "auditeurs" ou "actions" que les groupes des classes non connexes simplement parce qu'elles implémentent la même interface.

À l'intérieur d'un module, ou dans une petite application, de l'utilisation des packages pour l'application de couches. Probablement forfaits comprennent des choses comme les suivantes, en fonction de l'architecture:

• com.mycompany.myapp.vue
• com.mycompany.myapp.modèle
• com.mycompany.myapp.services
• com.mycompany.myapp.règles
• com.mycompany.myapp.la persistance (ou " dao " pour la couche d'accès aux données)
• com.mycompany.myapp.util (méfiez-vous de cet être utilisé comme si c'était 'divers')

À l'intérieur de chacune de ces couches, il est naturel pour des cours de groupe par type si il y en a beaucoup. D'un commun anti-modèle ici est d'introduire inutilement trop de paquets et les niveaux de sous-paquet, de sorte qu'il y a seulement quelques classes dans chaque paquet.

Une chose que j'ai fait dans le passé - si je suis à l'extension d'une classe, je vais essayer et suivre leurs conventions. Par exemple, lorsque l'on travaille avec le Framework Spring, je vais avoir mon MVC Contrôleur de classes dans un package nommé com.mydomain.myapp.web.servlet.mvc
Si je ne suis pas l'extension de quelque chose, j'ai juste aller avec ce qui est le plus simple. com.mydomain.de domaine pour le Domaine des Objets (bien que si vous avez une tonne d'objets de domaine de ce paquet pourrait obtenir un peu lourd).
Pour le domaine spécifique des constantes, j'ai, en fait comme des constantes publiques dans la plupart des classes. Par exemple, si j'ai un "Membre" de la classe et d'avoir un maximum de membre nom de la constante de longueur, je l'ai mis dans le Membre de classe. Certains magasins en faire un distinct des Constantes de la classe, mais je ne vois pas la valeur dans la formation de grumeaux sans rapport avec les nombres et les chaînes de caractères en une seule classe. J'ai vu quelques autres magasins d'essayer de résoudre ce problème par la création de SÉPARER les Constantes de classes, mais qui semble juste comme une perte de temps et le résultat est trop confus. En utilisant cette configuration, un grand projet avec plusieurs développeurs sera la duplication des constantes de tous sur la place.