Garder tout couplage lâche et extensible: Trop de couches, trop petit retour sur investissement?

Question

I (plus que jamais) voir les développeurs à écrire d'énormes quantités de couches telles que:

implementation PresentationLayer ->
    interface IMyDTO ->
        implementation MyDTO ->
            interface IMyService -> 
                implementation MyService -> 
                    interface IMyDomainRepository ->
                        implementation MyDomainRepository ->
                            interface IMyDomainObject -> 
                                implementation MyDomainObject ->
                                    interface IMyIndependentStorageLayer ->
                                        implementation MyMSSQLStorageLayer

En regardant à travers des blogs C #, cela semble la meilleure chose depuis le pain tranché. En gros, tout est couplé de façon lâche. Ne pas utiliser un objet de domaine directement. Exécutez tout à travers une couche de service. Accès aux données par le biais d'un référentiel. Toutes les couches sont parfaitement indépendantes.

Ne vous méprenez pas, j'aime l'idée, mais n'est pas le compromis dans le temps énorme, en particulier sur un projet plus vaste? Est-ce le retour sur investissement dans l'entretien vraiment assez grand pour justifier cela?

Les explications que je lis sont un peu maladroits, tels que « cette façon, je peux joindre une autre base de données si je dois ». Vraiment? Je ne que tous ne savent pas pense pas que c'est un problème commun que quelqu'un demande soudainement passer de MSSQL à Oracle et maintenant vous êtes assis là et je souhaite que vous aviez un million de couches les unes des autres.

Y at-il une tendance à aller trop loin avec couplage lâche, ou suis-je en train de lire les blogs faux? Comment vous sentez-vous à ce sujet, et avez-vous eu des cas où vous étiez vraiment heureux plus tard que vous avez fait le travail supplémentaire au début?

Answer 1

Il est très difficile de concevoir la bonne conception aligné d'affaires pour un logiciel. Je veux dire avec un retour sur investissement acceptable.

Cependant, pour moi, le nombre de couches ou le niveau de faible couplage d'une conception logicielle dépend du contexte dans lequel le logiciel sera utilisé!

Si vous êtes sûr de ce que le logiciel doit faire, et il y aura probablement pas de grandes modifications ou ajoute à l'avenir, une application de couplage de niveau super bas avec beaucoup de couches ne sont pas la solution. Parce qu'il rend l'architecture trop complexe sans aucune raison et le temps investi pour l'architecture n'est pas rentable ...
D'autre part, si vous savez que l'application devra être personnalisée à chaque client et sera certainement modifier en profondeur, donc le temps passé à une architecture de couplage faible niveau est une bonne idée ...
couplage faible niveau peut être intelligent lorsque vous souhaitez réutiliser une partie du code pour une autre application. Dans ce cas, le temps passé pour la conception est tout à fait rentable, bien sûr.
Puis, en résumé, je dirai que tout dépend de l'évolution du logiciel dans l'avenir et le potentiel de réutilisation de code pour d'autres applications.
Mais il est une meilleure pratique pour moi faire pas systématiquement une architecture très complexe.

Answer 2

De toute évidence, il peut être exagéré, et on a besoin de savoir « où arrêter » en ajoutant des couches.

Ma règle de base est que si une couche n'a pas besoin d'inclure toutes les fonctionnalités importantes / code, je ne suis pas besoin. Cela étant dit, testabilité est une chose importante, donc si une couche me achète mieux testabilité, je vais l'ajouter.

Answer 3

Rien dans la conception d'applications est sans prix. Ici, le prix est augmenté complexibility. Il faut toujours des regards à travers vos options avant de choisir celui qui correspond à vos besoins le meilleur.

Cela étant dit, je pense que votre question semble un peu biaisé. Dans le monde réel, vous pourriez ne pas voir souvent un client exigeant un nouveau type de DB, mais vous pouvez voir souvent une nouvelle costumer qui veut le même genre de données d'accès que le précédent, mais sur un autre DB. Il est non seulement sur la facilité de changement, il est aussi sur le code-réutilisation.

Answer 4

Lors de l'évaluation de ces choses que je trouve souvent utile de le regarder à travers la lentille du principe DRY et regardant double emploi dans votre projet.

