PHP代码简洁之道——SOLID原则

SOLID 是Michael Feathers推荐的便于记忆的首字母简写，它代表了Robert Martin命名的最重要的五个面对对象编码设计原则：

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：空间域名、雅安服务器托管、营销软件、网站建设、盘锦网站维护、网站推广。

  • S: 单一职责原则 (SRP)
  • O: 开闭原则 (OCP)
  • L: 里氏替换原则 (LSP)
  • I: 接口隔离原则 (ISP)
  • D: 依赖反转原则 (DIP)

单一职责原则 Single Responsibility Principle (SRP)

"修改一个类应该只为一个理由"。人们总是易于用一堆方法塞满一个类，如同我们在飞机上只能携带一个行李箱(把所有的东西都塞到箱子里)。这样做的问题是：从概念上这样的类不是高内聚的，并且留下了很多理由去修改它。将你需要修改类的次数降低到最小很重要。这是因为，当有很多方法在类中时，修改其中一处，你很难知晓在代码库中哪些依赖的模块会被影响到。

Bad:

 
 
 
    
  
  
  
  1. class UserSettings{    
    2. 
  
  
  
  2.     private $user;    
    3. 
  
  
  
  3.     public function __construct($user)
    4. 
  
  
  
  4.     {        
    5. 
  
  
  
  5.         $this->user = $user;
    6. 
  
  
  
  6.     }    
    7. 
  
  
  
  7.     public function changeSettings($settings)
    8. 
  
  
  
  8.     {        
    9. 
  
  
  
  9.         if ($this->verifyCredentials()) {           
    10. 
  
  
  
  10.          // ...
    11. 
  
  
  
  11.         }
    12. 
  
  
  
  12.     }    
    13. 
  
  
  
  13.     private function verifyCredentials()
    14. 
  
  
  
  14.     {        
    15. 
  
  
  
  15.     // ...
    16. 
  
  
  
  16.     }
    17. 
  
  
  
  17. } 
    18.

Good:

 
 
 
    
  
  
  
  1. class UserAuth {    
    2. 
  
  
  
  2. private $user;    
    3. 
  
  
  
  3. public function __construct($user){        
    4. 
  
  
  
  4.     $this->user = $user;
    5. 
  
  
  
  5. }    
    6. 
  
  
  
  6. public function verifyCredentials(){        
    7. 
  
  
  
  7.     // ...
    8. 
  
  
  
  8. 
  
  
  
  9. }
    10. 
  
  
  
  10. }
    11. 
  
  
  
  11. class UserSettings {    
    12. 
  
  
  
  12. private $user;    
    13. 
  
  
  
  13. private $auth;    
    14. 
  
  
  
  14. public function __construct($user) {        
    15. 
  
  
  
  15.   $this->user = $user;        
    16. 
  
  
  
  16.   $this->auth = new UserAuth($user);
    17. 
  
  
  
  17. }    
    18. 
  
  
  
  18. public function changeSettings($settings){        
    19. 
  
  
  
  19.     if ($this->auth->verifyCredentials()) {            
    20. 
  
  
  
  20.     // ...
    21. 
  
  
  
  21.         }
    22. 
  
  
  
  22.     }
    23. 
  
  
  
  23. } 
    24.

开闭原则 Open/Closed Principle (OCP)

正如Bertrand Meyer所述，"软件的实体(类, 模块, 函数,等)应该对扩展开放，对修改关闭。"这个原则是在说明应该允许用户在不改变已有代码的情况下增加新的功能。

