设计模式【PHP案例】

内容来源:

　　

　　波客

　　菜鸟教程

　　

策略模式

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

介绍

意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。

何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决：将这些算法封装成一个一个的类，任意地替换。

关键代码：实现同一个接口。

应用实例：

　　　　　　1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。

　　　　　　2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。

　　　　　　3、JAVA AWT 中的 LayoutManager。

优点：

　　　　　　1、算法可以自由切换。

　　　　　　2、避免使用多重条件判断。

　　　　　　3、扩展性良好。

缺点：

　　　　　　1、策略类会增多。

　　　　　　2、所有策略类都需要对外暴露。

使用场景：

　　　　　　1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。

　　　　　　2、一个系统需要动态地在几种算法中选择一种。

　　　　　　3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

实现

我们将创建一个定义活动的 Strategy 接口和实现了 Strategy 接口的实体策略类。Context 是一个使用了某种策略的类。

StrategyPatternDemo，我们的演示类使用 Context 和策略对象来演示 Context 在它所配置或使用的策略改变时的行为变化。

 

<?php

class StrategyPattern 
{
　　
　　
    protected $cdArr;

    //构造方法
    public function __construct($title, $info) 
　　{
        $this->cdArr['title'] = $title;
        $this->cdArr['info']  = $info;
    }

    //实现接口调用不同类返回不同数据
    public function getCd($typeObj) 
　　{
        return $typeObj->get($this->cdArr);
    }
}

//返回json的数据形式
class json 
{
    public function get($return_data) 
　　{
        return json_encode($return_data);
    }
}

//返回串行化后的xml数据形式
class xml 
{
    public function get($return_data) 
　　{
            $xml = '<?xml version="1.0" encoding="utf-8"?>';
            $xml .= '<return>';
                $xml .= '<data>' .serialize($return_data). '</data>';
            $xml .= '</return>';
            return $xml;
    }
}

$cd = new StrategyPattern('test_1', 'test_2');
echo $cd->getCd(new json);
echo '<hr>';
echo $cd->getCd(new xml);

单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

介绍

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

应用实例：

　　　　　　1、一个党只能有一个书记。

　　　　　　2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。

　　　　　　3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

　　　　　　1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。

　　　　　　2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

　　　　　　1、要求生产唯一序列号。

　　　　　　2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

　　　　　　3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

实现

我们将创建一个 SingleObject 类。SingleObject 类有它的私有构造函数和本身的一个静态实例。

SingleObject 类提供了一个静态方法，供外界获取它的静态实例。SingletonPatternDemo，我们的演示类使用 SingleObject 类来获取 SingleObject对象。

 

<?php

    class Database
    {
        private $pdo;
        static $instance;
        private function __construct()
        {
            $this->pdo = new PDO(DSN,USER,PWD);
        }
        private function __clone()
        {
        }
        public static function getInstance()
        {
            if(!(self::$instance instanceof self)){
                self::$instance = new self();
            }
            return self::$instance;
        }
        public function getPDO()
        {
            return $this->pdo;
        }
    }
    $database = Database::getInstance();
    $pdo = $database->getPDO();

 ?>

观察者模式

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

介绍

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

关键代码：在抽象类里有一个 ArrayList 存放观察者们。

应用实例：

　　　　1、拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。

　　　　2、西游记里面悟空请求菩萨降服红孩儿，菩萨洒了一地水招来一个老乌龟，这个乌龟就是观察者，他观察菩萨洒水这个动作。

优点：

　　　　1、观察者和被观察者是抽象耦合的。

　　　　2、建立一套触发机制。

缺点：

　　　　1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

　　　　2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。

　　　　3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

使用场景：

• 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
• 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
• 一个对象必须通知其他对象，而并不知道这些对象是谁。
• 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

注意事项：

　　　　1、JAVA 中已经有了对观察者模式的支持类。

　　　　2、避免循环引用。

　　　　3、如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

实现

