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.     private $user;     
3.     public function __construct($user) 
4.     {         
5.         $this->user = $user; 
6.     }     
7.     public function changeSettings($settings) 
8.     {         
9.         if ($this->verifyCredentials()) {            
10.          // ... 
11.         } 
12.     }     
13.     private function verifyCredentials() 
14.     {         
15.     // ... 
16.     } 
17. }  

Good:

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

开闭原则 Open/Closed Principle (OCP)

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

Bad:

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

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

Good:

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

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

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

Bad:

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

Good:

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

接口隔离原则

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

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

Bad:

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

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

Good:

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

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

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

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

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

Bad:

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

Good:

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

别写重复代码 (DRY)

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

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

Bad:

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

Good:

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

Very good:

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

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

原文发布时间为：2017-10-24

本文作者：佚名

本文来自云栖社区合作伙伴“51CTO”，了解相关信息可以关注。