PHP面向对象设计的五大原则

面向对象设计的五大原则：单一职责原则、接口隔离原则、开放-封闭原则、替换原则、依赖倒置原则。这些原则主要是由Robert C.Martin在《敏捷软件开发——原则、方法、与实践》一书中总结出来，这五大原则也是23种设计模式的基础。

单一职责原则 Single Pesponsibility Principle, SRP

在MVC框架中，对于表单插入数据库字段过滤与安全检查应该是放在control层处理还是model层处理，这类问题都可以归到单一职责的范围。

单一职责有两个含义：

1. 避免相同的职责分散到不同的类中
2. 一个类承担太多职责

遵守SRP的好处：

1. 减少类之间的耦合
2. 提高类的复用性

在实际代码开发中的应用：工厂模式、命令模式、代理模式等。
工厂模式（Factory）允许在代码执行时实例化对象。之所以被称为工厂模式是因为它负责“生产”对象。以数据库为例，工厂需要的就是根据不同的参数，生成不同的实例化对象。它只负责生产对象，而不负责对象的具体内容。

定义一个适配器接口：

<?php
interface DbAdapter 
{
    /**
    * 数据库连接
    * @param $config 数据库配置
    * @return resource
    */
    public function connect($config);
    
    /**
    * 执行数据库查询
    * @param string $query 数据库查询SQL字符串
    * @param mixed $handle 连接对象
    * @return resource
    */
    public function query($query, $handle);
}
?>

定义MySQL数据库操作类：

<?php
class DbAdapterMysql implements DbAdapter
{
    private $_dbLink; //数据库连接字符串表示

    /**
    * 数据库连接函数
    * @param $config 数据库配置
    * @throws DbException
    * @return resource
    */
    public function connect($config)
    {
        if($this->_dbLink = @mysql_connect($config->host .
            (empty($config->port) ? '' : ':' . $config->port),
        $config->user, $config->password, true)) {
            if(@mysql_select_db($config->database, $this->_dbLink)){
                if($config->charset){
                    mysql_query("SET NAMES '{$config->charset}'", $this->_dbLink);
                }
                return $this->_dbLink;
            }
        }
        //数据库异常
        throw new DbException(@mysql_error($this->_dbLink));
    }
    
    /**
    * 执行数据库查询
    * @param string $query 数据库查询SQL字符串
    * @param mixed $handle 连接对象
    * @return resource
    */
    public function query($query, $handle)
    {
        if ($resource = @mysql_query($query, $handle)) {
            return $resource;
        }
    }
}
?>

SQLite数据库操作类：

<?php
class DbAdapterSqlite implements DbAdapter
{
    private $_dbLink;
    
    /**
    * 数据库连接函数
    * @param $config 数据库配置
    * @throws DbException
    * @return resource
    */
    public function connect($config)
    {
        if ($this->_dbLink = sqlite_open($config->file, 0666, $error)) {
            return $this->_dbLink;
        }
        
        throw new DbException($error);
    }
    
    /**
    * 执行数据库查询
    * @param string $query 数据库查询SQL字符串
    * @param mixed $handle 连接对象
    * @return resource
    */
    public function query($query, $handle)
    {
        if ($resource = @sqlite_query($query, $handle)) {
            return $resource;
        }
    }
}
?>

定义一个工厂类，根据传入不同的参数生成需要的类：

<?php
    class sqlFactory
    {
        public static function factory($type)
        {
            if (include_once 'Drivers/' . $type . '.php') {
                $classname = 'DbAdapter' . $type;
                return new $classname;
            } else {
                throw new Exception('Driver not found');
            }
        }
    }
?>

调用：

$db = sqlFactory::factory('MySQL');
$db = sqlFactory::factory('SQLite');

命令模式分离“命令的请求者”和“命令的实现者”方面的职责。

<?php
/**
* 厨师类，命令接受者与执行者
*/
class cook 
{
    public function meal(){
        echo '番茄炒鸡蛋',PHP_EOL;
    }
    
    public function drink(){
        echo '紫菜蛋花汤',PHP_EOL;
    }
    
    public function ok(){
        echo '完毕',PHP_EOL;
    }
}

/**
* 命令接口
*/
interface Command{
    public function execute();
}
?>

模拟服务员与厨师的过程：

<?php
class MealCommand implements Command
{
    private $cook;
    
    //绑定命令接受者
    public function __construct(cook $cook){
        $this->cook = $cook;
    }
    