观察者模式使用三个类 Subject、Observer 和 Client。Subject 对象带有绑定观察者到 Client 对象和从 Client 对象解绑观察者的方法。我们创建 Subject 类、Observer 抽象类和扩展了抽象类 Observer 的实体类。

ObserverPatternDemo，我们的演示类使用 Subject 和实体类对象来演示观察者模式。

 

<?php
//观察者设计模式能够更便利创建和查看目标对象状态的对象，并且提供和核心对象非耦合的置顶功能性。
//观察者设计模式非常常用，在一般复杂的WEB系统中，观察者模式可以帮你减轻代码设计的压力，降低代码耦合。
//以一个购物流程为例子
class order {

    protected $observers = array(); // 存放观察容器

    //观察者新增
    public function addObServer($type, $observer) 
　　{
        $this->observers[$type][] = $observer;
    }

    //运行观察者
    public function obServer($type) 
　　{
        if (isset($this->observers[$type])) {
            foreach ($this->observers[$type] as $obser) {
                $a = new $obser;
                $a->update($this); //公用方法
            }
        }
    }

    //下单购买流程
    public function create() 
　　{
        echo '购买成功';
        $this->obServer('buy'); // buy动作
    }
}
class orderEmail 
{
    public static function update($order) 
　　{
        echo '发送购买成功一个邮件';
    }
}
class orderStatus 
{
    public static function update($order) 
　　{
        echo '改变订单状态';
    }
}
$ob = new order;
$ob->addObServer('buy', 'orderEmail');
$ob->addObServer('buy', 'orderStatus');
$ob->create();

中介者模式

中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

介绍

意图：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

主要解决：对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。

何时使用：多个类相互耦合，形成了网状结构。

如何解决：将上述网状结构分离为星型结构。

关键代码：对象 Colleague 之间的通信封装到一个类中单独处理。

应用实例：

　　　　　　1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。

　　　　　   2、机场调度系统。

　　　　　　3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。

优点：

　　　　　  1、降低了类的复杂度，将一对多转化成了一对一。

　　　　　  2、各个类之间的解耦。

　　　　  3、符合迪米特原则。

缺点：中介者会庞大，变得复杂难以维护。

使用场景：

　　　　　　1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。

　　　　　　2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

注意事项：不应当在职责混乱的时候使用。

实现

我们通过聊天室实例来演示中介者模式。实例中，多个用户可以向聊天室发送消息，聊天室向所有的用户显示消息。我们将创建两个类 ChatRoom和 User。User 对象使用 ChatRoom 方法来分享他们的消息。

MediatorPatternDemo，我们的演示类使用 User 对象来显示他们之间的通信。

<?php
class Mediator
{
    public $band  = '';
    public $title = '';
    protected $_mediator;

    public function __construct(MusicContainerMediator $mediator = NULL)
    {
        $this->_mediator = $mediator;
    }

    public function save()
    {
        //具体实现待定
        var_dump($this);
    }

    public function changeBandName($bandname)
    {
        if ( ! is_null($this->_mediator)) {
            $this->_mediator->change($this, array("band" => $bandname));
        }
        $this->band = $bandname;
        $this->save();
    }
}
//MP3Archive类
class MP3Archive
{
    protected $_mediator;

    public function __construct(MusicContainerMediator $mediator = NULL)
    {
        $this->_mediator = $mediator;
    }

    public function save()
    {
        //具体实现待定
        var_dump($this);
    }

    public function changeBandName($bandname)
    {
        if ( ! is_null($this->_mediator)) {
            $this->_mediator->change($this, array("band" => $bandname));
        }
        $this->band = $bandname;
        $this->save();
    }

}

 //中介者类
class MusicContainerMediator
{
    protected $_containers = array();

    public function __construct()
    {
        $this->_containers[] = "Mediator";
        $this->_containers[] = "MP3Archive";
    }