Bad:

 
 
 
    
  
  
  
  1. abstract class Adapter{    
    2. 
  
  
  
  2. protected $name;    
    3. 
  
  
  
  3. public function getName(){        
    4. 
  
  
  
  4.     return $this->name;
    5. 
  
  
  
  5. }
    6. 
  
  
  
  6. }
    7. 
  
  
  
  7. class AjaxAdapter extends Adapter{    
    8. 
  
  
  
  8. public function __construct(){     
    9. 
  
  
  
  9.       parent::__construct();        
    10. 
  
  
  
  10.       $this->name = 'ajaxAdapter';
    11. 
  
  
  
  11.  }
    12. 
  
  
  
  12. }
    13. 
  
  
  
  13. class NodeAdapter extends Adapter{    
    14. 
  
  
  
  14.     public function __construct(){   
    15. 
  
  
  
  15.         parent::__construct();        
    16. 
  
  
  
  16.         $this->name = 'nodeAdapter';
    17. 
  
  
  
  17.     }
    18. 
  
  
  
  18. }
    19. 
  
  
  
  19.     class HttpRequester{    
    20. 
  
  
  
  20.     private $adapter;    
    21. 
  
  
  
  21.     public function __construct($adapter)
    22. 
  
  
  
  22.     {        
    23. 
  
  
  
  23.         $this->adapter = $adapter;
    24. 
  
  
  
  24.     }    
    25. 
  
  
  
  25.     public function fetch($url)
    26. 
  
  
  
  26.     {
    27. 
  
  
  
  27.         $adapterName = $this->adapter->getName();        
    28. 
  
  
  
  28.     if ($adapterName === 'ajaxAdapter') {            
    29. 
  
  
  
  29.         return $this->makeAjaxCall($url);
    30. 
  
  
  
  30.         } 
    31. 
  
  
  
  31.     elseif ($adapterName === 'httpNodeAdapter') {            
    32. 
  
  
  
  32.         return $this->makeHttpCall($url);
    33. 
  
  
  
  33.         }
    34. 
  
  
  
  34.     }    
    35. 
  
  
  
  35.     private function makeAjaxCall($url)
    36. 
  
  
  
  36.     {        // request and return promise
    37. 
  
  
  
  37.     }    
    38. 
  
  
  
  38.     private function makeHttpCall($url)
    39. 
  
  
  
  39.     {        // request and return promise
    40. 
  
  
  
  40.     }
    41. 
  
  
  
  41. } 
    42.

在上面的代码中，对于HttpRequester类中的fetch方法，如果我新增了一个新的xxxAdapter类并且要在fetch方法中用到的话，就需要在HttpRequester类中去修改类(如加上一个elseif 判断)，而通过下面的代码，就可很好的解决这个问题。下面代码很好的说明了如何在不改变原有代码的情况下增加新功能。

Good:

 
 
 
    
  
  
  
  1. interface Adapter{    
    2. 
  
  
  
  2.     public function request($url);
    3. 
  
  
  
  3. }
    4. 
  
  
  
  4.     class AjaxAdapter implements Adapter{    
    5. 
  
  
  
  5.     public function request($url)
    6. 
  
  
  
  6.     {        // request and return promise
    7. 
  
  
  
  7.     }
    8. 
  
  
  
  8. }
    9. 
  
  
  
  9. class NodeAdapter implements Adapter{    
    10. 
  
  
  
  10.     public function request($url)
    11. 
  
  
  
  11.     {        // request and return promise
    12. 
  
  
  
  12.     }
    13. 
  
  
  
  13. }
    14. 
  
  
  
  14.     class HttpRequester{    
    15. 
  
  
  
  15.     private $adapter;    
    16. 
  
  
  
  16.     public function __construct(Adapter $adapter)
    17. 
  
  
  
  17.     {        $this->adapter = $adapter;
    18. 
  
  
  
  18.     }    
    19. 
  
  
  
  19.     public function fetch($url)
    20. 
  
  
  
  20.     {        return $this->adapter->request($url);
    21. 
  
  
  
  21.     }
    22. 
  
  
  
  22. } 
    23.

里氏替换原则 Liskov Substitution Principle (LSP)

对这个概念***的解释是：如果你有一个父类和一个子类，在不改变原有结果正确性的前提下父类和子类可以互换。这个听起来让人有些迷惑，所以让我们来看一个经典的正方形-长方形的例子。从数学上讲，正方形是一种长方形，但是当你的模型通过继承使用了"is-a"的关系时，就不对了。

