PhpDesignPatterns 【PHP 中的设计模式】

一、 Introduction【介绍】

设计模式：提供了一种广泛的可重用的方式来解决我们日常编程中常常遇见的问题。设计模式并不一定就是一个类库或者第三方框架，它们更多的表现为一种思想并且广泛地应用在系统中。它们也表现为一种模式或者模板，可以在多个不同的场景下用于解决问题。设计模式可以用于加速开发，并且将很多大的想法或者设计以一种简单地方式实现。当然，虽然设计模式在开发中很有作用，但是千万要避免在不适当的场景误用它们。

二、 Category【分类】

根据目的和范围，设计模式可以分为五类。
按照目的分为：创建设计模式，结构设计模式，以及行为设计模式。
按照范围分为：类的设计模式，以及对象设计模式。

1. 按照目的分，目前常见的设计模式主要有23种，根据使用目标的不同可以分为以下三大类：

• 创建设计模式（Creational Patterns）(5种)：用于创建对象时的设计模式。更具体一点，初始化对象流程的设计模式。当程序日益复杂时，需要更加灵活地创建对象，同时减少创建时的依赖。而创建设计模式就是解决此问题的一类设计模式。

  • 单例模式【Singleton】
  • 工厂模式【Factory】
  • 抽象工厂模式【AbstractFactory】
  • 建造者模式【Builder】
  • 原型模式【Prototype】

• 结构设计模式（Structural Patterns）(7种)：用于继承和接口时的设计模式。结构设计模式用于新类的函数方法设计，减少不必要的类定义，减少代码的冗余。

  • 适配器模式【Adapter】
  • 桥接模式【Bridge】
  • 合成模式【Composite】
  • 装饰器模式【Decorator】
  • 门面模式【Facade】
  • 代理模式【Proxy】
  • 享元模式【Flyweight】

• 行为模式（Behavioral Patterns）(11种)：用于方法实现以及对应算法的设计模式，同时也是最复杂的设计模式。行为设计模式不仅仅用于定义类的函数行为，同时也用于不同类之间的协议、通信。

  • 策略模式【Strategy】
  • 模板方法模式【TemplateMethod】
  • 观察者模式【Observer】
  • 迭代器模式【Iterator】
  • 责任链模式【ResponsibilityChain】
  • 命令模式【Command】
  • 备忘录模式【Memento】
  • 状态模式【State】
  • 访问者模式【Visitor】
  • 中介者模式【Mediator】
  • 解释器模式【Interpreter】

2.按照范围分为：类的设计模式，以及对象设计模式

• 类的设计模式(Class patterns)：用于类的具体实现的设计模式。包含了如何设计和定义类，以及父类和子类的设计模式。

• 对象设计模式(Object patterns): 用于对象的设计模式。与类的设计模式不同，对象设计模式主要用于运行期对象的状态改变、动态行为变更等。

三、 DesignPatternsPrinciple【设计模式原则】

设计模式六大原则

• 开放封闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
• 里氏替换原则：所有引用基类的地方必须能透明地使用其子类的对象.
• 依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。
• 单一职责原则：不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。
• 接口隔离原则：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。
• 迪米特法则：一个对象应该对其他对象保持最少的了解。

四、 Realization【设计模式实现】

Creational Patterns(创建设计模式)

1. Singleton(单例模式)

• Singleton(单例模式):单例模式是最常见的模式之一，在Web应用的开发中，常常用于允许在运行时为某个特定的类创建仅有一个可访问的实例。

1.  
   <?php
2.  
    
3.  
   /**
4.  
   * Singleton class[单例模式]
5.  
   * @author ITYangs<ityangs@163.com>
6.  
   */
7.  
   final classMysql
8.  
   {
9.  
    
10.  
    /**
11.  
    *
12.  
    * @var self[该属性用来保存实例]
13.  
    */
14.  
    private static $instance;
15.  
     
16.  
    /**
17.  
    *
18.  
    * @var mixed
19.  
    */
20.  
    public $mix;
21.  
     
22.  
    /**
23.  
    * Return self instance[创建一个用来实例化对象的方法]
24.  
    *
25.  
    * @return self
26.  
    */
27.  
    public static functiongetInstance()
28.  
    {
29.  
    if (! (self::$instance instanceof self)) {
30.  
    self::$instance = new self();
31.  
    }
32.  
    return self::$instance;
33.  
    }
34.  
     
35.  
    /**
36.  
    * 构造函数为private,防止创建对象
37.  
    */
38.  
    private function__construct()
39.  
    {}
40.  
     
41.  
    /**
42.  
    * 防止对象被复制
43.  
    */
44.  
    private function__clone()
45.  
    {
46.  
    trigger_error(‘Clone is not allowed !‘);
47.  
    }
48.  
    }
