PHP常用的设计模式基本有四种

PHP常用的设计模式基本有四种: 单例模式、工厂模式、观察者模式、策略模式； 随着一些框架涌入市面，PHP程序员写程序越来越模板化，甚至有2~3年经验的开发者也说不清这几种设计模式的作用以及应用场景。这里简单说明一下：

单例模式
class Single{

    private static $obj;
    public  $redis;

    private function __construct(){
        $this->redis=new redis();
        $this->redis->connect("127.0.0.1","6379");
    }

    public static function door(){

        if( !is_object(self::$obj) ){
            self::$obj=new self();
        }
        return self::$obj;
    }

    public function init(){

        echo '初始化';
    }

    public function __clone(){
        exit('禁止clone');
    }
}

$obj=Single::door();
$obj->redis->set('aa',111);
echo $obj->redis->get('aa');

结论: 防止对象重复实例化

工厂模式例子:

    interface Home{
        function GrandParents();
        function Parents();
        function Children();
    }

    class ZhangSanHome implements Home
    {
        function GrandParents(){
            return __CLASS__.':'.__METHOD__;
        }
        function Parents(){
            return __CLASS__.':'.__METHOD__;
        }
        function Children(){
            return __CLASS__.':'.__METHOD__;
        }
    }
    class LisiHome implements Home
    {
        function GrandParents(){
            return __CLASS__.':'.__METHOD__;
        }
        function Parents(){
            return __CLASS__.':'.__METHOD__;
        }
        function Children(){
            return __CLASS__.':'.__METHOD__;
        }
    }
    $zs=new ZhangSanHome();
    echo $zs->GrandParents();echo '<br>';
    echo $zs->Parents();echo '<br>';
    echo $zs->Children();echo '<br>';
    $ls=new LisiHome();
    echo $ls->GrandParents();echo '<br>';
    echo $ls->Parents();echo '<br>';
    echo $ls->Children();

结论:面向对象的规范化，使用场景，像是一个模型，抽出共性，差别分别实现

观察者模式：

    interface Observer {
            function update($args);
    }

    interface Object {
            function addObserver($new_observer);            
            function delObserver($old_observer);    
            function notify($args);
    }
    //观测对象
    class Obs implements Object {
            protected $observer=[];

            function addObserver($new_observer){
                    $this->observer[]=$new_observer;
            }
            function delObserver($old_observer){

            }
            function notify($args){
                    foreach ($this->observer as $o) {
                        $o->update($args);
                    }
            }

    }
  //观察者1
  class ObserverOne implements Observer
  {
          function update($args){
                  echo $args.':'.__CLASS__.'<br>';
          }
  }
  //观察者2
  class ObserverTwo implements Observer
  {
          function update($args){
                  echo $args.':'.__CLASS__.'<br>';
          }
  }
  //观察者3
  class ObserverThree implements Observer
  {
          function update($args){
                  echo $args.':'.__CLASS__.'<br>';
          }
  }

    $ob=new Obs();
    $ob->addObserver( new ObserverOne() );
    $ob->addObserver( new ObserverTwo() );
    $ob->addObserver( new ObserverThree() );
    $ob->notify('已修改完成,通知观察者');

结论: 将对象存入数组,每个对象都有一个相同名称的方法(update),操作完成后,通知数组中所有的对象。

策略模式:

interface Weapon {
    function fire();
}
interface Equipment {
    function ready($weapon);
    function attack();
}
class Gun implements Weapon {
    function fire(){
        echo 'gun is firing..<br>';        
    }
}
class Cannon implements Weapon {
    function fire(){
        echo 'Cannon is firing..<br>';
    }
}
class MyEquipment implements Equipment {
    protected $_equipment;
    function ready($weapon){
        $this->_equipment=$weapon;
    }
    function attack(){
        $this->_equipment->fire();
    }
}
$equipment=new MyEquipment();
$equipment->ready(new Gun());
$equipment->attack();

$equipment->ready(new Cannon());
$equipment->attack();

结论: 将A类对象作为参数传入B类,通过B类执行A类的方法,一般用作配置加载,不同配置不同执行方式