Les interacteurs dans une "architecture propre" violent-ils le principe de responsabilité unique?
Le SRP indique qu'une classe (module) ne devrait avoir qu'une seule raison de changer. Les "tâches" d'un interacteur dans l'architecture propre de Bob Martin sont, par cas d'utilisation: recevoir des demandes/des entrées d'un contrôleur; orchestrer les entités de domaine pour remplir les demandes; et préparer les données de sortie.
Cela implique-t-il trois raisons de changer? (c'est-à-dire chaque fois que les entrées modifient ou des fonctionnalités de domaine sont élargies ou des champs de sortie supplémentaires sont ajoutés.) Si nécessaire, quelle serait une bonne stratégie pour résoudre ce problème? (par exemple, CQRS?)
Mon approche actuelle consiste à effectuer un module d'interacteur de cas d'utilisation avec trois classes, une par chaque préoccupation et une quatrième classe de façade/médiatrice pour l'orchestration et les clients interfaçant. Cependant, cela ne pousse pas la violation SRP au niveau du module?
Comme indiqué par @robert Harvey, le terme "devoirs" a été utilisé plutôt surnombily. La question de conception réelle a été les grandes modifications apportées à l'interacteur nécessaire à la fois lorsque le domaine a changé, et les champs OutputData (formats "ont changé (moins avec les entrées). Ces deux raisons distinctes de changement ne sont-elles pas différentes?
Comme je me suis rendu compte de @Filip Milovanović et @ Guillaume31, SRP n'est pas violé, esp. avec trois classes distinctes dans le module d'interacteur. De plus, au niveau du module, le "principe de fermeture commune" est peut-être plus approprié que le SRP. Le PCC ("rassembler des composants ... CLASSES qui changent pour les mêmes raisons et aux mêmes moments.") Peut suggérer de séparer les classes d'interacteur. (Mais ensuite, les classes correspondant au même cas d'utilisation seraient étendues entre les emplacements.) Grâce aux réponses et commentaires, ces compromis sont devenus beaucoup plus clairs pour moi.
Les "tâches" d'un interacteur dans l'architecture propre de Bob Martin sont, par cas d'utilisation: recevoir des demandes/des entrées d'un contrôleur; orchestrer les entités de domaine pour remplir les demandes; et préparer les données de sortie.
Cela implique-t-il trois raisons de changer?
Vous confondez des tâches avec des responsabilités. Plus spécifiquement, vous êtes déroutant "ne devrait avoir qu'une seule responsabilité" avec "ne devrait faire qu'une chose."
La responsabilité d'un interacteur est de "interagir".
La responsabilité d'une classe d'accès aux données est d'accéder aux données. Il n'a pas quatre responsabilités car elle crée, lit, mises à jour et suppression; Il a quatre devoirs
Si vous êtes un cuisinier à court terme, votre responsabilité est de faire des repas. Vous ne divisez pas vos tâches en employés distincts. Vous n'avez pas un employé qui fissure l'œuf, un autre employé qui le retourne et un tiers qui le met sur la plaque. Vous effectuez tous les trois.
Pour une méthode, recevoir des paramètres d'entrée et retourner une sortie ne sont pas des responsabilités en soi.
Mappage/mise en forme des données pour le rendre prête à être transféré à une autre couche peut être considérée comme une, mais elle peut être externalisée à un objet MAPER.
Et peu importe si vous orchestrez des appels vers un, 2 ou dix collaborateurs, il est encore une responsabilité unique, donc aucun problème ici.
L'une des raisons de changer n'est pas aussi claire que Robert Martin s'est corrigée dans ses vidéos. IMHO, la meilleure explication est n rôle à changement (c), ce qui signifie qu'un seul rôle devrait changer un module. Par exemple, certains des rôles possibles sont DBA, un propriétaire de produit, une analyse commerciale, un concepteur, un avocat avec les nouvelles règles de calcul, etc. Cela signifie que les modifications css ne devraient pas affecter la logique commerciale et Le Sharding DB ne devrait pas changer de logique de cas. C'est tout. Et cette règle concerne uniquement des modules, une personne pourrait l'appliquer aux cours ou aux méthodes, mais la raison pour laquelle cette règle a été créée pour scinder le code par des rôles pouvant changer le code.