PHP常用设计模式一

1.单例模式

单例模式顾名思义，就是只有一个实例。作为对象的创建模式， 单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

个人理解：相当于多次调用这个类的时候，类本身会实例化，然后获得这个实例的结果，后面多次调用都是获取第一次获取的实例。常用余数据库连接

特点 
一是某个类只能有一个实例；
二是它必须自行创建这个实例；
三是它必须自行向整个系统提供这个实例。

class Single
{
    private static $_instance;
    private static $db;
    //构造函数声明为private,防止直接创建对象
    private function __construct(){
        self::$db = "被实例化了".rand(1,999999);
    }
    private function __clone(){
        trigger_error('Clone is not allow' ,E_USER_ERROR);
    }
    public static function getInstance()
    {
        var_dump(isset(self::$_instance));
        var_dump(self::$db);
        if(!isset(self::$_instance)){//如果已经new 实例化过，直接返回实例化的结果。
            self::$_instance = new Single();
        }
        return self::$_instance;
    }

    function test(){
        echo 'test'.rand(1,999999);
    }
}

//$sign = new Single(); //报错 因为__construct 为私有
$n1 =   Single::getInstance();
$n1 = Single::getInstance();
$n1 = Single::getInstance();
$n1->test();
$n1->test();
$n1->test();
//clone $n1;
//bool(false)
//被实例化了
//bool(true)
//第一次被实例化之后 后续不再被实例化

2.工厂模式

连接数据库 可以用多种方式

理解： 工厂模式 ， 比如我告诉工厂，我想要一辆汽车，我只care汽车，不care汽车的来源，或者制造方式。（本例中，我只需要使用mysql，而mysql连接的实现过程，我不在意）

class mysql
{
    //这里使用单例
    private static $_instance;
    private function __clone(){}
    private function __construct()
    {
        echo "我正在使用mysql";
    }

    public static function getInstance(){
        if(!isset(self::$_instance)){
            self::$_instance = new mysql();
        }
        return self::$_instance;
    }
}
class sqlserver
{

}
class oracle
{

}
class Database
{
    public static function getInstance($newclass)
    {
        $class = $newclass;//真实项目中这里常常是用来解析路由，加载文件。
        return $class::getInstance();
    }
}
//定义每个类的类名
const A = 'mysql';
const B = 'sqlserver';
const C = 'oracle';
//调用方法：
$return = Database::getInstance('mysql');
var_dump($return);

3.注册树模式

注册树模式通过将对象实例注册到一棵全局的对象树上，需要的时候从对象树上采摘的模式设计方法

class mysql
{
    //这里使用单例
    private static $_instance;
    private function __clone(){}
    private function __construct()
    {
        echo "我正在使用mysql";
    }

    public static function getInstance(){
        if(!isset(self::$_instance)){
            self::$_instance = new mysql();
        }
        return self::$_instance;
    }
}
class sqlserver
{

}
class oracle
{

}
class Database
{
    public static function getInstance($newclass)
    {
        $class = $newclass;//真实项目中这里常常是用来解析路由，加载文件。
        return $class::getInstance();
    }
}

class Register{
    protected static $obj;
    public static function set($name,$obj){
        self::$obj[$name] = $obj;
    }
    public static function get($name){
        return self::$obj[$name];
    }
    public static function _unset($name){
        unset(self::$obj[$name]);
    }
}

//定义每个类的类名
const A = 'mysql';
const B = 'sqlserver';
const C = 'oracle';
//调用注册
Register::set('mysqldb',Database::getInstance(A));
$db = Register::get('mysqldb');
var_dump($db);

4.策略模式

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

理解： 比如我在高德导航上导航家到公司，出行方式有，打车，公交地铁，骑行，步行等方式，这些方式就是以到公司为目的的策略，策略可以变化。

//构建策略 去公司
abstract class Stratrgy{
    abstract function goCompany();
}

//坐地铁地铁
class Subway extends Stratrgy
{
    public function goCompany()
    {
        // TODO: Implement goCompany() method.
        echo 'subway';
    }
}

//打车
class Taxi extends Stratrgy
{
    public function goCompany()
    {
        // TODO: Implement goCompany() method.
        echo  'taxi';
    }
}

//定义抽象算法实现
class Obj
{
    protected $stratrgy;
    function __construct(Stratrgy $way)
    {
        $this->stratrgy = $way;
    }

    public function goCompany(){
        $this->stratrgy->goCompany();
    }
}

//现在打车去公司

$nowWay = new Taxi();
$s = new Obj($nowWay);
$s->goCompany();

5.观察者模式

理解： 一个事件产生后，这个事件会通知所有观察者，事件抽象出来，就是事件都通知所有观察者干XX事情。* 观察者和事件如果需要存在关联或者监听关系，需要一方主动，观察者模式中，事件产生后会注册观察者，然后通知他。

观察者模式(Observer)，当一个对象状态发生变化时，依赖它的对象全部会收到通知，并自动更新。观察者模式实现了低耦合，非侵入式的通知与更新机制。

interface Observer
{
    //吃饭
    public function eat();
}

interface Event
{
  public function register(Observer $observer); //注册观察者
  public function notify(); //通知观察者
}

//观察者zhangsan

class Zhangsan implements Observer{
    public function eat()
    {
        // TODO: Implement eat() method.
        echo '张三吃火锅';
    }
}

class Lisi implements Observer{
    public function eat()
    {
        // TODO: Implement eat() method.
        echo "李四吃烤鸭";
    }
}

class Eventeat implements Event{
    protected $_observer;
    public function register(Observer $observer)
    {
        // TODO: Implement register() method.
        $this->_observer[] = $observer;
    }

    public function notify()
    {
        // TODO: Implement notify() method.
        //通知每个观察者
        foreach ($this->_observer as $k=>$v){
            $v->eat();
        }
    }
}

//触发吃东西这个事件
$eat = new Eventeat();
//注册观察者
$eat->register(new Zhangsan());
$eat->register(new Lisi());
//通知张三
$eat->notify();