    public function execute(){
        $this->cook->meal();//把消息传递给厨师，让厨师做饭
    }
}

class DrinkCommand implements Command
{
    private $cook;
    
    //绑定命令接受者
    public function __construct(cook $cook){
        $this->cook = $cook;
    }
    
    public function execute(){
        $this->cook->drink();
    }
}
?>

模拟顾客与服务员的过程：

<?php
class cookControl
{
    private $mealCommand;
    private $drinkCommand;
    
    //将命令发送者绑定到命令接收器
    public function addCommand(Command $mealCommand, Command $drinkCommand){
        $this->mealCommand = $mealCommand;
        $this->drinkCommand = $drinkCommand;
    }
    
    public function callMeal(){
        $this->mealCommand->execute();
    }
    
    public function callDrink(){
        $this->drinkCommand->execute();
    }
}    
?>

实现命令模式：

$control = new cookControl;
$cook = new cook;
$mealCommand = new MealCommand($cook);
$drinkCommand = new DrinkCommand($cook);
$control->addCommand($mealCommand, $drinkCommand);
$control->callMeal();
$control->callDrink();

接口隔离原则 Interface Segregation Principle,ISP
接口隔离原则（Interface Segregation Principle,ISP）表明客户端不应该被强迫实现一些不会使用的接口，应该把胖接口分组，用多个接口代替它，每个接口服务于一个子模块。简单地说，就是使用多个专门的接口比使用单个接口要好很多。
ISP主要观点：
1.一个类对另外一个类的依赖性应当是建立在最小接口上的。
ISP可以达到不强迫客户（接口使用者）依赖于他们不用的方法，接口的实现类应该只呈现为单一职责的角色（遵守SRP原则）。
ISP可以降低客户之间的相互影响——当某个客户程序要求提供新的职责（需求变化）而迫使接口发生变化时，影响到其他客户程序的可能性会最小。
2.客户端程序不应该依赖它不需要的接口方法（功能）。

ISP强调的是接口对客户端的承诺越少越好，并且要做到专一。
接口污染就是为接口添加不必要的职责。“接口隔离”其实就是定制化服务设计的原则。使用接口的多重继承实现对不同的接口的组合，从而对外提供组合功能——达到“按需提供服务”。

对于接口的污染，使用下面两种处理方式：

• 利用委托分离接口。
• 利用多继承分离接口。

委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理，如策略模式、代理模式等都应用到了委托的概念。

开放-封闭原则
随着软件系统的规模不断增大，软件系统的维护和修改的复杂性不断提高，这种困境促使法国工程院士Bertrand Meyer在1998年提出了“开放-封闭”（Open-Close Principle, OCP）原则，基本思想是：
Open(Open for extension)模块的行为必须是开放的、支持扩展的，而不是僵化的。
Closed(Closed for modification)在对模块的功能进行扩展时，不应该影响或大规模地影响已有的程序模块。

换句话说，也就是要求开发人员在不修改系统中现有功能代码（源代码或二进制代码）的前提下，实现对应用系统的软件功能的扩展。用一句话概括就是：一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。
开放-封闭能够提高系统的可扩展性和可维护性，但这也是相对的。
以播放器为例，先定义一个抽象的接口：

interface Process
{
    public function process();
}

然后对此接口进行扩展，实现解码和输出的功能：

class playerEncode implements Proess
{
    public function process(){
        echo "encode\r\n";
    }
}    

class playerOutput implements Process
{
    public function process(){
        echo "output\r\n";
    }
}

对于播放器的各种功能，这里是开放的。只要你遵守约定，实现了process接口，就能给播放器添加新的功能模块。
接下来为定义播放器的线程调度管理器，播放器一旦接收到通知（可以是外部单击行为，也可以是内部的notify行为），将回调实际的线程处理：

class playProcess
{
    private $message = null;
    public function __construct(){
    }
    
    public function callback(Event $event){
        $this->message = $event->click();
        if($this->message instanceof Process){
            $this->message->process();
        }
    }
}

具体的产品出来了，在这里定义一个MP4类，这个类是相对封闭的，其中定义事件的处理逻辑：

class MP4
{
    public function work(){
        $playProcess = new playProcess();
        $playProcess->callback(new Event('encode'));
        $playProcess->callback(new Event('output'));
    }
}

最后为事件分拣的处理类，此类负责对事件进行分拣，判断用户或内部行为，以产生正确的“线程”，供播放器内置的线程管理器调度：