49.  
     
50.  
    // @test
51.  
    $firstMysql = Mysql::getInstance();
52.  
    $secondMysql = Mysql::getInstance();
53.  
     
54.  
    $firstMysql->mix = ‘ityangs_one‘;
55.  
    $secondMysql->mix = ‘ityangs_two‘;
56.  
     
57.  
    print_r($firstMysql->mix);
58.  
    // 输出： ityangs_two
59.  
    print_r($secondMysql->mix);
60.  
    // 输出： ityangs_two

在很多情况下，需要为系统中的多个类创建单例的构造方式，这样，可以建立一个通用的抽象父工厂方法：

1.  
   <?php
2.  
   /**
3.  
   * Singleton class[单例模式:多个类创建单例的构造方式]
4.  
   * @author ITYangs<ityangs@163.com>
5.  
   */
6.  
   abstract classFactoryAbstract{
7.  
    
8.  
   protected static $instances = array();
9.  
    
10.  
    public static functiongetInstance(){
11.  
    $className = self::getClassName();
12.  
    if (!(self::$instances[$className] instanceof $className)) {
13.  
    self::$instances[$className] = new $className();
14.  
    }
15.  
    return self::$instances[$className];
16.  
    }
17.  
     
18.  
    public static functionremoveInstance(){
19.  
    $className = self::getClassName();
20.  
    if (array_key_exists($className, self::$instances)) {
21.  
    unset(self::$instances[$className]);
22.  
    }
23.  
    }
24.  
     
25.  
    final protected static functiongetClassName(){
26.  
    return get_called_class();
27.  
    }
28.  
     
29.  
    protected function__construct(){ }
30.  
     
31.  
    final protected function__clone(){ }
32.  
    }
33.  
     
34.  
    abstract classFactoryextendsFactoryAbstract{
35.  
     
36.  
    final public static functiongetInstance(){
37.  
    return parent::getInstance();
38.  
    }
39.  
     
40.  
    final public static functionremoveInstance(){
41.  
    parent::removeInstance();
42.  
    }
43.  
    }
44.  
    // @test
45.  
     
46.  
    classFirstProductextendsFactory{
47.  
    public $a = [];
48.  
    }
49.  
    classSecondProductextendsFirstProduct{
50.  
    }
51.  
     
52.  
    FirstProduct::getInstance()->a[] = 1;
53.  
    SecondProduct::getInstance()->a[] = 2;
54.  
    FirstProduct::getInstance()->a[] = 11;
55.  
    SecondProduct::getInstance()->a[] = 22;
56.  
     
57.  
    print_r(FirstProduct::getInstance()->a);
58.  
    // Array ( [0] => 1 [1] => 11 )
59.  
    print_r(SecondProduct::getInstance()->a);
60.  
    // Array ( [0] => 2 [1] => 22 )

2. Factory(工厂模式)

工厂模式是另一种非常常用的模式，正如其名字所示：确实是对象实例的生产工厂。某些意义上，工厂模式提供了通用的方法有助于我们去获取对象，而不需要关心其具体的内在的实现。

1.  
   <?php
2.  
    
3.  
   /**
4.  
   * Factory class[工厂模式]
5.  
   * @author ITYangs<ityangs@163.com>
6.  
   */
7.  
   interface SystemFactory
8.  
   {
9.  
   public function createSystem($type);
10.  
    }
11.  
     
12.  
    classMySystemFactoryimplementsSystemFactory
13.  
    {
14.  
    // 实现工厂方法
15.  
    public function createSystem($type)
16.  
    {
17.  
    switch ($type) {
18.  
    case ‘Mac‘:
19.  
    return new MacSystem();
20.  
    case ‘Win‘:
21.  
    return new WinSystem();
22.  
    case ‘Linux‘:
23.  
    return new LinuxSystem();
24.  
    }
25.  
    }
26.  
    }
