Dois-je organiser mes dossiers par domaine d'activité ou par domaine technique?

Par exemple, si j'utilise une architecture de type MVC, quelle structure de dossier dois-je utiliser:

domain1/
    controller
    model
    view
domain2/
    controller
    model
    view

Ou:

controllers/
    domain1
    domain2
models/
    domain1
    domain2
views/
    domain1
    domain2

J'ai délibérément omis les extensions de fichier pour garder cette question indépendante de la langue.

Personnellement, je préférerais séparer par domaine d'activité (intuition), mais je vois que la plupart / de nombreux cadres se séparent par domaine technique. Pourquoi devrais-je choisir l'un plutôt que l'autre?

Je pense que cela dépend d'un projet spécifique.

Par exemple, si les différents domaines d'activité sont totalement indépendants les uns des autres, je m'organiserais par domaine d'activité.

Mais s'il y a du code partagé entre les domaines d'activité, ou plutôt, les domaines d'activité sont différentes variantes de la même base de code, alors il semble plus logique de les organiser par domaine technique. Et si vous utilisez n'importe quel type de langage orienté objet, vous pouvez probablement sous-classer vos contrôleurs génériques, modèles, etc. dans vos fichiers spécifiques à l'entreprise pour les rendre plus fins.

Il y a également un (doré) à mi-chemin entre les deux: supprimer le code partagé dans son propre domaine et l'utiliser dans d'autres domaines. Cela vous donne une présentation optimisée, mais permet un code partagé entre les domaines d'activité.

Domain1              # This domain changes bits of standard MVC code
  controllers
  models
  views
Domain2              # this domain only modifies views, all else is standard
  views
Shared               # Here is the better part of code base
  controllers
  models
  views

PS. Je pense que la plupart des frameworks s'organisent par domaine technique simplement parce qu'ils ont tendance à s'attendre à ce que vous mélangiez différents domaines commerciaux en un seul projet uniquement si vous avez partagé du code et sinon vous créeriez des projets séparés.

ÉDITER:

Par exemple, supposons qu'il existe une application Web qui gère l'entrepôt d'une entreprise. Sous forme générique, cela peut s'appliquer à de nombreuses entreprises, mais chacune d'entre elles peut avoir des spécificités qui ne sont pas remplies et leur interdit d'acheter. Par exemple, l'une d'entre elles a déployé des tablettes sur les chariots élévateurs et a besoin d'une vue spéciale pour elles tandis qu'une autre souhaite pour organiser les éléments en trois niveaux au lieu de la valeur par défaut de deux.

Vous pouvez bien sûr bifurquer le projet pour chacune de ces entreprises. Mais si le cadre / langage le permet, vous pouvez utiliser des sous-classes ou des plugins, etc. pour personnaliser les éléments du projet générique en fonction des besoins de chaque client et les organiser dans les dispositions du domaine d'activité.

Par exemple, si le projet générique exporte vers JSON uniquement l'élément lui-même, Domain1 peut sous-classer le contrôleur et le faire exporter également les problèmes de livraison récents.

Et si vous constatez plus tard que Domain1 a un composant qui est également valide pour Domain2, vous pouvez en extraire la version générique vers Shared.

Comme vous l'avez dit, de nombreux frameworks s'organisent par domaine technique et c'est ce que j'ai utilisé pour l'instant, juste parce que mon FW de choix rend cela plus facile. Mais avec un peu (ou beaucoup) d'huile de coude, je pense que je pourrais également réécrire les chemins d'inclusion pour prendre en charge la mise en page du domaine d'activité.

Je pense qu'il est éclairant de se demander: "qu'est-ce que je suis le plus susceptible d'ajouter régulièrement, plus de domaines ou des divisions plus techniques?" Quelle que soit la réponse, mettez-la au plus haut niveau.

Dans la plupart des cas, votre architecture technique se solidifie plus rapidement que votre domaine. Cela signifie que vous devez d'abord organiser par domaine, puis par composant architectural. La raison en est que lorsque quelque chose dans un domaine change, vous devrez peut-être ajouter ou modifier plusieurs composants techniques dans ce domaine, mais nous espérons que cela est localisé et ne déborde pas beaucoup sur d'autres domaines.

Si vous avez modifié votre infrastructure graphique, cela signifie que vos modifications se répercuteront sur l'ensemble de l'application, mais là encore, vous modifiez rarement votre infrastructure graphique, mais vous changez toujours la logique de votre domaine.

