PHP常用设计模式

一、单例模式

 确保一个类只有一个实例

特点：

• 三私一公：私有静态属性（存放实例）、私有构造方法（防止创建实例）、私有克隆方法（防止克隆对象）、公有静态方法（对外提供实例）
• 一个类只有一个实例
• 必须自行创建这个实例
• 自行像整个系统提供这个实例

应用场景：避免大量new操作消耗资源，减少数据库连接

<?php
/**
  * 设计模式之单例模式
  * $_instance必须声明为静态的私有变量
  * 构造函数必须声明为私有,防止外部程序new类从而失去单例模式的意义
  * getInstance()方法必须设置为公有的,必须调用此方法以返回实例的一个引用
  * ::操作符只能访问静态变量和静态函数
  * new对象都会消耗内存
  * 使用场景:最常用的地方是数据库连接。
  * 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。
  */
class main{
    
    //保存实例在此属性中
    private static $_instance;

    //构造方法设置为private，防止直接创建对象
    private function __construct(){
        
    }
    
    //防止用户复制对象实例
    private function __clone(){
        trigger_error('Clone is not allow',E_USER_ERROR);
    }
    
    //单例方法
    public static function get_instance(){
        if(!isset(self::$_instance)){
            self::$_instance = new self();
        }
        return self::$_instance;
    }
    
    function test(){
        echo "test";
    }
}

//实例单例对象
$test = main::get_instance();
$test->test();
?>

二、简单工厂模式

 特点：将调用对象和创建对象分离，调用者直接向工厂请求，减少代码耦合，提高系统的可维护性和可扩展性。

应用场景：提供一种类，具有为你创建对象的某些方法，这样就可以使用工厂创建对象，而不是直接使用new，这样如果想更改创建对象类型直接更改工厂即可。

<?php
/**
 * 定义抽象类，让子类继承实现它
 */
abstract class Operation{
    abstract function getValue($num1,$num2);
}
/**
 * 加法类
 */
class OperationAdd extends Operation{
    function getValue($num1,$num2){
        return $num1+$num2;
    }
}
/**
 * 减法类
 */
class OperationSub extends Operation{
    function getValue($num1,$num2){
        return $num1-$num2;
    }
}
/**
 * 定义工厂类，为了创建对象
 */
class Factory{
    public static function createObj($operate){
        switch($operate){
            case '+':
                return new OperationAdd();
                break;
            case '-':
                return new OperationSub();
                break;
        }
    }
}
//创建对象
$test = Factory::createObj('+');
echo $test->getValue(1,2);

?>

三、观察者模式

特点：当一个对象放生变化时，依赖他的对象全部会收到通知，并自动更新，观察者模式实现了低耦合，非侵入式的通知与更新机制。

应用场景：一个事件发生后，会执行一连串更新操作。传统的编程方式，就是在事件的代码之后直接加入处理逻辑，当更新的逻辑增多后，代码会变得难以维护。这种方式是耦合的，侵入式的。增加新的逻辑需要修改事件的主题体码。

<?php
/**
 * 主题接口
 */
interface subject{
    public function register(observer $observer);
    public function notify();
}
/**
 * 观察者接口
 */
interface observer{
    public function watch();
}

/**
 * 主题
 */
class action implements subject{
    public $_observers = [];
    function register(observer $observer){
        $this->_observers[] = $observer;
    }
    function notify(){
        foreach($this->_observers as $observer){
            $observer->watch();
        }
    }
}
/** 
 * 观察者
 */
class cat implements observer{
    function watch(){
        echo "cat watches TV<br />";
    }
}
class dog implements observer{
    function watch(){
        echo "dog watches TV<br />";
    }
}

//调用实例
$action = new action();
$action->register(new cat());
$action->register(new dog());
$action->notify();

?>

四、策略模式

定义一系列算法，将每个算法封装起来，并让他们相互交替，策略模式让算法独立于使用它的客户而改变。

特点：策略模式提供了管理相关的算法族的办法，策略模式提供了可以替换继承关系的办法，使用策略模式可以避免使用多重条件转移语句。

应用场景：多个类之区别在行为表现不同，在运行时动态选择具体要执行的行为，比如上学，有多种策略：走路、公交、地铁

<?php
/**
 * 定义策略抽象类，让子类继承并实现它
 */
abstract class Strategy{
    abstract function goSchool();
}

/**
 *实现接口
 */
class run extends Strategy{
    function goSchool(){
        echo "走路去学校<br />";
    }
}
class subway extends Strategy{
    function goSchool(){
        echo "坐地铁去学校<br />";
    }
}
class bike extends Strategy{
    function goSchool(){
        echo "骑自行车去学校< br />";
    }
}

/**
 * 主类
 */
class main{
    protected $_stratege;
    function goSchool($stratege){
        $this->_stratege = $stratege;
        $this->_stratege->goSchool();
    }
}

//调用
$main = new main();
$run = new run();
$main->goSchool($run);
?>