27.  
     
28.  
    classSystem{ /* ... */}
29.  
    classWinSystemextendsSystem{ /* ... */}
30.  
    classMacSystemextendsSystem{ /* ... */}
31.  
    classLinuxSystemextendsSystem{ /* ... */}
32.  
     
33.  
    //创建我的系统工厂
34.  
    $System_obj = new MySystemFactory();
35.  
    //用我的系统工厂分别创建不同系统对象
36.  
    var_dump($System_obj->createSystem(‘Mac‘));//输出：object(MacSystem)#2 (0) { }
37.  
    var_dump($System_obj->createSystem(‘Win‘));//输出：object(WinSystem)#2 (0) { }
38.  
    var_dump($System_obj->createSystem(‘Linux‘));//输出：object(LinuxSystem)#2 (0) { }

3. AbstractFactory(抽象工厂模式)

有些情况下我们需要根据不同的选择逻辑提供不同的构造工厂，而对于多个工厂而言需要一个统一的抽象工厂：

1.  
   <?php
2.  
    
3.  
   classSystem{}
4.  
   classSoft{}
5.  
    
6.  
   classMacSystemextendsSystem{}
7.  
   classMacSoftextendsSoft{}
8.  
    
9.  
   classWinSystemextendsSystem{}
10.  
    classWinSoftextendsSoft{}
11.  
     
12.  
     
13.  
    /**
14.  
    * AbstractFactory class[抽象工厂模式]
15.  
    * @author ITYangs<ityangs@163.com>
16.  
    */
17.  
    interfaceAbstractFactory{
18.  
    public functionCreateSystem();
19.  
    public functionCreateSoft();
20.  
    }
21.  
     
22.  
    classMacFactoryimplementsAbstractFactory{
23.  
    public functionCreateSystem(){ return new MacSystem(); }
24.  
    public functionCreateSoft(){ return new MacSoft(); }
25.  
    }
26.  
     
27.  
    classWinFactoryimplementsAbstractFactory{
28.  
    public functionCreateSystem(){ return new WinSystem(); }
29.  
    public functionCreateSoft(){ return new WinSoft(); }
30.  
    }
31.  
     
32.  
     
33.  
     
34.  
     
35.  
     
36.  
     
37.  
    //@test:创建工厂->用该工厂生产对应的对象
38.  
     
39.  
    //创建MacFactory工厂
40.  
    $MacFactory_obj = new MacFactory();
41.  
    //用MacFactory工厂分别创建不同对象
42.  
    var_dump($MacFactory_obj->CreateSystem());//输出：object(MacSystem)#2 (0) { }
43.  
    var_dump($MacFactory_obj->CreateSoft());// 输出：object(MacSoft)#2 (0) { }
44.  
     
45.  
     
46.  
    //创建WinFactory
47.  
    $WinFactory_obj = new WinFactory();
48.  
    //用WinFactory工厂分别创建不同对象
49.  
    var_dump($WinFactory_obj->CreateSystem());//输出：object(WinSystem)#3 (0) { }
50.  
    var_dump($WinFactory_obj->CreateSoft());//输出：object(WinSoft)#3 (0) { }

4. Builder(建造者模式)

建造者模式主要在于创建一些复杂的对象。将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示的设计模式;

结构图：

1.  
   <?php
2.  
   /**
3.  
   *
4.  
   * 产品本身
5.  
   */
6.  
   classProduct{
7.  
   private $_parts;
8.  
   publicfunction__construct(){ $this->_parts = array(); }
9.  
   publicfunctionadd($part){ return array_push($this->_parts, $part); }
10.  
    }
11.  
     
12.  
     
13.  
     
14.  
     
15.  
     
16.  
    /**
17.  
    * 建造者抽象类
18.  
    *
19.  
    */
20.  
    abstractclassBuilder{
21.  
    publicabstractfunctionbuildPart1();
22.  
    publicabstractfunctionbuildPart2();
23.  
    publicabstractfunctiongetResult();
24.  
    }
25.  
     
26.  
    /**
27.  
    *
28.  
    * 具体建造者
29.  
    * 实现其具体方法
30.  
    */