Gardez les choses ensemble si elles sont susceptibles de changer en même temps.

Il existe une autre alternative qui consiste à déplacer les parties séparées dans les plugins. CakePHP fait cela par exemple. Il vous permettra de générer des pièces MVC complètes réutilisables que vous pourrez trier selon la logique de votre choix.

Votre application principale les utilisera et les liera.

Fondamentalement, votre question concerne également la cohésion et le couplage. Vous souhaitez que les pièces séparées fonctionnent de manière aussi indépendante que possible. De cette façon, vous obtenez du code testable et réutilisable.

En tenant compte de cela: Si vous vous divisez par domaine, comment réutiliseriez-vous des parties de votre application? Par exemple, prenez une boutique en ligne: une demande arrive pour / commandes / vue / 1, vous devez donc afficher la commande n °. 1. Accède à / commandes / contrôleurs / control_controller Si vous avez séparé le domaine par produits et commandes, vous auriez déjà besoin de parties de l'autre "domaine".

Là, vous pouvez commencer à interfacer des choses, mais les choses sont probablement trop cohérentes dans la plupart des entreprises. Si vous adoptez l'approche technique. Par exemple, vous pourriez avoir un plugin qui gère les commandes. Vous y mettez des objets Product depuis votre application centrale. De cette façon, vous pouvez tester le plugin facilement, créez simplement un objet Produit avec un nom et un prix et envoyez-le.

Le plugin fera exactement ce qu'il doit faire. Cela dépendra de son entrée et non pas d'autres "parties / domaines / zones".

Microsoft ASP.Net MVC 3 a le concept de "Zones". Lorsque vous introduisez des "Zones" dans votre projet MVC, elles se décomposent comme:

area1/
   models
   views
   controllers
area2/
   models
   views
   controllers

J'ai trouvé que c'était assez naturel. Une zone est un "gros morceau" d'un projet, et travailler dans une unité autonome était tout à fait logique.

Nous avons utilisé des espaces de noms pour correspondre, FWIW.

D'après mon expérience personnelle avec une boutique en ligne composée de 300 000 lignes de code, je choisirais toujours l'organisation par domaine d'activité. De cette façon, vous pouvez non seulement obtenir un aperçu rapide de toutes les classes pertinentes lorsque vous travaillez sur un domaine fonctionnel, mais en Java, vous pouvez également utiliser la visibilité du package.

Quelques détails pour ceux qui sont intéressés: Lorsque le projet a été lancé il y a 5 ans, les développeurs ont créé la structure de package suivante:

com
  example
    web
      struts
        action
        form
      shared
      functionality1
      functionality2

Chaque fonction de boutique telle que le panier, la recherche de produits, etc. se compose de plusieurs actions, chacune avec sa propre classe de formulaire (structure mandatée par le framework MVC). Nous nous sommes retrouvés avec plus de 200 classes dans le package d'action, chacune complètement séparée de sa classe de formulaire associée. Le pire est que les actions n'implémentent pas trop de logique, mais appellent des services spécifiques aux fonctions qui résident dans un autre package.

J'ai suggéré et convaincu l'équipe que nous devrions passer à l'organisation des packages par domaine d'activité. Le raisonnement est simple: si vous voulez vraiment voir une liste de toutes les actions, vous pouvez simplement ouvrir la vue de la hiérarchie des types de n'importe quel IDE décent. Cependant, ce que l'IDE ne peut pas faire, c'est inférer le domaine d'activité auquel appartient une classe. De plus, cette approche vous permet de ne rendre publiques que les classes nécessaires à plusieurs fonctionnalités, en gardant le reste sur la visibilité des packages.

Je suis d'accord que de nombreux frameworks se séparent par domaine technique et je commence donc souvent de cette façon lorsque j'utilise un nouveau framework. Cependant, je me contente de toujours utiliser le domaine d'activité comme niveau principal d'organisation des dossiers.

Personnellement, je pense qu'il est beaucoup plus facile de garder mon contrôleur Foo et mon référentiel Foo ou quoi que ce soit ensemble que d'aller et venir entre le dossier du contrôleur et le dossier du référentiel, car j'ai souvent besoin de travailler sur les deux lors de l'ajout de fonctionnalités autour de Foo. Dans les grands projets, cela est encore plus important car la distance entre les dossiers techniques peut être grande et devenir une perte de temps notable lors du développement.