class Event
{
    private $m;
    
    public function __construct($me){
        $this->m = $me;
    }
    
    public function click(){
        switch($this->m){
            case 'encode':
                return new playerEncode();
                break;
            case 'output':
                return new playerOutput();
                break;    
        }
    }
}

运行：

$mp4 = new MP4;
$mp4->work();
//打印结果
encode
output

如何遵守开放-封闭原则
实现开放-封闭的核心思想就是抽象编程的核心思想就是对抽象编程，而不是对具体编程，因为抽象相对稳定。让类依赖于固定的抽象，这样的修改就是封闭的；而通过面向对象的继承和多态机制，可以实现对抽象体的继承，通过覆写其方法来改变固有的行为，实现新的扩展方法，所以对于扩展就是开放的。
1.在设计方面充分应用“抽象”和封装的思想。
一方面就是要在软件系统中找出各种可能的“可变因素”，并将之封装起来；另一方面，一种可变性因素不应当散落在多个不同代码模块中，而应当被封装到一个对象中。
2.在系统功能编程实现方面应用面向接口编程。
当需求发生变化时，可以提供该接口新的实现类，以求适应变化。
面向接口编程要求功能类实现接口，对象声明为接口类型。再设计模式中，装饰模式比较明显地用到OCP。

替换原则
替换原则也称里氏替换原则（Liskov Substitution Principle, LSP）的定义和主要思想如下：由于面向对象编程技术中的继承在具体的编程中过于简单，在许多系统的设计和编程实现中，我们并没有认真地、理性地思考应用系统中各个类之间的继承关系是否合适，派生类是否能正确地对其基类中的某些方法进行重写等问题。因此经常出现滥用继承或者错误地进行了继承等现象，给系统的后期维护带来不少麻烦。
LSP指出：子类型必须能够替换掉它们的父类型，并出现在父类能够出现的任何地方。
LSP主要是针对继承的设计原则，继承与派生（多态）是OOP的主要特性。
如何遵守LSP设计原则：

• 父类的方法都要在子类中实现或重写，并且派生类只实现其抽象类中声明的方法，而不应当给出多余的方法定义或实现。

在客户段程序中只应该使用父类对象而不应当直接使用子类对象，这样可以实现运行期绑定（动态绑定）。
如果A、B两个类违反了LSP的设计，通常的做法是创建一个新的抽象类C，作为两个具体类的超类，将A和B的共同行为移到C中，从而解决A和B行为不完全一致的问题。

依赖倒置原则 Dependence Inversion Principle, DIP
依赖倒置简单地讲就是将依赖关系倒置为依赖接口，具体概念如下：

• 上层模块不应该依赖于下层模块，它们共同依赖于一个抽象（父类不能依赖子类，它们都要依赖抽象类）。
• 抽象不能依赖于具体，具体应该依赖于抽象。

为什么要依赖接口？因为接口体现对问题的抽象，同时由于抽象一般是相对稳定的或者是相对变化不频繁的，而具体是易变的。因此，依赖抽象是实现代码扩展和运行期内绑定（多态）的基础：只要实现了该抽象类的子类，都可以被类的使用者使用。

<?php
interface employee
{
    public function working();
}

class teacher implements employee
{
    public function working(){
        echo 'teaching...';
    }
}

class coder implements employee
{
    public function working(){
        echo 'coding...';
    }
}

class workA
{
    public function work(){
        $teacher = new teacher;
        $teacher->working();
    }
}

class workB
{
    private $e;
    public function set(employee $e){
        $this->e = $e;
    }
    
    public function work(){
        $this->e->working();
    }
}

$worka = new workA;
$worka->work();
$workb = new workB;
$workb->set(new teacher());
$workb->work();

在workA中，work方法依赖于teacher实现；在workB中，work转而依赖于抽象，这样可以把需要的对象通过参数传入。
在workB中，teacher实例通过setter方法传入，从而实现了工厂模式。由于这样的是实现是硬编码的，为了实现代码的进一步扩展，把这个依赖关系写在配置文件里，指明workB需要一个teacher对象，专门由一个程序检测配置是否正确（如所依赖的类文件是否存在）以及加载配置中所依赖的实现，这个检测程序，就称为IOC容器。
IOC（Inversion Of Control）是依赖倒置原则（Dependence Inversion Principle, DIP）的同义词。依赖注入（DI）和依赖查找（DS）是IOC的两种实现。