Si vous utilisez une architecture plus complexe que votre projet, vous aurez tendance à voir beaucoup de couches qui ne peu en plus enveloppent d'autres couches et passent sur les appels. Ceci est de vous répéter.

Si d'autre part vous utilisez une architecture mince pour un système complexe, vous trouverez peut-être que la création d'une fonctionnalité dans une partie du système ne vous permet pas de réutiliser cette fonctionnalité dans une autre partie, vous forçant à écrire beaucoup de très un code similaire dans tous les sens. Ceci est de vous répéter.

Dans mon expérience, si vous êtes vigilant à identifier les doubles emplois et refactorisation constamment pour l'enlever, la structure va se présenter à vous. Disons, par exemple, que vous commencez avec une architecture assez simple mais briser les choses dans les méthodes dès qu'ils ont besoin d'être réutilisés, et de briser les méthodes à en classes dès qu'ils ont besoin d'être réutilisés par d'autres classes. Ensuite, vous pouvez éventuellement réaliser que vos 13 Helper / directeur / classes de gestionnaire que vous avez écrit pour éliminer la duplication regarder effectivement tout à fait un peu comme ils prennent la responsabilité qui aurait pu être plus si elle avait clairement défini entré dans une couche de service.

Il peut être difficile de savoir quand il vaut la peine, mais je pense que la clé du succès dans la construction d'un système avec beaucoup de couches est d'être très clair avec quelles responsabilités les différentes couches doivent avoir. Toute couche que vous ajoutez doit vous être utile pour réduire la complexité des opérations dans la couche au-dessus et en le rendant plus facile à tisser ensemble des fonctionnalités d'une manière élégante.

Answer 5

Prenons un exemple de projet hypothétique. Les tests utilisent divers en cours de traitement des bases de données SQLite pour la vitesse, la base de données de développement sur l'ordinateur de certains développeur est PostgreSQL, la base de données de mise en scène est un seul Oracle installer, et la base de données de production est une solution évolutive massivement, très cher, et très difficile à configurer Oracle cluster.

Comment qualifieriez-vous jamais retirer cela sans séparer la couche SQL de la couche d'affaires?

Answer 6

Il est une tendance récente, et conduit / architectes moins expérimentés sont en proie à sauter sur le train en marche.

Dans le projet, je suis sur, l'accès aux données a:

Service Interface -> Mise en œuvre de services -> Interface délégué -> Mise en œuvre de délégué -> Interface DAO -> Mise en œuvre DAO -.> Ibatis XML

C'était (et est!) Mauvais dans notre cas, parce que le plus code dans toute méthode de mise en œuvre du délégué était une seule ligne; il vient d'appeler DAO. Pour chaque DAO, nous avions deux classes supplémentaires et une configuration de haricots supplémentaire, et nous ne gagnons rien du tout de cela.

Accepter le changement, refactoring, et passer à autre chose. Utilisez autant de couches que nécessaire pour reconstituer en dehors des concepts différents ... puis arrêter. S'il n'y a pas de gain perçu par écrit du code, sauf qu'il suivra un modèle, que ce soit ralentir et essayer de comprendre pourquoi le modèle a fait, ou accepter que le modèle est mauvais pour votre application et ignorer ce bit.

Answer 7

Je travaille actuellement sur un grand projet SOA où chaque couche a été découplée, et presque toutes les classes est instancié via une usine abstraite. Maintenant, nous essayons de délester certaines des fonctionnalités existantes dans les services hébergés séparément, et il est un véritable cauchemar en passant par les couches essayant d'extrapoler les bits importants parce qu'il ya un clic droit sans fin> Aller à la définition ... pour chasser vers le bas ce qui était seulement 1 ligne de code à la couche la plus externe!

Il n'y a rien de mal avec le découplage en soi, et certainement même dans mon projet il y a beaucoup de domaines dans lesquels je trouve utile d'un point de vue architectural. Il suffit de ne pas se laisser emporter ... Soyez pragmatique, et peser les avantages / inconvénients lors de l'examen des domaines que vous envisagez de découpler.

Vive