PHP 设计模式实例

设计模式实例：

Singleton（单例）表示类只能实例化一次，生成一个全局状态且单一的根对象 ,利用单例模式可以配置应用程序并定义应用程序中可能随时访问你的变量，缺点在于该对象没有封装任何系统功能，多数情况下使应用程序的单元测试和调试变得更加困难

<?php
class SingletonClass {
    public static function getInstance(){
        static $instance = null;
        if($instance == null){
            $instance = new SingletoClass();
        }
        return $instance;
    }
}
$singletion = SingletonClass::getInstance();
?>

Multiton（多例）表示类可以多次实例化，对于给定的关键值只会存在唯一的对象实力，这样做可以节省内存，同时确保同一个对象的多个实例不会发生冲突

<?php 
class MultitonClass { 
    public static function getInstance($key){ 
        static $instance = array() 
        if(!array_key_exists($key,$instance)){
            $instance[$key] = new  MultitonClass();
        }
        return $instance[$key];
    } 
}
$multion = MultitonClass::getInstance("cms"); 
?>

Proxy（代理）表示所有的成员方法和变量都来源于目标类，代理模式能够对他所传递的数据进行修改和检查，也可用来记录访问信息，通过代理模式可以实现不同系统的接口调用

<?php 
class ProxyClass {
    private $target;
    function  __construct($target){
        $this->target=$target;
    }
    function __log($line){
        error_log($line);
    }
    function __set($name,$value){
        $this->target->$name;
        $this->log("Setting value for $name:$value");
    }
    function __get($name){
        $value=$this->target->$name;
        $this->log("Getting value for $name:$value");
        return $value;
    }
    function __call($name,$arguments){
        $this->log("Calling method $name width：".impolde(",",$arguments));
        return call_user_func_array(array($this->target,$name),$arguments);
    }    
}

$object =new myClass();
$proxy = ProxyClass($object);
$proxy->myname();
?>

Facade（外观） 抽象化复杂的功能，将子系统处理各请求的细节委托成合适的责任，这样使应用程序无需了解了解子系统的存在，子系统也不需要外观者的存在

<?php
class FacadeClass {
    publice apiRequestJson($data){
        $verify = new Verify();
        if($verify->verifyData($data)){
            $result=$this->method($data);
            return json_decode($result);
        }9     }
}
?>

Decorator（装饰者） 表示对象实例化后，可以通过多个装饰者类来扩展实例化对象

<?php
abstract class abstractCar{
    publice abstract function getPrice(){}
}
class Car extends abstractCar｛
    private $price=16000;
    publice function  getPrice(){return $this->price;}
}
class CarDecorator extends abstractCar｛
    private $target;
    publice __constrauct(Car $target){$this->target=$target;}
    publice function getPrice(){return $this->target->price;}
}
class writeColor extends CarDecorator{
    publice function  getPrice (){return parent:: getPrice()+500;}
}
$car = new Car();
$writeCar =new writeColor($car);
$writeCar->getPrice();
?> 

Factory（工厂） 对象调用某一条件的方法时，工厂模式通过一定的判断条件来获取到子类的对象实例

<?php
abstract class Factory{
    public static function getFactory($type){
        swith($tyle){
            case 1 : return new userFartory();break;
            case 2 : return new adminFartory();break;
        }
    }
}
class userFartory extends userFartory{}
class userFartory extends adminFartory{}
$userFactory= $factory::getFactory(1);
$adminFactory= $factory::getFactory(2);
?>

Observer Pattern（观察者模式） 当发布者Publisher对象生成事件后，发布者立刻通知所有观察者，观察者必须掌握广播了它的监听事件的对象

<?php
interface Obsercer{
    publice function notify($event);
}
class ObservableObject{
    private $observers=array();
    publice function observer(Observer $observer){
        $this->observers[]=$observer;
    }
    publice function dispath($event){
        foreach ($this->observers as $observer){
            $observer->notify($event);
        }
    }
}
?>

Publisher/subscriber（发布者/订阅者）当应用程序在何时何处触发时，观察者都将订阅到事件的通知，而不是仅观察到某个类所生成的事件，往往事件本身充当控制器

<?php
interface Obsercer{
    publice function notify($event);
}
class BroadcastingEvent{
    private static $observers=array();
    publice static function subscribe(Observer $observer){
        self::observers[]=$observer;
    }
    publice function publish(){
        foreach (self::observers as $observer){
            $observer->notify($this);
        }
    }
}
?>