原文地址 https://my.oschina.net/botkenni/blog/1603660
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应用的开发中，常常用于允许在运行时为某个特定的类创建仅有一个可访问的实例。
<?php
/**
* Singleton class[单例模式]
* @author ITYangs<[email protected]>
*/
final class Mysql { /** * * @var self[该属性用来保存实例] */ private static $instance; /** * * @var mixed */ public $mix; /** * Return self instance[创建一个用来实例化对象的方法] * * @return self */ public static function getInstance() { if (! (self::$instance instanceof self)) { self::$instance = new self(); } return self::$instance; } /** * 构造函数为private,防止创建对象 */ private function __construct() {} /** * 防止对象被复制 */ private function __clone() { trigger_error('Clone is not allowed !'); } } // @test $firstMysql = Mysql::getInstance(); $secondMysql = Mysql::getInstance(); $firstMysql->mix = 'ityangs_one'; $secondMysql->mix = 'ityangs_two'; print_r($firstMysql->mix); // 输出： ityangs_two print_r($secondMysql->mix); // 输出： ityangs_two在很多情况下，需要为系统中的多个类创建单例的构造方式，这样，可以建立一个通用的抽象父工厂方法：
<?php
/**
* Singleton class[单例模式:多个类创建单例的构造方式]
* @author ITYangs<[email protected]>
*/
abstract class FactoryAbstract { protected static $instances = array(); public static function getInstance() { $className = self::getClassName(); if (!(self::$instances[$className] instanceof $className)) { self::$instances[$className] = new $className(); } return self::$instances[$className]; } public static function removeInstance() { $className = self::getClassName(); if (array_key_exists($className, self::$instances)) { unset(self::$instances[$className]); } } final protected static function getClassName() { return get_called_class(); } protected function __construct() { } final protected function __clone() { } } abstract class Factory extends FactoryAbstract { final public static function getInstance() { return parent::getInstance(); } final public static function removeInstance() { parent::removeInstance(); } } // @test class FirstProduct extends Factory { public $a = []; } class SecondProduct extends FirstProduct { } FirstProduct::getInstance()->a[] = 1; SecondProduct::getInstance()->a[] = 2; FirstProduct::getInstance()->a[] = 11; SecondProduct::getInstance()->a[] = 22; print_r(FirstProduct::getInstance()->a); // Array ( [0] => 1 [1] => 11 ) print_r(SecondProduct::getInstance()->a); // Array ( [0] => 2 [1] => 22 )2. Factory(工厂模式)
工厂模式是另一种非常常用的模式，正如其名字所示：确实是对象实例的生产工厂。某些意义上，工厂模式提供了通用的方法有助于我们去获取对象，而不需要关心其具体的内在的实现。
<?php
/**
* Factory class[工厂模式]
* @author ITYangs<[email protected]>
*/
interface SystemFactory { public function createSystem($type); } class MySystemFactory implements SystemFactory { // 实现工厂方法 public function createSystem($type) { switch ($type) { case 'Mac': return new MacSystem(); case 'Win': return new WinSystem(); case 'Linux': return new LinuxSystem(); } } } class System{ /* ... */} class WinSystem extends System{ /* ... */} class MacSystem extends System{ /* ... */} class LinuxSystem extends System{ /* ... */} //创建我的系统工厂 $System_obj = new MySystemFactory(); //用我的系统工厂分别创建不同系统对象 var_dump($System_obj->createSystem('Mac'));//输出：object(MacSystem)#2 (0) { } var_dump($System_obj->createSystem('Win'));//输出：object(WinSystem)#2 (0) { } var_dump($System_obj->createSystem('Linux'));//输出：object(LinuxSystem)#2 (0) { }3. AbstractFactory(抽象工厂模式)
有些情况下我们需要根据不同的选择逻辑提供不同的构造工厂，而对于多个工厂而言需要一个统一的抽象工厂：
<?php
class System{} class Soft{} class MacSystem extends System{} class MacSoft extends Soft{} class WinSystem extends System{} class WinSoft extends Soft{} /** * AbstractFactory class[抽象工厂模式] * @author ITYangs<[email protected]> */ interface AbstractFactory { public function CreateSystem(); public function CreateSoft(); } class MacFactory implements AbstractFactory{ public function CreateSystem(){ return new MacSystem(); } public function CreateSoft(){ return new MacSoft(); } } class WinFactory implements AbstractFactory{ public function CreateSystem(){ return new WinSystem(); } public function CreateSoft(){ return new WinSoft(); } } //@test:创建工厂->用该工厂生产对应的对象 //创建MacFactory工厂 $MacFactory_obj = new MacFactory(); //用MacFactory工厂分别创建不同对象 var_dump($MacFactory_obj->CreateSystem());//输出：object(MacSystem)#2 (0) { } var_dump($MacFactory_obj->CreateSoft());// 输出：object(MacSoft)#2 (0) { } //创建WinFactory $WinFactory_obj = new WinFactory(); //用WinFactory工厂分别创建不同对象 var_dump($WinFactory_obj->CreateSystem());//输出：object(WinSystem)#3 (0) { } var_dump($WinFactory_obj->CreateSoft());//输出：object(WinSoft)#3 (0) { }4. Builder(建造者模式)
建造者模式主要在于创建一些复杂的对象。将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示的设计模式;
结构图：
<?php
/**
*
* 产品本身
*/
class Product { private $_parts; public function __construct() { $this->_parts = array(); } public function add($part) { return array_push($this->_parts, $part); } } /** * 建造者抽象类 * */ abstract class Builder { public abstract function buildPart1(); public abstract function buildPart2(); public abstract function getResult(); } /** * * 具体建造者 * 实现其具体方法 */ class ConcreteBuilder extends Builder { private $_product; public function __construct() { $this->_product = new Product(); } public function buildPart1() { $this->_product->add("Part1"); } public function buildPart2() { $this->_product->add("Part2"); } public function getResult() { return $this->_product; } } /** * *导演者 */ class Director { public function __construct(Builder $builder) { $builder->buildPart1();//导演指挥具体建造者生产产品 $builder->buildPart2(); } } // client $buidler = new ConcreteBuilder(); $director = new Director($buidler); $product = $buidler->getResult(); echo "<pre>"; var_dump($product); echo "</pre>"; /*输出： object(Product)#2 (1) { ["_parts":"Product":private]=> array(2) { [0]=>string(5) "Part1" [1]=>string(5) "Part2" } } */ ?>5. Prototype(原型模式)
有时候，部分对象需要被初始化多次。而特别是在如果初始化需要耗费大量时间与资源的时候进行预初始化并且存储下这些对象，就会用到原型模式：
<?php
/**
*
* 原型接口
*
*/
interface Prototype { public function copy(); } /** * 具体实现 * */ class ConcretePrototype implements Prototype{ private $_name; public function __construct($name) { $this->_name = $name; } public function copy() { return clone $this;} } class Test {} // client $object1 = new ConcretePrototype(new Test()); var_dump($object1);//输出：object(ConcretePrototype)#1 (1) { ["_name":"ConcretePrototype":private]=> object(Test)#2 (0) { } } $object2 = $object1->copy(); var_dump($object2);//输出：object(ConcretePrototype)#3 (1) { ["_name":"ConcretePrototype":private]=> object(Test)#2 (0) { } } ?>Structural Patterns(结构设计模式)
6. Adapter(适配器模式)
这种模式允许使用不同的接口重构某个类，可以允许使用不同的调用方式进行调用：
<?php
/**
* 第一种方式：对象适配器
*/
interface Target { public function sampleMethod1(); public function sampleMethod2(); } class Adaptee { public function sampleMethod1() { echo '++++++++'; } } class Adapter implements Target { private $_adaptee; public function __construct(Adaptee $adaptee) { $this->_adaptee = $adaptee; } public function sampleMethod1() { $this->_adaptee->sampleMethod1(); } public function sampleMethod2() { echo '————————'; } } $adapter = new Adapter(new Adaptee()); $adapter->sampleMethod1();//输出：++++++++ $adapter->sampleMethod2();//输出：———————— /** * 第二种方式：类适配器 */ interface Target2 { public function sampleMethod1(); public function sampleMethod2(); } class Adaptee2 { // 源角色 public function sampleMethod1() {echo '++++++++';} } class Adapter2 extends Adaptee2 implements Target2 { // 适配后角色 public function sampleMethod2() {echo '————————';} } $adapter = new Adapter2(); $adapter->sampleMethod1();//输出：++++++++ $adapter->sampleMethod2();//输出：———————— ?>7. Bridge(桥接模式)
将抽象部分与它的实现部分分离，使他们都可以独立的变抽象与它的实现分离，即抽象类和它的派生类用来实现自己的对象
桥接与适配器模式的关系（适配器模式上面已讲解）：
桥接属于聚合关系，两者关联 但不继承
适配器属于组合关系，适配者需要继承源
聚合关系：A对象可以包含B对象 但B对象不是A对象的一部分
<?php
/**
*
*实现化角色, 给出实现化角色的接口，但不给出具体的实现。
*/
abstract class Implementor { abstract public function operationImp(); } class ConcreteImplementorA extends Implementor { // 具体化角色A public function operationImp() {echo "A";} } class ConcreteImplementorB extends Implementor { // 具体化角色B public function operationImp() {echo "B";} } /** * * 抽象化角色，抽象化给出的定义，并保存一个对实现化对象的引用 */ abstract class Abstraction { protected $imp; // 对实现化对象的引用 public function operation() { $this->imp->operationImp(); } } class RefinedAbstraction extends Abstraction { // 修正抽象化角色, 扩展抽象化角色，改变和修正父类对抽象化的定义。 public function __construct(Implementor $imp) { $this->imp = $imp; } public function operation() { $this->imp->operationImp(); } } // client $abstraction = new RefinedAbstraction(new ConcreteImplementorA()); $abstraction->operation();//输出:A $abstraction = new RefinedAbstraction(new ConcreteImplementorB()); $abstraction->operation();//输出:B ?>8. Composite(合成模式)
组合模式（Composite Pattern）有时候又叫做部分-整体模式，用于将对象组合成树形结构以表示“部分-整体”的层次关系。组合模式使得用户对单个对象和组合对象的使用具有一致性。
常见使用场景：如树形菜单、文件夹菜单、部门组织架构图等。
<?php
/**
*
*安全式合成模式
*/
interface Component { public function getComposite(); //返回自己的实例 public function operation(); } class Composite implements Component { // 树枝组件角色 private $_composites; public function __construct() { $this->_composites = array(); } public function getComposite() { return $this; } public function operation() { foreach ($this->_composites as $composite) { $composite->operation(); } } public function add(Component $component) { //聚集管理方法 添加一个子对象 $this->_composites[] = $component; } public function remove(Component $component) { // 聚集管理方法 删除一个子对象 foreach ($this->_composites as $key => $row) { if ($component == $row) { unset($this->_composites[$key]); return TRUE; } } return FALSE; } public function getChild() { // 聚集管理方法 返回所有的子对象 return $this->_composites; } } class Leaf implements Component { private $_name; public function __construct($name) { $this->_name = $name; } public function operation() {} public function getComposite() {return null;} } // client $leaf1 = new Leaf('first'); $leaf2 = new Leaf('second'); $composite = new Composite(); $composite->add($leaf1); $composite->add($leaf2); $composite->operation(); $composite->remove($leaf2); $composite->operation(); /** * *透明式合成模式 */ interface Component { // 抽象组件角色 public function getComposite(); // 返回自己的实例 public function operation(); // 示例方法 public function add(Component $component); // 聚集管理方法,添加一个子对象 public function remove(Component $component); // 聚集管理方法 删除一个子对象 public function getChild(); // 聚集管理方法 返回所有的子对象 } class Composite implements Component { // 树枝组件角色 private $_composites; public function __construct() { $this->_composites = array(); } public function getComposite() { return $this; } public function operation() { // 示例方法，调用各个子对象的operation方法 foreach ($this->_composites as $composite) { $composite->operation(); } } public function add(Component $component) { // 聚集管理方法 添加一个子对象 $this->_composites[] = $component; } public function remove(Component $component) { // 聚集管理方法 删除一个子对象 foreach ($this->_composites as $key => $row) { if ($component == $row) { unset($this->_composites[$key]); return TRUE; } } return FALSE; } public function getChild() { // 聚集管理方法 返回所有的子对象 return $this->_composites; } } class Leaf implements Component { private $_name; public function __construct($name) {$this->_name = $name;} public function operation() {echo $this->_name."<br>";} public function getComposite() { return null; } public function add(Component $component) { return FALSE; } public function remove(Component $component) { return FALSE; } public