由于本人才疏学浅，对问题认知难免有偏差，本着学习与共享的精神和大家一起探讨，若有不对之处，望大家多多批评指正。

 

 一、什么是设计模式？

     设计模式就是一个教你如何利用真实可靠的设计来组织你的代码的模板，是解决特定问题的有效方法。通俗点说就是设计方法。在软件设计中，不可避免地要碰到一些设计上的问题，这些问题前人已经遇到过，并且总结出一些解决相关问题的方法，称这一系列方法为“模式”。

二、设计模式的原则

     1.开-闭原则：

         就是说模块应对扩展开放，而对修改关闭。简单点说就是模块应尽量在不修改原(是"原"，指原来的代码)代码的情况下进行扩展。（我的理解就是扩展性要好，也就是OOP的可扩展）

     2.里氏代换原则

         如果调用的是父类的话，那么换成子类也完全可以运行。（我的理解就是子类重写父类的方法的访问权限要大于父类的访问权限，我觉得这个原则强调的是OOP的继承和重写）

     3.合成复用原则

         就是说要少用继承，多用合成关系来实现。（我的理解是针对接口编程）

     4.依赖倒转原则

抽象不应该依赖于细节，细节应当依赖于抽象。

　　        要针对接口编程，而不是针对实现编程。

　　       传递参数，或者在组合聚合关系中，尽量引用层次高的类。

     5.接口隔离原则

每一个接口应该是一种角色，不多不少，不干不该干的事，该干的事都要干。（我的理解是分工明确）

     6.抽象类

     7．迪米特法则

最少知识原则。不要和陌生人说话。

三、所有的设计模式都有一些常用的特性：模式名称，问题，解决方案，效果。

A:模式名称（pattern name）：

　 　一个助记名，它用一两个词来描述模式的问题、解决方案和效果。

B:问题(problem)

描述了应该在何时使用模式。它解释了设计问题和问题存在的前因后果，它可能描述了特定的设计问题，如怎样用对象表示算法等。也可能描述了导致不灵活设计的类或对象结构。有时候，问题部分会包括使用模式必须满足的一系列先决条件。

 

C:解决方案(solution)

描述了设计的组成成分，它们之间的相互关系及各自的职责和协作方式。因为模式就像一个模板，可应用于多种不同场合，所以解决方案并不描述一个特定而具体的设计或实现，而是提供设计问题的抽象描述和怎样用一个具有一般意义的元素组合（类或对象组合）来解决这个问题。

 

D:效果(consequences)

描述了模式应用的效果及使用模式应权衡的问题。尽管我们描述设计决策时，并不总提到模式效果，但它们对于评价设计选择和理解使用模式的代价及好处具有重要意义。软件效果大多关注对时间和空间的衡量，它们也表述了语言和实现问题。因为复用是面向对象设计的要素之一，所以模式效果包括它对系统的灵活性、扩充性或可移植性的影响，显式地列出这些效果对理解和评价这些模式很有帮助。

四、使用设计模式的优点：可重用代码、让代码更容易被他人理解、保证代码可靠性。

