Qu'est-ce qu'un exemple du principe de responsabilité unique?
Quelqu'un peut-il me donner un exemple du principe de responsabilité unique? J'essaie de comprendre ce que cela signifie, en pratique, pour une classe d'assumer une seule responsabilité, car je crains d'enfreindre cette règle quotidiennement.
Découvrez la Description solide .
À moins que vous ne demandiez quelque chose de plus spécifique, il sera difficile d’aider davantage.
La responsabilité unique est le concept de classe faisant une chose spécifique (responsabilité) et n'essayant pas de faire plus qu'elle ne le devrait, ce qui est également appelé haute cohésion.
Les classes ne commencent pas souvent avec une faible cohésion, mais généralement, après plusieurs versions et différents développeurs qui les ont ajoutées, vous remarquerez tout à coup que c'est devenu un monstre ou une classe de Dieu comme certains l'appellent. Donc, la classe devrait être refactorisée.
Il est difficile de penser à un bon exemple, mais celui auquel je peux penser récemment serait une classe que nous avons qui gère différentes étapes de traitement des paquets, un type de Chain of Responsibility. L'intention initiale de cette classe était de maintenir une liste d'étapes et d'orchestrer l'appel de packetProcess () sur celles-ci. En fin de compte, tout le monde a ajouté quelque chose à propos des étapes de traitement (car la classe de gestionnaires était un endroit facile d'accès aux étapes) à cette classe de gestionnaires, en particulier la configuration des étapes. La classe des gestionnaires n’avait plus une responsabilité unique, mais était également chargée d’appeler les étapes pour les modifications de configuration: la cohésion avait donc été réduite.
Nous avons finalement dû refactoriser la classe manager, en extrayant toute la configuration de la scène et en la plaçant dans une usine, laissant ainsi le manager faire ce qu'il était censé faire.
Le moyen le plus efficace de casser les applications consiste à créer DIEU classes. Ce sont des classes qui gardent trace de beaucoup d’informations et ont plusieurs responsabilités. Un changement de code affectera probablement d'autres parties de la classe et donc indirectement toutes les autres classes qui l'utilisent. Cela entraîne à son tour un gâchis de maintenance encore plus important puisque personne n’ose oser d’apporter de modifications autres que l’ajout de nouvelles fonctionnalités.
L'exemple suivant est une classe TypeScript qui définit une Person. Cette classe ne doit pas inclure la validation de courrier électronique car elle n'est pas liée au comportement d'une personne:
class Person {
public name : string;
public surname : string;
public email : string;
constructor(name : string, surname : string, email : string){
this.surname = surname;
this.name = name;
if(this.validateEmail(email)) {
this.email = email;
}
else {
throw new Error("Invalid email!");
}
}
validateEmail(email : string) {
var re = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
return re.test(email);
}
greet() {
alert("Hi!");
}
}
Nous pouvons améliorer la classe ci-dessus en supprimant la responsabilité de la validation du courrier électronique de la classe Personne et en créant une nouvelle classe Email qui aura cette responsabilité:
class Email {
public email : string;
constructor(email : string){
if(this.validateEmail(email)) {
this.email = email;
}
else {
throw new Error("Invalid email!");
}
}
validateEmail(email : string) {
var re = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
return re.test(email);
}
}
class Person {
public name : string;
public surname : string;
public email : Email;
constructor(name : string, surname : string, email : Email){
this.email = email;
this.name = name;
this.surname = surname;
}
greet() {
alert("Hi!");
}
}
En veillant à ce qu'une classe ait une responsabilité unique, il est également plus facile par défaut de voir ce qu'elle fait et comment vous pouvez l'étendre/l'améliorer.
Le principe de responsabilité unique (SRP) stipule qu'une classe ou une méthode ne doit faire qu'une chose et ne doit en aucun cas être liée à une chose. Une classe ne devrait avoir qu'une seule raison de changer.
Un exemple typique pourrait être une classe EmailSender:
- cela devrait juste traiter d'envoyer un email.
- cela ne devrait pas être responsable du chargement du contenu du courrier électronique depuis la base de données ou même du formatage du contenu du courrier électronique à envoyer.
Ici est un article à ce sujet.
Une classe ne devrait avoir qu'une seule raison de changer.
Ce principe stipule que si nous avons deux raisons de changer pour une classe, nous devons diviser la fonctionnalité en deux classes. Chaque classe n'assumera qu'une seule responsabilité et si, à l'avenir, nous devons effectuer un changement, nous le ferons dans la classe qui le gère.
S'il y a deux raisons différentes de changer, il est concevable que deux équipes différentes puissent travailler sur le même code pour deux raisons différentes. Chacun devra déployer sa solution, ce qui dans le cas d'un langage compilé (comme C++, C # ou Java) peut conduire à des modules incompatibles avec d'autres équipes ou d'autres parties de l'application.
Ce principe est étroitement lié aux concepts de couplage et de cohésion. Le couplage fait référence au lien inextricable entre les différents aspects d’une application, tandis que la cohésion fait référence au rapport étroit qui existe entre le contenu d’une classe ou d’un package particulier. Tous les contenus d'une même classe sont étroitement couplés, car la classe elle-même est une [unité unique] [1] qui doit être entièrement utilisée ou pas du tout.
Mon article sur ce blog:
http://javaexplorer03.blogspot.in/2016/12/single-responsibility-principle.html