    public function change($originalObject, $newValue)
    {
        $title = $originalObject->title;
        $band  = $originalObject->band;
        foreach ($this->_containers as $container) {
            if ( ! ($originalObject instanceof $container)) {
                $object = new $container;
                $object->title = $title;
                $object->band  = $band;
                foreach ($newValue as $key => $val) {
                    $object->$key = $val;
                }
                $object->save();
            }
        }
    }
}

//测试实例
$titleFromDB = "Waste of a Rib";
$bandFromDB  = "Never Again";
$mediator = new MusicContainerMediator();
$cd = new Mediator($mediator);
$cd->title = $titleFromDB;
$cd->band  = $bandFromDB;
$cd->changeBandName("Maybe Once More");

迭代器模式

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

迭代器模式属于行为型模式。

介绍

意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

主要解决：不同的方式来遍历整个整合对象。

何时使用：遍历一个聚合对象。

如何解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。

关键代码：定义接口：hasNext, next。

应用实例：JAVA 中的 iterator。

优点：

　　1、它支持以不同的方式遍历一个聚合对象。

　　2、迭代器简化了聚合类。

　　3、在同一个聚合上可以有多个遍历。

　　4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

使用场景：

　　1、访问一个聚合对象的内容而无须暴露它的内部表示。

　　2、需要为聚合对象提供多种遍历方式。

　　3、为遍历不同的聚合结构提供一个统一的接口。

注意事项：迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

实现

我们将创建一个叙述导航方法的 Iterator 接口和一个返回迭代器的 Container 接口。实现了 Container 接口的实体类将负责实现 Iterator 接口。

IteratorPatternDemo，我们的演示类使用实体类 NamesRepository 来打印 NamesRepository 中存储为集合的 Names。

 

<?php
//迭代器：可帮助构造特定的对象，那些对象能够提供单一标准接口循环或迭代任何类型的可计数数据
class MyIterator implements Iterator
{

    private $var = array();

    public function __construct($array)
    {
        $this->var = $array;
    }

    public function rewind()
    {
        reset($this->var);
    }

    public function current()
    {
        $var = current($this->var);
         return $var;
    }

    public function valid()
    {
        $var = $this->current() !== false;
        return $var;
    }

    public function next()
    {
        $var = next($this->var);
         return $var;
    }

    public function key()
    {
        $var = key($this->var);
         return $var;
    }
}
$values = array('a', 'b', 'c');
$it = new MyIterator($values);
foreach ($it as $a => $b) {
    print "$a: $b<br>";
}
?>

解释器模式

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

介绍

意图：给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。

主要解决：对于一些固定文法构建一个解释句子的解释器。

何时使用：如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

如何解决：构件语法树，定义终结符与非终结符。

关键代码：构件环境类，包含解释器之外的一些全局信息，一般是 HashMap。

应用实例：编译器、运算表达式计算。

优点：

　　1、可扩展性比较好，灵活。

　　2、增加了新的解释表达式的方式。

　　3、易于实现简单文法。

缺点：

　　1、可利用场景比较少。

　　2、对于复杂的文法比较难维护。

　　3、解释器模式会引起类膨胀。

　　4、解释器模式采用递归调用方法。

使用场景：

　　1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。

　　2、一些重复出现的问题可以用一种简单的语言来进行表达。

　　3、一个简单语法需要解释的场景。

注意事项：可利用场景比较少，JAVA 中如果碰到可以用 expression4J 代替。

实现

我们将创建一个接口 Expression 和实现了 Expression 接口的实体类。定义作为上下文中主要解释器的 TerminalExpression 类。其他的类 OrExpression、AndExpression 用于创建组合式表达式。

InterpreterPatternDemo，我们的演示类使用 Expression 类创建规则和演示表达式的解析。

 

<?php
//解释器模式 用于分析一个实体的关键元素，并且针对每个元素提供自己的解释或相应动作
//解释器模式非常常用，比如PHP的模板引擎 就是非常常见的一种解释器模式
class template
{

    private $left  = '<!--{';
    private $right = '}-->';