31.  
    classConcreteBuilderextendsBuilder{
32.  
    private $_product;
33.  
    publicfunction__construct(){ $this->_product = new Product(); }
34.  
    publicfunctionbuildPart1(){ $this->_product->add("Part1"); }
35.  
    publicfunctionbuildPart2(){ $this->_product->add("Part2"); }
36.  
    publicfunctiongetResult(){ return$this->_product; }
37.  
    }
38.  
    /**
39.  
    *
40.  
    *导演者
41.  
    */
42.  
    classDirector{
43.  
    publicfunction__construct(Builder $builder){
44.  
    $builder->buildPart1();//导演指挥具体建造者生产产品
45.  
    $builder->buildPart2();
46.  
    }
47.  
    }
48.  
     
49.  
     
50.  
     
51.  
     
52.  
    // client
53.  
    $buidler = new ConcreteBuilder();
54.  
    $director = new Director($buidler);
55.  
    $product = $buidler->getResult();
56.  
    echo"<pre>";
57.  
    var_dump($product);
58.  
    echo"</pre>";
59.  
    /*输出： object(Product)#2 (1) {
60.  
    ["_parts":"Product":private]=>
61.  
    array(2) {
62.  
    [0]=>string(5) "Part1"
63.  
    [1]=>string(5) "Part2"
64.  
    }
65.  
    } */
66.  
    ?>

5. Prototype(原型模式)

有时候，部分对象需要被初始化多次。而特别是在如果初始化需要耗费大量时间与资源的时候进行预初始化并且存储下这些对象，就会用到原型模式：

1.  
   <?php
2.  
   /**
3.  
   *
4.  
   * 原型接口
5.  
   *
6.  
   */
7.  
   interfacePrototype{ publicfunctioncopy(); }
8.  
    
9.  
   /**
10.  
    * 具体实现
11.  
    *
12.  
    */
13.  
    classConcretePrototypeimplementsPrototype{
14.  
    private $_name;
15.  
    publicfunction__construct($name){ $this->_name = $name; }
16.  
    publicfunctioncopy(){ returnclone$this;}
17.  
    }
18.  
     
19.  
    classTest{}
20.  
     
21.  
    // client
22.  
    $object1 = new ConcretePrototype(new Test());
23.  
    var_dump($object1);//输出：object(ConcretePrototype)#1 (1) { ["_name":"ConcretePrototype":private]=> object(Test)#2 (0) { } }
24.  
    $object2 = $object1->copy();
25.  
    var_dump($object2);//输出：object(ConcretePrototype)#3 (1) { ["_name":"ConcretePrototype":private]=> object(Test)#2 (0) { } }
26.  
    ?>

Structural Patterns(结构设计模式)

6. Adapter(适配器模式)

这种模式允许使用不同的接口重构某个类，可以允许使用不同的调用方式进行调用：

1.  
   <?php
2.  
   /**
3.  
   * 第一种方式：对象适配器
4.  
   */
5.  
   interfaceTarget{
6.  
   publicfunctionsampleMethod1();
7.  
   publicfunctionsampleMethod2();
8.  
   }
9.  
    
10.  
    classAdaptee{
11.  
    publicfunctionsampleMethod1(){
12.  
    echo‘++++++++‘;
13.  
    }
14.  
    }
15.  
     
16.  
    classAdapterimplementsTarget{
17.  
    private $_adaptee;
18.  
     
19.  
    publicfunction__construct(Adaptee $adaptee){
20.  
    $this->_adaptee = $adaptee;
21.  
    }
22.  
     
23.  
    publicfunctionsampleMethod1(){
24.  
    $this->_adaptee->sampleMethod1();
25.  
    }
26.  
     
27.  
    publicfunctionsampleMethod2(){
28.  
    echo‘————————‘;
29.  
    }
30.  
    }
31.  
    $adapter = new Adapter(new Adaptee());
32.  
    $adapter->sampleMethod1();//输出：++++++++
33.  
    $adapter->sampleMethod2();//输出：————————
34.  
     
35.  
     
36.  
     
37.  
    /**
38.  
    * 第二种方式：类适配器
39.  
    */
40.  
    interfaceTarget2{
41.  
    publicfunctionsampleMethod1();
42.  
    publicfunctionsampleMethod2();
43.  
    }
44.  
     
45.  
    classAdaptee2{ // 源角色
46.  
    publicfunctionsampleMethod1(){echo‘++++++++‘;}
47.  
    }
48.  
     