五、PHP常用的设计模式

     工厂模式：工厂模式 是一种类，它具有为您创建对象的某些方法。您可以使用工厂类创建对象，而不直接使用 new。　

 

     实例：

 
  
  1. <?php 
  2. 简单工厂模式 
  3.     /** 
  4.     * 定义运算类 
  5.     * 
  6.     */ 
  7.     abstract class Operation { 
  8.             //存储第一个数字 
  9.             protected $_NumberA = 0; 
  10.             //存储第二个数字 
  11.             protected $_NumberB = 0; 
  12.             //存储运算结果 
  13.             protected $_Result = 0; 
  14.             public function __construct(){} 
  15.             /** 
  16.              * 设定需要运行的二个数字 
  17.         * @param 第一个数字 $A 
  18.             * @param 第二个数字 $B 
  19.             */ 
  20.         public function SetNumber($A=0,$B=0) { 
  21.                     $this->_NumberA = $A; 
  22.                  $this->_NumberB = $B; 
  23.             } 
  24.         /** 
  25.              * 清除所有数据 
  26.             * 
  27.             */ 
  28.             protected function ClearResult(){ 
  29.                 $this->_Result = 0; 
  30.         } 
  31.         abstract function GetResult($type) {} 
  32.     } 
  33.  
  34.     /** 
  35.     * 数据相加 
  36.     */ 
  37.     class OperactionAdd extends Operation { 
  38.         public function GetResult(){ 
  39.                     $this->_Result = $this->_NumberA + $this->_NumberB; 
  40.                     return $this->_Result; 
  41.          } 
  42.     } 
  43.     /** 
  44.     * 数据相减 
  45.     */ 
  46.     class OperactionSub extends Operation { 
  47.             public function GetResult(){ 
  48.                 $this->_Result = $this->_NumberA - $this->_NumberB; 
  49.                     return $this->_Result; 
  50.             } 
  51.     } 
  52.     /** 
  53.     * 数据相乘 
  54.     */ 
  55.     class OperactionMul extends Operation { 
  56.         public function GetResult(){ 
  57.                     $this->_Result = $this->_NumberA * $this->_NumberB; 
  58.                     return $this->_Result; 
  59.             } 
  60.     } 
  61.     /** 
  62.     * 数据相除 
  63.     */ 
  64.     class OperactionDiv extends Operation { 
  65.             public function GetResult(){ 
  66.                     $this->_Result = $this->_NumberA / $this->_NumberB; 
  67.                     return $this->_Result; 
  68.             } 
  69.     } 
  70.  
  71.     class OperactionFactory{ 
  72.             private static $_Obj; 
  73.         public static function CreateOperaction($type) { 
  74.                 switch($type) { 
  75.                     case "+": 
  76.                         self::$_Obj = new OperactionAdd; 
  77.                         break; 
  78.                      case "-": 
  79.                         self::$_Obj = new OperactionSub; 
  80.                         break; 
  81.                 case "*": 
  82.                         self::$_Obj = new OperactionMul; 
  83.                         break; 
  84.                 case "/": 
  85.                         self::$_Obj = new OperactionDiv; 
  86.                         break; 
  87.                 } 
  88.                 return self::$_Obj; 
  89.         } 
  90. } 
  91.  
  92. $Obj = OperactionFactory::CreateOperaction("*"); 
  93. $Obj->SetNumber(6,4); 
  94. $num = $Obj->GetResult(); 
  95. var_dump($num); 
  96. ?> 
 
  
     单例模式：某些应用程序资源是独占的，因为有且只有一个此类型的资源。例如，通过数据库句柄到数据库的连接是独占的。
 
  
 
  
      单例模式的核心思想是：保证一个对象存在且仅允许存在一个实例，并提供一个全局访问方式。单例模式的运作模型是：当对象第一次被请求时，创建这个对象的实例；之后的每次请求，仅传递已创建实例的句柄。在WEB程序中应用单例模式的一个典型例子是数据库连接的创建：通过数据库句柄来连接数据库这一行为是独占的。换言之，在一个句柄尚未关闭之前，你无法第二次创建一个相同名称的句柄。在此场景下，我们可以运用单例模式来维护和共享同一个数据库句柄。优点有二：
 
  
1、提高了程序运行上的安全性。你不必过多的担心和考虑诸如数据库打开/关闭的问题。
 
  
 
  
2、避免了因创建多个连接导致的不必要资源浪费。垃圾回收机制仅需要对一个链接句柄进行操作。
 
  
 
  
当然，以上两个问题对于PHP来说并不是问题，PHP的垃圾回收机制就是：当一个页面执行完毕会自动清空所有资源和内存，这里面就包括数据库连接。
 
  
 
  
至此，可以总结出单例模式在WEB程序中的运用场合：
 
  
 
  
1、某些资源本身具有独占性，你不希望在多个地方重复创建对这个独占资源对象的实例。
 
  
 
  
 
 
  
 
 
  
2、你需要在同一个对象的实例的多个引用之间共享这个对象的状态。
 
  
 
 
  
 
  
  1. 实例： 
  2. <?php 
  3. class Single { 
  4. //此成员变量用来记录此对象的引用次数 
  5. private  $counter = 1; 
  6. //注意这里是private，即禁止外部程序通过解析函数实例化对象 
  7. private function __construct() {} 
  8. //禁止克隆这个对象 
  9. private function __clone()  {} 
  10. //必须通过此方法得到对象的引用 
  11. public static function getInstance() { 
  12.         static $instance = null; 
  13.         if($instance == null) { 
  14.             $instance = new Singleton(); 
  15.         } 
  16.         return $instance; 
  17. } 
  18.     public function getUsedCount() { 
  19.         return $this->counter++; 
  20. } 
  21. } 
  22. //测试代码 
  23. echo Single::getInstance()->getUsedCount(); //echo 1 
  24. echo Single::getInstance()->getUsedCount(); //echo 2 
  25. echo Single::getInstance()->getUsedCount(); //echo 3 
  26. $obj = new Single();   //这样会报语法错误 
  27. ?> 
 
  
 
 
  
从以上代码中，我们总结出PHP单例模式实现的核心要点有如下三条：
     1.    需要一个保存类的唯一实例的静态成员变量（通常为$_instance私有变量）
     2.    构造函数和克隆函数必须声明为私有的，这是为了防止外部程序new类从而失去单例模式的意义
     3.    必须提供一个访问这个实例的公共的静态方法（通常为getInstance方法），从而返回唯一实例的一      个引用