Bad:

 
 
 
    
  
  
  
  1. class Rectangle{    
    2. 
  
  
  
  2.     protected $width = 0;    
    3. 
  
  
  
  3.     protected $height = 0;    
    4. 
  
  
  
  4.     public function render($area)
    5. 
  
  
  
  5.     {        // ...
    6. 
  
  
  
  6.     }    
    7. 
  
  
  
  7.     public function setWidth($width)
    8. 
  
  
  
  8.     {        $this->width = $width;
    9. 
  
  
  
  9.     }    
    10. 
  
  
  
  10.     public function setHeight($height)
    11. 
  
  
  
  11.     {        $this->height = $height;
    12. 
  
  
  
  12.     }    
    13. 
  
  
  
  13.     public function getArea()
    14. 
  
  
  
  14.     {        return $this->width * $this->height;
    15. 
  
  
  
  15.     }
    16. 
  
  
  
  16. }
    17. 
  
  
  
  17. class Square extends Rectangle{    
    18. 
  
  
  
  18.     public function setWidth($width)
    19. 
  
  
  
  19.     {        
    20. 
  
  
  
  20.         $this->width = $this->height = $width;
    21. 
  
  
  
  21.     }    
    22. 
  
  
  
  22.     public function setHeight(height)
    23. 
  
  
  
  23.     {        $this->width = $this->height = $height;
    24. 
  
  
  
  24.     }
    25. 
  
  
  
  25. }
    26. 
  
  
  
  26. function renderLargeRectangles($rectangles){    
    27. 
  
  
  
  27.     foreach ($rectangles as $rectangle) {
    28. 
  
  
  
  28.         $rectangle->setWidth(4);
    29. 
  
  
  
  29.         $rectangle->setHeight(5);
    30. 
  
  
  
  30.         $area = $rectangle->getArea(); // BAD: Will return 25 for Square. Should be 20.
    31. 
  
  
  
  31.         $rectangle->render($area);
    32. 
  
  
  
  32.     }
    33. 
  
  
  
  33. }
    34. 
  
  
  
  34. 
  
  
  
  35. $rectangles = 
    36. 
  
  
  
  36. [new Rectangle(), new Rectangle(), new Square()];
    37. 
  
  
  
  37. renderLargeRectangles($rectangles); 
    38.

Good:

 
 
 
    
  
  
  
  1. abstract class Shape{    
    2. 
  
  
  
  2.     protected $width = 0;    
    3. 
  
  
  
  3.     protected $height = 0;    
    4. 
  
  
  
  4.     abstract public function getArea();    
    5. 
  
  
  
  5.     public function render($area)    {        // ...
    6. 
  
  
  
  6.     }
    7. 
  
  
  
  7. }
    8. 
  
  
  
  8. class Rectangle extends Shape{    
    9. 
  
  
  
  9.     public function setWidth($width)
    10. 
  
  
  
  10.     {        $this->width = $width;
    11. 
  
  
  
  11.     }    
    12. 
  
  
  
  12.     public function setHeight($height)
    13. 
  
  
  
  13.     {        $this->height = $height;
    14. 
  
  
  
  14.     }    
    15. 
  
  
  
  15.     public function getArea()
    16. 
  
  
  
  16.     {        return $this->width * $this->height;
    17. 
  
  
  
  17.     }
    18. 
  
  
  
  18. }
    19. 
  
  
  
  19. class Square extends Shape{    
    20. 
  
  
  
  20.     private $length = 0;    
    21. 
  
  
  
  21.     public function setLength($length)
    22. 
  
  
  
  22.     {        $this->length = $length;
    23. 
  
  
  
  23.     }    
    24. 
  
  
  
  24.     public function getArea()
    25. 
  
  
  
  25.     {        return pow($this->length, 2);
    26. 
  
  
  
  26.     }
    27. 
  
  
  
  27. }
    28. 
  
  
  
  28. function renderLargeRectangles($rectangles){    
    29. 
  
  
  
  29. foreach ($rectangles as $rectangle) {        
    30. 
  
  
  
  30. if ($rectangle instanceof Square) {
    31. 
  
  
  
  31.             $rectangle->setLength(5);
    32. 
  
  
  
  32.         } elseif ($rectangle instanceof Rectangle) {
    33. 
  
  
  
  33.             $rectangle->setWidth(4);
    34. 
  
  
  
  34.             $rectangle->setHeight(5);
    35. 
  
  
  
  35.         }
    36. 
  
  
  
  36. 
  
  
  
  37.         $area = $rectangle->getArea(); 
    38. 
  
  
  
  38.         $rectangle->render($area);
    39. 
  
  
  
  39.     }
    40. 
  
  
  
  40. }
    41. 
  
  
  
  41. 
  
  
  
  42. $shapes = [new Rectangle(), new Rectangle(), new Square()];
    43. 
  
  
  
  43. renderLargeRectangles($shapes); 
    44.

接口隔离原则

接口隔离原则："客户端不应该被强制去实现于它不需要的接口"。

有一个清晰的例子来说明示范这条原则。当一个类需要一个大量的设置项，为了方便不会要求客户端去设置大量的选项，因为在通常他们不需要所有的设置项。使设置项可选有助于我们避免产生"胖接口"