49.  
    classAdapter2extendsAdaptee2implementsTarget2{ // 适配后角色
50.  
    publicfunctionsampleMethod2(){echo‘————————‘;}
51.  
    }
52.  
     
53.  
    $adapter = new Adapter2();
54.  
    $adapter->sampleMethod1();//输出：++++++++
55.  
    $adapter->sampleMethod2();//输出：————————
56.  
    ?>

7. Bridge(桥接模式)

将抽象部分与它的实现部分分离，使他们都可以独立的变抽象与它的实现分离，即抽象类和它的派生类用来实现自己的对象

桥接与适配器模式的关系（适配器模式上面已讲解）：
桥接属于聚合关系，两者关联 但不继承
适配器属于组合关系，适配者需要继承源

聚合关系：A对象可以包含B对象 但B对象不是A对象的一部分

1.  
   <?php
2.  
   /**
3.  
   *
4.  
   *实现化角色, 给出实现化角色的接口，但不给出具体的实现。
5.  
   */
6.  
   abstractclassImplementor{
7.  
   abstractpublicfunctionoperationImp();
8.  
   }
9.  
    
10.  
    classConcreteImplementorAextendsImplementor{ // 具体化角色A
11.  
    publicfunctionoperationImp(){echo"A";}
12.  
    }
13.  
     
14.  
    classConcreteImplementorBextendsImplementor{ // 具体化角色B
15.  
    publicfunctionoperationImp(){echo"B";}
16.  
    }
17.  
     
18.  
     
19.  
    /**
20.  
    *
21.  
    * 抽象化角色，抽象化给出的定义，并保存一个对实现化对象的引用
22.  
    */
23.  
    abstractclassAbstraction{
24.  
    protected $imp; // 对实现化对象的引用
25.  
    publicfunctionoperation(){
26.  
    $this->imp->operationImp();
27.  
    }
28.  
    }
29.  
    classRefinedAbstractionextendsAbstraction{ // 修正抽象化角色, 扩展抽象化角色，改变和修正父类对抽象化的定义。
30.  
    publicfunction__construct(Implementor $imp){
31.  
    $this->imp = $imp;
32.  
    }
33.  
    publicfunctionoperation(){ $this->imp->operationImp(); }
34.  
    }
35.  
     
36.  
     
37.  
     
38.  
     
39.  
     
40.  
    // client
41.  
    $abstraction = new RefinedAbstraction(new ConcreteImplementorA());
42.  
    $abstraction->operation();//输出:A
43.  
    $abstraction = new RefinedAbstraction(new ConcreteImplementorB());
44.  
    $abstraction->operation();//输出:B
45.  
    ?>

8. Composite(合成模式)

组合模式（Composite Pattern）有时候又叫做部分-整体模式，用于将对象组合成树形结构以表示“部分-整体”的层次关系。组合模式使得用户对单个对象和组合对象的使用具有一致性。

常见使用场景：如树形菜单、文件夹菜单、部门组织架构图等。

1.  
   <?php
2.  
   /**
3.  
   *
4.  
   *安全式合成模式
5.  
   */
6.  
   interfaceComponent{
7.  
   publicfunctiongetComposite(); //返回自己的实例
8.  
   publicfunctionoperation();
9.  
   }
10.  
     
11.  
    classCompositeimplementsComponent{ // 树枝组件角色
12.  
    private $_composites;
13.  
    publicfunction__construct(){ $this->_composites = array(); }
14.  
    publicfunctiongetComposite(){ return$this; }
15.  
    publicfunctionoperation(){
16.  
    foreach ($this->_composites as $composite) {
17.  
    $composite->operation();
18.  
    }
19.  
    }
20.  
     
21.  
    publicfunctionadd(Component $component){ //聚集管理方法 添加一个子对象
22.  
    $this->_composites[] = $component;
23.  
    }
24.  
     
25.  
    publicfunctionremove(Component $component){ // 聚集管理方法 删除一个子对象
26.  
    foreach ($this->_composites as $key => $row) {
27.  
    if ($component == $row) { unset($this->_composites[$key]); returnTRUE; }
28.  
    }
29.  
    returnFALSE;
30.  
    }
31.  
     
32.  
    publicfunctiongetChild(){ // 聚集管理方法 返回所有的子对象
33.  
    return$this->_composites;
34.  
    }
35.  
     
36.  
    }
