php设计模式

1、常见的设计模式：单例模式、工厂模式、观察者模式

工厂模式：

工厂模式，工厂方法或者类生成对象，而不是在代码中直接new。 

使用工厂模式，可以避免当改变某个类的名字或者方法之后，在调用这个类的所有的代码中都修改它的名字或者参数。

优点：

　　 1、一个调用者想创建一个对象，只要知道其名称就可以了。

　　 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

　　 3、屏蔽产品的具体实现，调用者只关心产品的接口。

代码：

　　

interface  mysql{

 

    public function connect();

}

 

class mysqli2  implements mysql{

 

    public  function connect(){

        echo 'mysqli';

    }

}

 

class pdo2 implements mysql{

 

    public function connect(){

        echo 'pdo';

    }

}

 

 

class mysqlFactory{

 

 

    static public function factory($class_name){

        return new $class_name();

    }

 

}

 

$obj = mysqlFactory::factory('pdo2');

$obj->connect();

观察者模式

1：观察者模式(Observer)，当一个对象状态发生变化时，依赖它的对象全部会收到通知，并自动更新。

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

3：观察者模式实现了低耦合，非侵入式的通知与更新机制。

定义一个事件触发抽象类。

/**
 * 事件产生类
 * Class EventGenerator
 */
abstract class EventGenerator
{
    private $ObServers = [];

    //增加观察者
    public function add($ObServer)
    {
        $this->ObServers[] = $ObServer;
    }

    //事件通知
    public function notify()
    {
        foreach ($this->ObServers as $ObServer) {
            $ObServer->update();
        }
    }

}

/**
 * 观察者接口类
 * Interface ObServer
 */
interface ObServer
{
    public function update($event_info = null);
}

/**
 * 观察者1
 */
class ObServer1 implements ObServer
{
    public function update($event_info = null)
    {
        echo "观察者1 收到执行通知 执行完毕！
";
    }
}

/**
 * 观察者1
 */
class ObServer2 implements ObServer
{
    public function update($event_info = null)
    {
        echo "观察者2 收到执行通知 执行完毕！
";
    }
}

/**
 * 事件
 * Class Event
 */
class Event extends EventGenerator
{
    /**
     * 触发事件
     */
    public function trigger()
    {
        //通知观察者
        $this->notify();
    }
}

//创建一个事件
$event = new Event();
//为事件增加旁观者
$event->add(new ObServer1());
$event->add(new ObServer2());
//执行事件 通知旁观者
$event->trigger();

 策略模式

 将一组特定的行为和算法封装成类,以适应某些特定的上下文环境.这种模式就是策略模式.

优点： 
　　1、 策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码转移到父类里面，从而避免重复的代码。
　　2、 策略模式提供了可以替换继承关系的办法,继承可以处理多种算法或行为。如果不是用策略模式，那么使用算法或行为的环境类就可能会有一些子类，每一个子类提供一个不同的算法或行为。但是，这样一来算法或行为的使用者就和算法或行为本身混在一起。决定使用哪一种算法或采取哪一种行为的逻辑就和算法或行为的逻辑混合在一起，从而不可能再独立演化。继承使得动态改变算法或行为变得不可能。
　　3、 使用策略模式可以避免使用多重条件转移语句。
多重转移语句不易维护，它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起，统统列在一个多重转移语句里面，比使用继承的办法还要原始和落后。

缺点：
　　1、客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。
　　2、 策略模式造成很多的策略类，每个具体策略类都会产生一个新类。
有时候可以通过把依赖于环境的状态保存到客户端里面，而将策略类设计成可共享的，这样策略类实例可以被不同客户端使用。换言之，可以使用享元模式来减少对象的数量。

<?php
header("Content-type:text/html;Charset=utf-8");
//抽象策略接口
abstract class Strategy{
    abstract function wayToSchool();
}
//具体策略角色
class BikeStrategy extends Strategy{
    function wayToSchool(){
         echo "骑自行车去上学";
    }
}
class BusStrategy extends Strategy{
    function wayToSchool(){
         echo "乘公共汽车去上学";
    }
}
class TaxiStrategy extends Strategy{
    function wayToSchool(){
         echo "骑出租车去上学";
    }
}

//环境角色
class Context{
    private $strategy;
    //获取具体策略
    function getStrategy($strategyName){
        try{
            $strategyReflection = new ReflectionClass($strategyName);
            $this->strategy = $strategyReflection->newInstance();

        }catch(ReflectionException $e){
             $this->strategy = ""; 
        }       
    }

    function goToSchool(){
        $this->strategy->wayToSchool();
        // var_dump($this->strategy);
    }
}

//测试
$context = new Context();
$context->getStrategy("BusStrategy");
$context->goToSchool();
 ?>

　　门面模式：提供一个统一的接口去访问多个子系统的多个不同的接口，它为子系统中的一组接口提供一个统一的高层接口。使用子系统更容易使用。