Bad:

 
 
 
    
  
  
  
  1. interface Employee{    
    2. 
  
  
  
  2.     public function work();    
    3. 
  
  
  
  3.     public function eat();
    4. 
  
  
  
  4. }
    5. 
  
  
  
  5. class Human implements Employee{    
    6. 
  
  
  
  6.     public function work()
    7. 
  
  
  
  7.     {        // ....working
    8. 
  
  
  
  8.     }    
    9. 
  
  
  
  9.     public function eat()
    10. 
  
  
  
  10.     {        // ...... eating in lunch break
    11. 
  
  
  
  11.     }
    12. 
  
  
  
  12. }class Robot implements Employee{    
    13. 
  
  
  
  13.     public function work()
    14. 
  
  
  
  14.     {        //.... working much more
    15. 
  
  
  
  15.     }    
    16. 
  
  
  
  16.     public function eat()
    17. 
  
  
  
  17.     {        //.... robot can't eat, but it must implement this method
    18. 
  
  
  
  18.     }
    19. 
  
  
  
  19. } 
    20.

上面的代码中，Robot类并不需要eat()这个方法，但是实现了Emplyee接口，于是只能实现所有的方法了，这使得Robot实现了它并不需要的方法。所以在这里应该对Emplyee接口进行拆分，正确的代码如下：

Good:

 
 
 
    
  
  
  
  1. interface Workable{    
    2. 
  
  
  
  2.     public function work();
    3. 
  
  
  
  3. }
    4. 
  
  
  
  4. interface Feedable{    
    5. 
  
  
  
  5.     public function eat();
    6. 
  
  
  
  6. }
    7. 
  
  
  
  7. interface Employee extends Feedable, Workable{
    8. 
  
  
  
  8. }
    9. 
  
  
  
  9. class Human implements Employee{    
    10. 
  
  
  
  10.     public function work()
    11. 
  
  
  
  11.     {        // ....working
    12. 
  
  
  
  12.     }    
    13. 
  
  
  
  13.     public function eat()
    14. 
  
  
  
  14.     {        //.... eating in lunch break
    15. 
  
  
  
  15.     }
    16. 
  
  
  
  16. }// robot can only work
    17. 
  
  
  
  17. 
  
  
  
  18. class Robot implements Workable{    
    19. 
  
  
  
  19.     public function work()
    20. 
  
  
  
  20.     {        // ....working
    21. 
  
  
  
  21.     }
    22. 
  
  
  
  22. } 
    23.

依赖反转原则 Dependency Inversion Principle (DIP)

这条原则说明两个基本的要点：

  • 高阶的模块不应该依赖低阶的模块，它们都应该依赖于抽象
  • 抽象不应该依赖于实现，实现应该依赖于抽象

这条起初看起来有点晦涩难懂，但是如果你使用过php框架(例如 Symfony)，你应该见过依赖注入(DI)对这个概念的实现。虽然它们不是完全相通的概念，依赖倒置原则使高阶模块与低阶模块的实现细节和创建分离。可以使用依赖注入(DI)这种方式来实现它。更多的好处是它使模块之间解耦。耦合会导致你难于重构，它是一种非常糟糕的的开发模式。

Bad:

 
 
 
    
  
  
  
  1. class Employee{    
    2. 
  
  
  
  2.     public function work()
    3. 
  
  
  
  3.     {        // ....working
    4. 
  
  
  
  4.     }
    5. 
  
  
  
  5. }
    6. 
  
  
  
  6. class Robot extends Employee{    
    7. 
  
  
  
  7.     public function work()    {        //.... working much more
    8. 
  
  
  
  8.     }
    9. 
  
  
  
  9. }
    10. 
  
  
  
  10. class Manager{    
    11. 
  
  
  
  11.     private $employee;   
    12. 
  
  
  
  12.     public function __construct(Employee $employee)
    13. 
  
  
  
  13.     {        $this->employee = $employee;
    14. 
  
  
  
  14.     }    public function manage()
    15. 
  
  
  
  15.     {        $this->employee->work();
    16. 
  
  
  
  16.     }
    17. 
  
  
  
  17. } 
    18.

Good:

 
 
 
    
  
  
  
  1. interface Employee{   
    2. 
  
  
  
  2.  public function work();
    3. 
  
  
  
  3. }
    4. 
  
  
  
  4.  class Human implements Employee{   
    5. 
  
  
  
  5. public function work()
    6. 
  
  
  
  6.     {        // ....working
    7. 
  
  
  
  7.     }
    8. 
  
  
  
  8. }
    9. 
  
  
  
  9. class Robot implements Employee{    
    10. 
  
  
  
  10. public function work()
    11. 
  
  
  
  11.     {        //.... working much more
    12. 
  
  
  
  12.     }
    13. 
  
  
  
  13. }
    14. 
  
  
  
  14. class Manager{    
    15. 
  
  
  
  15. private $employee;    
    16. 
  
  
  
  16. public function __construct(Employee $employee)
    17. 
  
  
  
  17.     {        $this->employee = $employee;
    18. 
  
  
  
  18.     }    public function manage()
    19. 
  
  
  
  19.     {        $this->employee->work();
    20. 
  
  
  
  20.     }
    21. 
  
  
  
  21. } 
    22.