37.  
     
38.  
    classLeafimplementsComponent{
39.  
    private $_name;
40.  
    publicfunction__construct($name){ $this->_name = $name; }
41.  
    publicfunctionoperation(){}
42.  
    publicfunctiongetComposite(){returnnull;}
43.  
    }
44.  
     
45.  
    // client
46.  
    $leaf1 = new Leaf(‘first‘);
47.  
    $leaf2 = new Leaf(‘second‘);
48.  
     
49.  
    $composite = new Composite();
50.  
    $composite->add($leaf1);
51.  
    $composite->add($leaf2);
52.  
    $composite->operation();
53.  
     
54.  
    $composite->remove($leaf2);
55.  
    $composite->operation();
56.  
     
57.  
     
58.  
     
59.  
     
60.  
     
61.  
     
62.  
    /**
63.  
    *
64.  
    *透明式合成模式
65.  
    */
66.  
    interfaceComponent{ // 抽象组件角色
67.  
    publicfunctiongetComposite(); // 返回自己的实例
68.  
    publicfunctionoperation(); // 示例方法
69.  
    publicfunctionadd(Component $component); // 聚集管理方法,添加一个子对象
70.  
    publicfunctionremove(Component $component); // 聚集管理方法 删除一个子对象
71.  
    publicfunctiongetChild(); // 聚集管理方法 返回所有的子对象
72.  
    }
73.  
     
74.  
    classCompositeimplementsComponent{ // 树枝组件角色
75.  
    private $_composites;
76.  
    publicfunction__construct(){ $this->_composites = array(); }
77.  
    publicfunctiongetComposite(){ return$this; }
78.  
    publicfunctionoperation(){ // 示例方法，调用各个子对象的operation方法
79.  
    foreach ($this->_composites as $composite) {
80.  
    $composite->operation();
81.  
    }
82.  
    }
83.  
    publicfunctionadd(Component $component){ // 聚集管理方法 添加一个子对象
84.  
    $this->_composites[] = $component;
85.  
    }
86.  
    publicfunctionremove(Component $component){ // 聚集管理方法 删除一个子对象
87.  
    foreach ($this->_composites as $key => $row) {
88.  
    if ($component == $row) { unset($this->_composites[$key]); returnTRUE; }
89.  
    }
90.  
    returnFALSE;
91.  
    }
92.  
    publicfunctiongetChild(){ // 聚集管理方法 返回所有的子对象
93.  
    return$this->_composites;
94.  
    }
95.  
     
96.  
    }
97.  
     
98.  
    classLeafimplementsComponent{
99.  
    private $_name;
100.  
     publicfunction__construct($name){$this->_name = $name;}
101.  
     publicfunctionoperation(){echo$this->_name."<br>";}
102.  
     publicfunctiongetComposite(){ returnnull; }
103.  
     publicfunctionadd(Component $component){ returnFALSE; }
104.  
     publicfunctionremove(Component $component){ returnFALSE; }
105.  
     publicfunctiongetChild(){ returnnull; }
106.  
     }
107.  
      
108.  
     // client
109.  
     $leaf1 = new Leaf(‘first‘);
110.  
     $leaf2 = new Leaf(‘second‘);
111.  
      
112.  
     $composite = new Composite();
113.  
     $composite->add($leaf1);
114.  
     $composite->add($leaf2);
115.  
     $composite->operation();
116.  
      
117.  
     $composite->remove($leaf2);
118.  
     $composite->operation();
119.  
      
120.  
     ?>

9. Decorator(装饰器模式)

装饰器模式允许我们根据运行时不同的情景动态地为某个对象调用前后添加不同的行

1.  
   <?php
2.  
   interfaceComponent{
3.  
   publicfunctionoperation();
4.  
   }
5.  
    
6.  
   abstractclassDecoratorimplementsComponent{ // 装饰角色
7.  
   protected $_component;
8.  
   publicfunction__construct(Component $component){
9.  
   $this->_component = $component;
10.  
    }
11.  
    publicfunctionoperation(){
12.  
    $this->_component->operation();
13.  
    }
14.  
    }
15.  
     
