Existe-t-il des meilleures pratiques pour l'organisation de packages (Java)?

Question

Il y A peu, j'ai vu une réponse à votre question ici concerne la fine organisation de paquets java. Par exemple, mon.projet.util, mon.projet.l'usine, mon.projet.service etc.

Je ne peux pas le trouver maintenant, donc je peut tout aussi bien poser la question.

Sont là les meilleures pratiques en ce qui concerne l'organisation des packages en Java et ce qui se passe en eux?

Comment organisez vous vos classes dans votre projet Java?

Par exemple, un projet, je travaille avec quelques personnes a un paquet de haricots. Il a commencé comme un projet comportant de simples haricots, mais a fini (par manque d'expérience et le manque de temps) contiaining tout (ou presque). J'ai nettoyé un peu, en mettant quelques classes de fabrique dans une usine de package (classes avec des méthodes statiques qui créent des haricots), mais nous avons d'autres classes qui n'logique d'affaires et que d'autres n'en traitement simple (pas avec la logique métier), comme la récupération d'un message et un code à partir d'un fichier de propriétés.

Vos pensées et vos commentaires sont appréciés.

Answer 1

J'organise les packages par fonction, et non par modèles ou rôles d'implémentation. Je pense que des paquets comme:

• des haricots
• des usines
• collections

sont faux. Je préfère, par exemple:

• ordres
• le magasin
• rapports

Je peux donc masquer les détails d'implémentation grâce à la visibilité des packages: la fabrique de commandes doit figurer dans le package de commandes afin que les détails relatifs à la création d'une commande soient masqués.

Answer 2

Package organisation ou un paquet de structuration est généralement une discussion houleuse. Ci-dessous sont quelques lignes directrices simples pour package de nommage et de structuration:

• Suivez java package conventions de nommage
• La Structure de vos paquets en fonction de leur rôle fonctionnel ainsi que leur rôle
  • Briser vos paquets en fonction de leur fonctionnalité ou de modules. par exemple, com.company.product.modulea
  • Décomposer davantage pourrait être fondée sur des calques dans votre logiciel. Mais n'exagérez pas si vous avez très peu de classes dans le paquet, alors il est logique d'avoir tout dans le paquet. par exemple, com.company.product.module.web ou com.company.product.module.util etc.
  • Éviter d'aller à la mer avec la structuration, de l'OMI éviter un emballage spécifique pour les exceptions, les usines, etc. sauf si il y a un besoin pressant.
• Si votre projet est de petite taille, garder les choses simples avec quelques paquets. par exemple, com.company.product.model et com.company.product.util, etc.
• Jetez un oeil à certains de l'open source les plus populaires de projets sur des projets Apache. Voir comment ils utilisent de structuration, pour diverses tailles de projets.
• Également envisager de construire et de distribution lors de la dénomination ( vous permettant de diffuser votre api ou SDK dans un package différent, voir la servlet api)

Après quelques expériences et essais, vous devriez être en mesure de venir avec une structuration que vous êtes à l'aise avec. Ne pas se fixer sur une convention, être ouverts aux changements.

Answer 3

Réponse courte: Un paquet par module / fonctionnalité, éventuellement avec des sous-paquets. Mettez ensemble des choses étroitement liées dans le même paquet. Évitez les dépendances circulaires entre les packages.

Réponse longue: je suis d'accord avec la plupart de cet article

Answer 4

Je préfère fonctionnalité avant de couches, mais je suppose que ça dépend de votre projet. Considérez vos forces:

• Les dépendances. Essayez de minimiser les dépendances des paquets, en particulier entre les fonctions. Extrait Api si nécessaire.
• Organisation de l'équipe. Dans certaines organisations, les équipes de fonctionnalités et dans d'autres couches. Cette influence la façon dont le code est organisé, l'utiliser pour formaliser d'Api ou d'encourager la coopération.
• Le déploiement et le versioning. Mettre le tout dans un module de rendre le déploiement et la gestion des versions plus simples, mais la correction de bug plus difficile. Le fractionnement des choses de permettre un meilleur contrôle, d'évolutivité et de disponibilité.
• Réagir au changement. Bien organisé, le code est beaucoup plus simple à changer qu'une grosse boule de boue.
• Taille (des personnes et des lignes de code). Le plus grand le plus formel/normalisés, il doit l'être.
• L'Importance et la qualité. Un peu de code est plus important que les autres. Api devrait être plus stable, alors la mise en œuvre. Par conséquent, il doit être clairement séparés.
• Niveau d'abstraction et de point d'entrée. Il devrait être possible pour un étranger de savoir ce que le code est sur, et par où commencer la lecture à partir de la recherche à l'arbre.

Exemple:

com/company/module
  + feature1/
    - MainClass          // The entry point for exploring
    + api/               // Public interface, used by other features
    + domain/
      - AggregateRoot
      + api/             // Internal API, complements the public, used by web
      + impl/ 
    + persistence/       
    + web/               // presentation layer 
    + services/          // Rest or other remote API 
    + support/            
  + feature2/
  + support/             // Any support or utils used by more than on feaure
    + io
    + config
    + persistence
    + web

C'est juste un exemple. Il est tout à fait formelle. Par exemple, il définit 2 interfaces pour feature1. Normalement, ce n'est pas obligatoire, mais peut être une bonne idée si elle est utilisée différemment par différentes personnes. Vous pouvez laisser l'api interne étendre le public.

Je n'aime pas le "impl" ou de "soutien" des noms, mais ils aident à séparer le moins de choses importantes à partir de la important (de domaine et de l'api). Quand il s'agit de nommage j'aime aussi concrète que possible. Si vous avez un package appelé "utils" avec 20 classes, déplacer StringUtils à l'appui/chaîne, HttpUtil à l'appui/http et ainsi de suite.

Answer 5

Sont là les meilleures pratiques en ce qui concerne l'organisation des packages en Java et ce qui se passe en eux?

Pas vraiment non. Il ya beaucoup d'idées, et beaucoup d'opinions, mais les "meilleures pratiques" à l'usage de votre bon sens!

Cependant, il y a un chef qui n'a probablement une large acceptation. Votre colis structure doit refléter votre application (informel) la structure du module, et vous devriez viser à minimiser (ou, idéalement, d'éviter complètement) toute cyclique dépendances entre les modules.

(Cyclique des dépendances entre les classes dans un package / module sont juste très bien, mais l'inter-paquet cycles ont tendance à faire du mal à comprendre votre application architecture, et peut être un obstacle à la réutilisation de code. En particulier, si vous utilisez Maven, vous trouverez que cyclique inter-paquets / inter-dépendances des modules à dire que toute la interconnectés désordre doit être un artefact Maven.)

Je dois aussi ajouter qu'il est un largement accepté les meilleures pratiques pour les noms de paquets. Et c'est que votre colis noms doivent commencer avec votre organisation de votre nom de domaine dans l'ordre inverse. Si vous suivez cette règle, vous réduire le risque de problèmes causés par votre (complet) les noms de classes en conflit avec d'autres peuples.