PHP設計模式的六大設計原則

１　簡介

　　軟體設計最大的難題就是應對需求的變化，但是紛繁複雜的需求變化卻是不可預料的．此時，我們可以通過六大設計原則良好的應對未來的變化．

２　講解

2.1　單一職責原則(Single Responsibility Principle)

一個類只負責一個職責

　　簡單的例子，用戶發送一個請求到伺服器，當我們所有的操作只用一個action類來完成

<?php 
$action = new action;
$action->getResp();
class action{
    public function getResp(){
        // １檢查路由
        // ２安全檢查
        // ３檢查緩存
        // ４查詢資料庫及返回
        // ５...
​
        echo 'hello world';
    }
}

那麼當需求業務比如安全檢查邏輯有變動時，我們都將修改這個類，繁瑣而沒有條理，極不容易維護．

若我們把路由－安全－緩存等都封裝成類，就僅在getResp()調用即可，簡單優雅．

2.2　開閉原則(Open Closed Principle)

一個軟體實體比如類－模塊－函數，應該對擴展開放，對修改關閉

　　小孩每天要做家庭作業

<?php 
class Child{
    public function doHomework( IHomework $homework ){
        $homework -> finHomework();
    }
}
 
interface IHomework{
    public function finHomework();
}
 
class Homework implements IHomework{
    private $work;
    public function __construct( $work ){    
        $this->work = $work;
    }
    public function getWork(){
        return $this->work;
    }
    public function finHomework(){
        echo "do homework : $this->work ".PHP_EOL.'<br/>';
    }
}
​
$xiaoming = new Child();
$xiaoming -> doHomework( new Homework('math') );

do homework : math 

　　突然有一天老實宣佈，臨近期中考試了，作業要做兩次．考完恢覆成做一次．倘若我們直接修改Homework類的finHomework函數，雖然可以解決問題，但是期中考試結束後又需要把函數改回來．最好的解決辦法就是利用開閉原則：

class HomeworkTwice extends Homework{
    public function __construct( $work ){    
        parent::__construct($work);
    }
    public function finHomework(){
        $work = parent::getWork();
        echo "do homework : ".$work." 1".PHP_EOL.'<br/>';
        echo "do homework : ".$work." 2".PHP_EOL.'<br/>';
    }
}
​
$xiaoming = new Child();
$xiaoming -> doHomework( new HomeworkTwice('math') );

do homework : math 1
do homework : math 2 

2.3　里氏替換原則(Liskov Substitution Principle)

所有引用基類的地方必須能透明地使用其子類的對象
​
子類必須完全實現父類的方法，可以拓展自己的方法和屬性．即子類可以擴展父類的功能，但不能改變父類原有的功能

　　我們設計了Mp4類，它具有聽歌和看視頻的功能．

interface IMp4{
    public function listenMusic();
    public function watchVedio();
}
​
class Mp4 implements IMp4{
    public function listenMusic(){
        echo ' listenMusic'.PHP_EOL.'<br/>';
    }
    public function watchVedio(){
        echo ' watchVedio'.PHP_EOL.'<br/>';
    }
}
​
class User1{
    public function litenM(IMp4 $mp4){
        echo 'user1';
        $mp4->listenMusic();
    }
    public function watchV(IMp4 $mp4){
        echo 'user1';
        $mp4->watchVedio();
    }
}
$user1 = new User1;
$mp4 = new Mp4;
$user1->litenM($mp4);
$user1->watchV($mp4);

user1 listenMusic
user1 watchVedio 

　　有一天我們要構建mp3的類，繼續依照mp4的介面來生成類的話，會發現播放視頻的功能用不了．

class Mp3 implements IMp4{
    public function listenMusic(){
        echo ' listenMusic'.PHP_EOL.'<br/>';
    }
    public function watchVedio(){
        //不能播放視頻
    }
}
$user1 = new User1;
$mp3 = new Mp3;
$user1->litenM($mp3);
$user1->watchV($mp3);

user1 listenMusic
user1 

此時我們可以構造IMp3介面來適應此種情況，我們還可以拓展處lookMini功能函數，符合里氏替換原則．

interface IMp3{
    public function listenMusic();
}
class Mp3 implements IMp3{
    public function listenMusic(){
        echo ' listenMusic'.PHP_EOL.'<br/>';
    }
    public function lookMini(){
        echo ' lookMini'.PHP_EOL.'<br/>';
    }
}

2.4　迪米特法則(Law of Demeter)

一個對象應該對其他對象保持最少的瞭解

　　系統判定英雄是否贏取lol游戲，需要觀察英雄完成三步：清理兵線－推塔－勝利．

class Hero{
    //清理兵線
    public function cleanLine(){
        echo ' killed little soldiers '.PHP_EOL.'<br/>'; 
        return true;
    }
    //推塔
    public function pushtower(){
        echo ' destroyed their towers '.PHP_EOL.'<br/>'; 
        return true;
    }
    //勝利
    public function vitory(){
        echo ' victory '.PHP_EOL.'<br/>'; 
    }
}
class system{
    public function judgeVictory(Hero $hero){
        if($hero->cleanLine()){
            if($hero->pushtower()){
                $hero->vitory();
            }
        }
    }
}
$system = new system;
$jax = new Hero;
$system->judgeVictory($jax);

killed little soldiers
destroyed their towers
victory

以上的Hero類中暴露了太多方法給system類，兩者的耦合關係異常牢固．以下設計方法可以解決此問題．