别写重复代码 (DRY)

这条原则大家应该都是比较熟悉了。

尽你***的努力去避免复制代码，它是一种非常糟糕的行为，复制代码通常意味着当你需要变更一些逻辑时，你需要修改不止一处。

Bad:

 
 
 
    
  
  
  
  1. function showDeveloperList($developers){    
    2. 
  
  
  
  2. foreach ($developers as $developer) {
    3. 
  
  
  
  3.         $expectedSalary = 
    4. 
  
  
  
  4. $developer->calculateExpectedSalary();
    5. 
  
  
  
  5.         $experience = $developer->getExperience();
    6. 
  
  
  
  6.         $githubLink = $developer->getGithubLink();
    7. 
  
  
  
  7.         $data = [
    8. 
  
  
  
  8.             $expectedSalary,
    9. 
  
  
  
  9.             $experience,
    10. 
  
  
  
  10.             $githubLink
    11. 
  
  
  
  11.         ];
    12. 
  
  
  
  12. 
  
  
  
  13.         render($data);
    14. 
  
  
  
  14.     }
    15. 
  
  
  
  15. }
    16. 
  
  
  
  16. function showManagerList($managers){    
    17. 
  
  
  
  17. foreach ($managers as $manager) {
    18. 
  
  
  
  18.         $expectedSalary = 
    19. 
  
  
  
  19. $manager->calculateExpectedSalary();
    20. 
  
  
  
  20.         $experience = $manager->getExperience();
    21. 
  
  
  
  21.         $githubLink = $manager->getGithubLink();
    22. 
  
  
  
  22.         $data = [
    23. 
  
  
  
  23.             $expectedSalary,
    24. 
  
  
  
  24.             $experience,
    25. 
  
  
  
  25.             $githubLink
    26. 
  
  
  
  26.         ];
    27. 
  
  
  
  27. 
  
  
  
  28.         render($data);
    29. 
  
  
  
  29.     }
    30. 
  
  
  
  30. } 
    31.

Good:

 
 
 
    
  
  
  
  1. function showList($employees){    
    2. 
  
  
  
  2. foreach ($employees as $employee) {
    3. 
  
  
  
  3.         $expectedSalary = 
    4. 
  
  
  
  4. $employee->calculateExpectedSalary();
    5. 
  
  
  
  5.         $experience = $employee->getExperience();
    6. 
  
  
  
  6.         $githubLink = $employee->getGithubLink();
    7. 
  
  
  
  7.         $data = [
    8. 
  
  
  
  8.             $expectedSalary,
    9. 
  
  
  
  9.             $experience,
    10. 
  
  
  
  10.             $githubLink
    11. 
  
  
  
  11.         ];
    12. 
  
  
  
  12. 
  
  
  
  13.         render($data);
    14. 
  
  
  
  14.     }
    15. 
  
  
  
  15. } 
    16.

Very good:

 
 
 
    
  
  
  
  1. function showList($employees){    foreach ($employees as $employee) {
    2. 
  
  
  
  2.         render([
    3. 
  
  
  
  3.             $employee->calculateExpectedSalary(),
    4. 
  
  
  
  4.             $employee->getExperience(),
    5. 
  
  
  
  5.             $employee->getGithubLink()
    6. 
  
  
  
  6.         ]);
    7. 
  
  
  
  7.     }
    8. 
  
  
  
  8. } 
    9.

后记：虽然OOP设计需要遵守如上原则，不过实际的代码设计一定要简单、简单、简单。在实际编码中要根据情况进行取舍，一味遵守原则，而不注重实际情况的话，可能会让你的代码变的难以理解!

当前名称：PHP代码简洁之道——SOLID原则
分享链接：http://www.shufengxianlan.com/qtweb/news42/540992.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

面包屑导航知识

同城分类信息

手机app　　 　公路钻孔机　　 　中国电信西部信息中心机房　　 　成都网站推广　　 　营销型网站　　 　崇州网站建设　　 　成都商城网站制作　　 　成都移动服务器托管　　 　微信开发　　 　四川网站建设　　 　娄底尾呼妄服装　　 　小谭建站工作室　　 　服务器托管　　 　网站制作公司　　 　成都网站推广　　 　成都橡塑保温板　　 　外贸网站建设　　 　三台网站建设　　 　成都主机租用　　 　中建建业环保