    public function run($str)
    {
        return $this->init($str, $this->left, $this->right);
    }

    /**
     * 模板驱动-默认的驱动
     * @param  string $str 模板文件数据
     * @return string
     */
     private function init($str, $left, $right)
     {
        $pattern = array('/'.$left.'/', '/'.$right.'/');
        $replacement = array('', '');
　　　　　//搜索$str中和$pattern匹配的字符并用$replacement去替换
        return preg_replace($pattern, $replacement, $str);
     }
}
$str = "这是一个模板类，简单的模板类，标题为：<!--{Hello World}-->";
$template = new template;
echo $template->run($str);

工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

介绍

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

应用实例：

　　1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

　　2、Hibernate 换数据库只需换方言和驱动就可以。

优点：

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

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

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

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景：

　　1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。

　　2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。

　　3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

实现

我们将创建一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory。

FactoryPatternDemo，我们的演示类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。

<?php

interface Transport
{
    public function go();

}

class Bus implements Transport
{
    public function go()
　　{
        echo "公交车走走停停";
    }
}

class Car implements Transport
{
    public function go()
　　{
        echo "小汽车停停走走";
    }
}

class Bike implements Transport
{
    public function go()
　　{
        echo "自行车疾驰而过";
    }
}

class transFactory
{
    public static function factory($transport)
    {

        switch ($transport) {
            case 'bus':
                return new Bus();
                break;

            case 'car':
                return new Car();
                break;
            case 'bike':
                return new Bike();
                break;
        }
    }
}

$transport=transFactory::factory('car');
$transport->go();

外观模式

外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。

这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。

介绍

意图：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

主要解决：降低访问复杂系统的内部子系统时的复杂度，简化客户端与之的接口。

何时使用：

　　1、客户端不需要知道系统内部的复杂联系，整个系统只需提供一个"接待员"即可。

　　2、定义系统的入口。

如何解决：客户端不与系统耦合，外观类与系统耦合。

关键代码：在客户端和复杂系统之间再加一层，这一层将调用顺序、依赖关系等处理好。

应用实例：

　　1、去医院看病，可能要去挂号、门诊、划价、取药，让患者或患者家属觉得很复杂，如果有提供接待人员，只让接待人员来处理，就很方便。

　　2、JAVA 的三层开发模式。

优点：

　　1、减少系统相互依赖。

　　2、提高灵活性。

　　3、提高了安全性。

缺点：不符合开闭原则，如果要改东西很麻烦，继承重写都不合适。

使用场景：

　　1、为复杂的模块或子系统提供外界访问的模块。

　　2、子系统相对独立。

　　3、预防低水平人员带来的风险。

注意事项：在层次化结构中，可以使用外观模式定义系统中每一层的入口。

实现

我们将创建一个 Shape 接口和实现了 Shape 接口的实体类。下一步是定义一个外观类 ShapeMaker。

ShapeMaker 类使用实体类来代表用户对这些类的调用。FacadePatternDemo，我们的演示类使用 ShapeMaker 类来显示结果。

<?php
//外观模式，通过在必须的逻辑和方法的集合前创建简单的外观接口，外观设计模式隐藏了来自调用对象的复杂性
class User
{

    protected $userName;
    protected $userAge;

    public function setUserName($userName)
    {
        return $this->userName = $userName;
    }

    public function setUserAge($userAge)
    {
        return $this->userAge = $userAge;
    }

    public function getUser()
    {
        echo '用户姓名：' . $this->userName . '； 用户年龄：' . $this->userAge;
    }
}

//创建一个User 类调用接口，简化获取用户getUser方法的调用
class UserFacade
{
    public static function getUserCall($userInfo)
    {
        $User = new User;
        $User->setUserName($userInfo['username']);
        $User->setUserAge($userInfo['userAge']);
        return $User->getUser();
    }
}
$userInfo = array('username' => 'wyy', 'userAge' => 18);
UserFacade::getUserCall($userInfo); //只要一个函数就能将调用类简化