class Hero{
    //清理並線
    private function cleanLine(){
        echo ' killed little soldiers '.PHP_EOL.'<br/>'; 
        return true;
    }
    //推塔
    private function pushtower(){
        echo ' destroyed their towers '.PHP_EOL.'<br/>'; 
        return true;
    }
    //勝利
    private function vitory(){
        echo ' victory '.PHP_EOL.'<br/>'; 
    }
    //獲取勝利
    public function getVictory(){
        if($this->cleanLine()){
            if($this->pushtower()){
                $this->vitory();
            }
        }
    }
}
class player{
    public function playLol(Hero $hero){
        $hero->getVictory();
    }
}
$player = new player;
$jax = new Hero;
$player->playLol($jax);

2.5　介面隔離原則(INterface Segregation Principle)

類間的依賴應該建立在最小的介面上。

　　有兩個手機用戶，用戶１拿手機聽歌，用戶２拿手機打游戲接電話，場景實現如下：

interface IPhone{
    public function call();
    public function playGame();
    public function listenMusic();
}
class Phone1 implements IPhone{
    public function call(){
        echo 'Phone1 call'.PHP_EOL.'<br/>';
    }
    public function playGame(){
        echo 'Phone1 playGame'.PHP_EOL.'<br/>';
    }
    public function listenMusic(){
        echo 'Phone1 listenMusic'.PHP_EOL.'<br/>';
    }
}
class Phone2 implements IPhone{
    public function call(){
        echo 'Phone2 call'.PHP_EOL.'<br/>';
    }
    public function playGame(){
        echo 'Phone2 playGame'.PHP_EOL.'<br/>';
    }
    public function listenMusic(){
        echo 'Phone2 listenMusic'.PHP_EOL.'<br/>';
    }
}
class User1{
    public function litenM(IPhone $phone){
        echo 'user1 use ';
        $phone->listenMusic();
    }
}
class User2{
    public function playG(IPhone $phone){
        echo 'user2 use ';
        $phone->playGame();
    }
    public function call(IPhone $phone){
        echo 'user2 use ';
        $phone->call();
    }
}
$phone1 = new Phone1;
$user1 = new User1;
$user1->litenM($phone1);
​
$phone2 = new Phone2;
$user2 = new User2;
$user2->playG($phone2);
$user2->call($phone2);

　　我們發現，介面 IPhone 中出現的方法，不管依賴於它的類有沒有作用，實現類的時候都要實現這些方法．若我們依據介面隔離原則，便可以解決以上問題．

interface IlandlineTelephone{
    public function call();
}
interface IGameMachine{
    public function playGame();
}
interface IMp3{
    public function listenMusic();
}
/*interface IPhone extends IlandlineTelephone,IGameMachine,IMp3{
}*/
interface IPhone1 extends IMp3{
}
interface IPhone2 extends IlandlineTelephone,IGameMachine{
}
class Phone1 implements IPhone1{
    public function listenMusic(){
        echo 'Phone1 listenMusic'.PHP_EOL.'<br/>';
    }
}
class Phone2 implements IPhone2{
    public function call(){
        echo 'Phone2 call'.PHP_EOL.'<br/>';
    }
    public function playGame(){
        echo 'Phone2 playGame'.PHP_EOL.'<br/>';
    }
}
class User1{
    public function litenM(IPhone1 $phone){
        echo 'user1 use ';
        $phone->listenMusic();
    }
}
class User2{
    public function playG(IPhone2 $phone){
        echo 'user2 use ';
        $phone->playGame();
    }
    public function call(IPhone2 $phone){
        echo 'user2 use ';
        $phone->call();
    }
}
$phone1 = new Phone1;
$user1 = new User1;
$user1->litenM($phone1);
​
$phone2 = new Phone2;
$user2 = new User2;
$user2->playG($phone2);
$user2->call($phone2);

2.6　依賴倒置原則(Dependence Inversion Principle)

高層模塊不應該依賴低層模塊，二者都應該依賴其抽象；抽象不應該依賴細節；細節應該依賴抽象。

　　以下是用戶吃晚餐的場景：

class Rice{
    public function taste(){
        echo ' rice is delicious'.PHP_EOL.'<br/>'; 
    }
}
class User{
    public function haveDinner(Rice $rice){
        $rice->taste();
    }
}
$user = new User;
$rice = new Rice;
$user->haveDinner($rice);

soup is delicious 

但是如果我們不止吃米飯，還喝湯呢，發現Rice並不適用了。我們引入一個抽象的介面Ifood，代表讀物。讓Mother類與介面Ifood發生依賴關係，而Rice和Soup都屬於食物的範疇，讓他們各自都去實現IReader介面，這樣就符合高層不應該依賴低層，應該依賴於介面的依賴倒置原則，修改後代碼如下：

　　用戶吃完米飯後想要喝點湯，我們發現 haveDinner() 方法的依賴 Rice 不再適用．此時我們若依賴倒置，將haveDinner與更大範圍的Ifood進行依賴，而Rice 和 Soup 實現Ifood介面，就可以解決所述問題．

interface Ifood{
    public function taste();
}
class Rice implements Ifood{
    public function taste(){
        echo ' rice is delicious'.PHP_EOL.'<br/>'; 
    }
}
class Soup implements Ifood{
    public function taste(){
        echo ' soup is delicious'.PHP_EOL.'<br/>'; 
    }
}
class User{
    public function haveDinner(Ifood $food){
        $food->taste();
    }
}
$user = new User;
$rice = new Rice;
$soup = new Soup;
$user->haveDinner($rice);
$user->haveDinner($soup);

rice is delicious
soup is delicious 

３　結尾

　　六大設計原則的首字母聯合起來為SOLID－穩定的（兩個L合成一個）．使用六大設計原則，可以建立靈活健壯的系統．