Sont là les meilleures pratiques pour (Java) package organisation?

Il y A peu, j'ai vu une réponse à votre question ici concerne la fine de l'organisation de paquets java. Par exemple, my.project.util, my.project.factory, my.project.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 vous 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) contenant 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.

Je suis en désaccord avec la fermeture de cette question. Je ne conteste pas que les meilleures pratiques questions sont presque toujours fondées sur l'expérience et l'opinion, cependant, je suis en désaccord que ces questions devraient être fermés sur un Débordement de Pile. C'est le point crucial de la bonne programmation, en utilisant les meilleures pratiques et de trouver la meilleure solution utilise ces opinions et d'expériences. S'il vous plaît ré-ouvrir cette question.

OriginalL'auteur Cyntech | 2010-07-12

  1. 146

    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:

    • Suivre java package conventions de nommage
    • 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 seulement quelques 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.
    • Prendre un coup d'oeil à certains de l'open source les plus populaires de projets sur Apache projets. 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.

    Merci pour votre réponse. C'est en grande partie ce que nous avons essayé de comprendre, mais beaucoup de sans rapport avec le code obtenu dans nos haricots paquet, qui est l'endroit où ma question vient.
    Je suis d'accord paquet par la caractéristique la plus logique. J'ai entendu une grande analogie une fois lié à un bureau de la compagnie de la structure. Dans une approche à plusieurs niveaux, chacun des individus par niveau dans une entreprise serait assis les uns avec les autres c'est à dire les Cadres supérieurs, les gestionnaires, les admin, les employés/ouvriers à s'asseoir dans des sections distinctes dans un bâtiment. Cette structure n'est probablement pas aussi efficace qu'une "fonctionnalité" de façon organisée. I. e. si le directeur des Ventes est assis avec le directeur des Ventes qui s'assoit avec les employés du service des Ventes qui sont tous assis à l'un de nos Admin. Ceci fournit une meilleure cohésion entre le ministère, organisée de cette façon.

    OriginalL'auteur naikus

  2. 148

    - Je organiser les paquets en fonction, non pas par des motifs ou des rôles de mise en œuvre. Je pense que les paquets comme:

    • haricots
    • usines
    • collections

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

    • commandes
    • magasin
    • rapports

    afin que je puisse masquer les détails de mise en œuvre par le biais de package de visibilité: l'usine de commandes devraient être dans les commandes de package de sorte que les détails sur la façon de créer un bon de commande sont cachés.

    Ce post fait un bon point sur le package de visibilité. Je n'ai jamais vu de package Java champ d'application en cours d'utilisation, mais le bon paquet structure pourrait permettre aux développeurs de tirer un meilleur parti.
    C'est exactement ça, mais quelques développeurs de le faire. Les emballages devraient être cohérent collections de classes, dont certaines sont visibles uniquement dans le package. Qui permettrait de minimiser le couplage entre les classes qui ne doit pas être couplé parce qu'ils se rapportent à des caractéristiques différentes. Le colis par couche approche ne permet pas de profiter de package modificateurs de visibilité, et les paquets dans un tel projet ont une faible cohésion et un haut degré de couplage entre les paquets.
    Avez-vous des exemple de cela? Je suis à l'aide de Spring-MVC, j'ai du mal à l'organiser en fonction/module car le printemps utilise config xml.
    J'ai aussi organiser mon code en fonction mais quelles sont les bonnes pratiques pour les classes de base partagée par toutes les fonctionnalités?
    J'ai été à la suite de la première de style. mais maintenant, je dois sauter d'un package à un autre lorsque l'on travaille avec des classes. ça fait vraiment une mauvaise expérience. Je suis maintenant de commutation de la deuxième de style parce que je pense qu'il sera plus facile de suivre les classes liées ensemble.

    OriginalL'auteur onof

  3. 36

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

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

    sous-paquetages briser l'encapsulation. Un "sous-ensemble" est vraiment un complètement indépendant paquet par lui-même

    OriginalL'auteur Peter Tseng

  4. 12

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

    • 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é.
    • De 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.

    OriginalL'auteur ThomasGran

  5. 10

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

    Pas vraiment pas. 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 également ajouter que il y 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.

    OriginalL'auteur Stephen C

  6. 4

    J'ai vu des personnes de promouvoir les colis en fonction de' plus 'colis par couche", mais j'ai utilisé un peu d'approches au cours de nombreuses années et a trouvé un paquet par calque "beaucoup mieux que le forfait "par fonction".

    De plus, j'ai trouvé que un hybride: d'un paquet par module, couche puis en fonction de la stratégie fonctionne très bien en pratique qu'il a beaucoup d'avantages d'un "forfait par la fonctionnalité":

    • Favorise la création de réutilisables cadres (bibliothèques avec les deux modèle
      l'INTERFACE et les aspects)
    • Permet de brancher et de jouer de la couche d'implémentations - pratiquement impossible avec le forfait "par fonction", car il met plus de couche implémentations dans le même package/répertoire que le code du modèle.
    • Beaucoup plus...

    J'explique en détail ici: Package Java Nom de la Structure et de l'Organisation mais mon paquet standard structure:

    revdomain.moduleType.moduleName.la couche.[layerImpl].fonctionnalité.subfeatureN.subfeatureN+1...

    Où:

    revdomain domaine Inversée, par exemple, com.mycompany

    moduleType [app*|cadre|util]

    moduleName par exemple myAppName si le type de module est une application ou à financer la si de sa un cadre comptable

    couche [modèle|ui|persistance|sécurité, etc.,]

    layerImpl eg., wicket, jsp, jpa, jdo, hibernate (Note: n'est pas utilisé si la couche est modèle)

    fonction eg., finances

    subfeatureN eg., comptabilité

    subfeatureN+1 eg., l'amortissement

    *Parfois 'app' gauche si moduleType est une application, mais de mettre en il fait de la structure du package cohérent à travers tous les types de modules.

    OriginalL'auteur Volksman

  7. 2

    Je ne suis pas au courant des pratiques standard pour les colis de l'organisation. J'ai en général de créer des forfaits qui couvrent certains raisonnablement large spectre, mais je peux différencier au sein d'un projet. Par exemple, un projet personnel, je suis actuellement en train de travailler sur a un paquet consacré à mon personnalisés des contrôles d'INTERFACE utilisateur (plein de classes de sous-classement swing classes). J'ai un paquet consacré à ma base de données de gestion des trucs, j'ai un paquet pour un ensemble d'auditeurs/événements que j'ai créé, et ainsi de suite.

    D'autre part, j'ai eu un collègue de travail, créez un nouveau package pour presque tout ce qu'il fait. Chaque MVC il voulait a son propre paquet, et il semblait un MVC était le seul regroupement de classes autorisés à être dans le même package. Je me souviens à un moment donné, il y avait 5 différents forfaits que chacun avait une classe unique en eux. Je pense que sa méthode est un peu à l'extrême (et l'équipe qui l'a contraint à réduire son paquet de compte quand on ne pouvait tout simplement pas s'en occuper), mais pour une demande non trivial, ce serait de tout mettre dans le même paquet. C'est un point d'équilibre que vous et vos coéquipiers devez trouver par vous-même.

    Une chose que vous pouvez faire est d'essayer de prendre du recul et penser: si vous étiez un nouveau membre introduits dans le projet, ou que votre projet a été publié en open source ou une API, comment facile/serait-il difficile de trouver ce que vous voulez? Parce que pour moi, c'est ce que j'ai vraiment envie de paquets: l'organisation. Similaire à la façon dont je stocker des fichiers dans un dossier sur mon ordinateur, je m'attends à être en mesure de trouver de nouveau sans avoir à chercher de l'ensemble de mon disque. Je excpect pour être en mesure de trouver la classe que je veux sans avoir à rechercher la liste de toutes les classes dans le package.

    OriginalL'auteur Brian S