Comment mettre en œuvre le principe de responsabilité unique du modèle de conception Java

Principe de responsabilité unique, appelé SRP.

Définition :

Il ne devrait jamais y avoir plus d'une raison pour qu'une classe change.

Il ne devrait y avoir qu'une seule raison pour qu'une classe change.

Parfois, les développeurs rencontrent des problèmes lors de la conception d'interfaces, tels que les attributs et les comportements des utilisateurs déclarés dans une interface. Cela entraîne la mise en place d'objets métier et de logique métier, ce qui donne à l'interface deux responsabilités. Selon la définition de SRP, cela viole le principe de responsabilité unique de l'interface.

Ce qui suit est un exemple :

package com.loulijun.chapter1;     public interface Itutu {      //身高      void setShengao(double height);      double getShengao();      //体重      void setTizhong(double weight);      double getTizhong();      //吃饭      boolean chiFan(boolean hungry);      //上网      boolean shangWang(boolean silly);  }

L'exemple ci-dessus présente ce problème. La taille et le poids sont des objets métier, et les méthodes correspondantes sont principalement responsables des attributs de l'utilisateur. Manger et surfer sur Internet sont des logiques commerciales correspondantes, qui sont principalement responsables du comportement des utilisateurs. Mais cela donnera aux gens le sentiment qu’ils ne savent pas à quoi sert cette interface, les responsabilités ne sont pas claires et cela entraînera également divers problèmes lors de maintenances ultérieures.

Solution : Principe de responsabilité unique, il suffit de décomposer cette interface en deux interfaces avec des responsabilités différentes

ItutuBO.java : Responsable des attributs de tutu (TuTu, si c'est un nom personnel)

package com.loulijun.chapter1;     /**   * BO：Bussiness Object，业务对象   * 负责用户的属性   * @author Administrator   *   */ public interface ItutuBO {      //身高      void setShengao(double height);      double getShengao();      //体重      void setTizhong(double weight);      double getTizhong();  }

ItutuBL.java : Responsable de Tutu Le comportement de Tu

package com.loulijun.chapter1;  /**   * BL:Business Logic,业务逻辑   * 负责用户的行为   * @author Administrator   *   */ public interface ItutuBL {      //吃饭      boolean chiFan(boolean hungry);      //上网      boolean shangWang(boolean silly);  }

atteint ainsi la seule responsabilité de l'interface. Ensuite, lors de l'implémentation de l'interface, vous devez avoir deux classes différentes

TutuBO.java

package com.loulijun.chapter1;     public class TutuBO implements ItutuBO {      private double height;      private double weight;      @Override     public double getShengao() {                 return height;      }         @Override     public double getTizhong() {          return weight;      }         @Override     public void setShengao(double height) {          this.height = height;      }         @Override     public void setTizhong(double weight) {          this.weight = weight;      }     }

TutuBL.java

package com.loulijun.chapter1;     public class TutuBL implements ItutuBL {         @Override     public boolean chiFan(boolean hungry) {          if(hungry)          {              System.out.println("去吃火锅...");              return true;          }          return false;      }         @Override     public boolean shangWang(boolean silly) {          if(silly)          {              System.out.println("好无聊啊，上会网...");              return true;          }          return false;      }     }

C'est clair Lorsque vous devez modifier les attributs utilisateur, il vous suffit de modifier l'interface ItutuBO. affectera la classe TutuBO et n’affectera pas les autres classes.

Alors, quelle est la signification du principe de responsabilité unique ?

1. Réduisez la complexité du cours et définissez clairement les types de responsabilités qui sont mises en œuvre

2. Améliorez la lisibilité

3. Améliorez la maintenabilité

4. Réduisez les risques causés par les changements et avez un impact négatif sur l'évolutivité du système C'est très utile pour la maintenance et la maintenance

Cependant, l'utilisation du principe de responsabilité unique pose un problème. Il n'y a pas de norme claire pour diviser la « responsabilité » si les responsabilités sont trop finement divisées, le nombre d'interfaces et la mise en œuvre. les classes augmenteront fortement, au contraire, cela augmentera la complexité et réduira la maintenabilité du code. Par conséquent, lorsque vous assumez cette responsabilité, vous devez analyser la situation spécifique en détail. La suggestion est que l'interface doit adopter le principe de responsabilité unique et mettre en œuvre le principe de responsabilité unique autant que possible dans la conception de la classe. La seule raison est qu'une classe change.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!