16.  
    classConcreteDecoratorAextendsDecorator{ // 具体装饰类A
17.  
    publicfunction__construct(Component $component){
18.  
    parent::__construct($component);
19.  
    }
20.  
    publicfunctionoperation(){
21.  
    parent::operation(); // 调用装饰类的操作
22.  
    $this->addedOperationA(); // 新增加的操作
23.  
    }
24.  
    publicfunctionaddedOperationA(){echo‘A加点酱油;‘;}
25.  
    }
26.  
     
27.  
    classConcreteDecoratorBextendsDecorator{ // 具体装饰类B
28.  
    publicfunction__construct(Component $component){
29.  
    parent::__construct($component);
30.  
    }
31.  
    publicfunctionoperation(){
32.  
    parent::operation();
33.  
    $this->addedOperationB();
34.  
    }
35.  
    publicfunctionaddedOperationB(){echo"B加点辣椒;";}
36.  
    }
37.  
     
38.  
    classConcreteComponentimplementsComponent{ //具体组件类
39.  
    publicfunctionoperation(){}
40.  
    }
41.  
     
42.  
    // clients
43.  
    $component = new ConcreteComponent();
44.  
    $decoratorA = new ConcreteDecoratorA($component);
45.  
    $decoratorB = new ConcreteDecoratorB($decoratorA);
46.  
     
47.  
    $decoratorA->operation();//输出：A加点酱油;
48.  
    echo‘<br>--------<br>‘;
49.  
    $decoratorB->operation();//输出：A加点酱油;B加点辣椒;
50.  
    ?>

10. Facade(门面模式)

门面模式 （Facade）又称外观模式，用于为子系统中的一组接口提供一个一致的界面。门面模式定义了一个高层接口，这个接口使得子系统更加容易使用：引入门面角色之后，用户只需要直接与门面角色交互，用户与子系统之间的复杂关系由门面角色来实现，从而降低了系统的耦

1.  
   <?php
2.  
   classCamera{
3.  
   publicfunctionturnOn(){}
4.  
   publicfunctionturnOff(){}
5.  
   publicfunctionrotate($degrees){}
6.  
   }
7.  
    
8.  
   classLight{
9.  
   publicfunctionturnOn(){}
10.  
    publicfunctionturnOff(){}
11.  
    publicfunctionchangeBulb(){}
12.  
    }
13.  
     
14.  
    classSensor{
15.  
    publicfunctionactivate(){}
16.  
    publicfunctiondeactivate(){}
17.  
    publicfunctiontrigger(){}
18.  
    }
19.  
     
20.  
    classAlarm{
21.  
    publicfunctionactivate(){}
22.  
    publicfunctiondeactivate(){}
23.  
    publicfunctionring(){}
24.  
    publicfunctionstopRing(){}
25.  
    }
26.  
     
27.  
    classSecurityFacade{
28.  
    private $_camera1, $_camera2;
29.  
    private $_light1, $_light2, $_light3;
30.  
    private $_sensor;
31.  
    private $_alarm;
32.  
     
33.  
    publicfunction__construct(){
34.  
    $this->_camera1 = new Camera();
35.  
    $this->_camera2 = new Camera();
36.  
     
37.  
    $this->_light1 = new Light();
38.  
    $this->_light2 = new Light();
39.  
    $this->_light3 = new Light();
40.  
     
41.  
    $this->_sensor = new Sensor();
42.  
    $this->_alarm = new Alarm();
43.  
    }
44.  
     
45.  
    publicfunctionactivate(){
46.  
    $this->_camera1->turnOn();
47.  
    $this->_camera2->turnOn();
48.  
     
49.  
    $this->_light1->turnOn();
50.  
    $this->_light2->turnOn();
51.  
    $this->_light3->turnOn();
52.  
     
53.  
    $this->_sensor->activate();
54.  
    $this->_alarm->activate();
55.  
    }
56.  
     
57.  
    publicfunctiondeactivate(){
58.  
    $this->_camera1->turnOff();
59.  
    $this->_camera2->turnOff();
60.  
     
61.  
    $this->_light1->turnOff();
62.  
    $this->_light2->turnOff();
63.  
    $this->_light3->turnOff();
64.  
     
65.  
    $this->_sensor->deactivate();
66.  
    $this->_alarm->deactivate();
67.  
    }
68.  
    }
69.  
     
70.  
     
71.  
    //client
72.  
    $security = new SecurityFacade();
73.  
    $security->activate();
74.  
    ?>