当前位置：首页 > PHP教程 > php面向对象 > 列表

PHP中常用的三种设计模式详解【单例模式、工厂模式、观察者模式】

发布:smiling　来源: PHP粉丝网 　添加日期：2021-11-25 15:47:03　浏览: 评论：0　

这篇文章主要介绍了PHP中常用的三种设计模式,结合实例形式详细分析了php单例模式、工厂模式与观察者模式概念、功能、相关使用技巧与操作注意事项,需要的朋友可以参考下。

本文实例讲述了PHP中常用的三种设计模式，分享给大家供大家参考，具体如下：

PHP中常用的三种设计模式：单例模式、工厂模式、观察者模式

1.单例模式

为何要使用PHP单例模式？

多数人都是从单例模式的字面上的意思来理解它的用途, 认为这是对系统资源的节省, 可以避免重复实例化, 是一种”计划生育”. 而PHP每次执行完页面都是会从内存中清理掉所有的资源. 因而PHP中的单例实际每次运行都是需要重新实例化的, 这样就失去了单例重复实例化的意义了. 单单从这个方面来说, PHP的单例的确有点让各位失望. 但是单例仅仅只有这个功能和应用吗? 答案是否定的。

php的应用主要在于数据库应用, 所以一个应用中会存在大量的数据库操作, 在使用面向对象的方式开发时(废话), 如果使用单例模式, 则可以避免大量的new 操作消耗的资源。

如果系统中需要有一个类来全局控制某些配置信息, 那么使用单例模式可以很方便的实现. 这个可以参看zend Framework的FrontController部分。

在一次页面请求中, 便于进行调试, 因为所有的代码(例如数据库操作类db)都集中在一个类中, 我们可以在类中设置钩子, 输出日志，从而避免到处var_dump, echo。

一个单例类应包括以下几点：

和普通类不同，单例类不能被直接实例化，只能是由自身实例化。因此，要获得这样的限制效果，构造函数必须标记为private。

要让单例类不被直接实例化而能起到作用，就必须为其提供这样的一个实例。因此，就必须要让单例类拥有一个能保存类的实例的私有静态成员变量和对应的一个能访问到实例的公共静态方法。

在PHP中，为防止对单例类对象的克隆来打破单例类的上述实现形式，通常还为其提供一个空的私有__clone()方法。

对于一个类的对象，如果使用“clone运算符”，就会复制出一个和当前对象完全一样的新对象出来，并且，此时还会自动调用该类的魔术方法：__clone()（只要该类中有该方法）。

则要实现单例类，就应该对这个单例类的对象“禁止克隆”，用private来修饰__clone()来实现禁止克隆，具体可参考单例类的加强：禁止克隆。

单例模式的例子：

  1. <?php 
  2. /** 
  3. * 设计模式之单例模式 
  4. * $instance必须声明为静态的私有变量 
  5. * 构造函数和析构函数必须声明为私有,防止外部程序new 
  6. * 类从而失去单例模式的意义 
  7. * getInstance()方法必须设置为公有的,必须调用此方法 
  8. * 以返回实例的一个引用 
  9. * ::操作符只能访问静态变量和静态函数 
  10. * new对象都会消耗内存 
  11. * 使用场景:最常用的地方是数据库连接。 
  12. * 使用单例模式生成一个对象后， 
  13. * 该对象可以被其它众多对象所使用。 
  14. */ 
  15. class SingetonBasic { 
  16. private static $instance; //静态变量要私有化，防止类外修改 
  17. // other vars.. 
  18. private function __construct() {  //构造函数私有化，类外不能直接新建对象 
  19.   // do construct.. 
  20. } 
  21. private function __clone() {}  //在__clone()前用private修饰，用来禁止克隆 
  22. public static function getInstance() { //公共的静态方法,public——外部的接口，static——不使用对象而是通过类名访问 
  23.   if (!(self::$instance instanceof self)) { //私有静态变量$instance为空 
  24.     self::$instance = new self(); //新建为自身的对象，并赋值给私有变量$instance 
  25.   } 
  26.   return self::$instance; //返回私有变量$instance 
  27. } 
  28. // other functions.. 
  29. } 
  30. $a = SingetonBasic::getInstance(); 
  31. $b = SingetonBasic::getInstance(); 
  32. var_dump($a === $b);  //结果为：boolean true 
  33. //?> 
  34.  
  35. <?php 
  36. /** 
  37.  * php单例，单例模式为何只能实例化一次 
  38. */ 
  39. class Example{ 
  40.   // 保存类实例在此属性中 
  41.   private static $instance; 
  42.   // 构造方法声明为private，防止直接创建对象 
  43.   private function __construct(){ 
  44.     echo 'I am constructed'; 
  45.   } 
  46.   // singleton 方法 
  47.   public static function singleton(){ 
  48.     if (!isset(self::$instance)) {//判断是否以前创建了当前类的实例 
  49.       $c = __CLASS__;//获取类名 
  50.       self::$instance = new $c;//如果没有创建，实例化当前类，这里实现类只实例化一次 
  51.     } 
  52.     return self::$instance;//返回类的实例 
  53.   } 
  54.   // Example类中的普通方法 
  55.   public function bark(){ 
  56.     echo 'Woof!'; 
  57.   } 
  58.   // 阻止用户复制对象实例 
  59.   public function __clone(){ 
  60.     trigger_error('Clone is not allowed.', E_USER_ERROR); 
  61.   } 
  62. } 
  63. // 这个写法会出错，因为构造方法被声明为private 
  64. $test = new Example; 
  65. // 下面将得到Example类的单例对象 
  66. $test = Example::singleton(); 
  67. $test->bark(); 
  68. // 下面将得到Example类的单例对象 
  69. $test = Example::singleton(); 
  70. $test->bark(); 
  71. // 复制对象将导致一个E_USER_ERROR. 
  72. $test_clone = clone $test; 
  73. ?> 

关于__clone()方法可参考： PHP对象克隆__clone()介绍

2. 工厂模式

工厂模式在于可以根据输入参数或者应用程序配置的不同来创建一种专门用来实现化并返回其它类的实例的类。

工厂模式的例子：

  1. <?php 
  2. class FactoryBasic { 
  3.   public static function create($config) { 
  4.   } 
  5. } 

比如这里是一个描述形状对象的工厂，它希望根据传入的参数个数不同来创建不同的形状。

  1. <?php 
  2. // 定义形状的公共功能：获取周长和面积。 
  3. interface IShape { 
  4.   function getCircum(); 
  5.   function getArea(); 
  6. } 
  7. // 定义矩形类 
  8. class Rectangle implements IShape { 
  9.   private $width, $height; 
  10.   public function __construct($width, $height) { 
  11.     $this->width = $width; 
  12.     $this->height = $height; 
  13.   } 
  14.   public function getCircum() { 
  15.     return 2 * ($this->width + $this->height); 
  16.   } 
  17.   public function getArea() { 
  18.     return $this->width * $this->height; 
  19.   } 
  20. } 
  21. // 定义圆类 
  22. class Circle implements IShape { 
  23.   private $radii; 
  24.   public function __construct($radii) { 
  25.     $this->radii = $radii; 
  26.   } 
  27.   public function getCircum() { 
  28.     return 2 * M_PI * $this->radii; 
  29.   } 
  30.   public function getArea() { 
  31.     return M_PI * pow($this->radii, 2); 
  32.   } 
  33. } 
  34. // 根据传入的参数个数不同来创建不同的形状。 
  35. class FactoryShape { 
  36.   public static function create() { 
  37.     switch (func_num_args()) { 
  38.       case 1: 
  39.       return new Circle(func_get_arg(0)); 
  40.       break; 
  41.       case 2: 
  42.       return new Rectangle(func_get_arg(0), func_get_arg(1)); 
  43.       break; 
  44.     } 
  45.   } 
  46. } 
  47. // 矩形对象 
  48. $c = FactoryShape::create(4, 2); 
  49. var_dump($c->getArea()); 
  50. // 圆对象 
  51. $o = FactoryShape::create(2); 
  52. var_dump($o->getArea()); 

使用工厂模式使得在调用方法时变得更容易，因为它只有一个类和一个方法，若没有使用工厂模式，则要在调用时决定应该调用哪个类和哪个方法；使用工厂模式还使得未来对应用程序做改变时更加容易，比如要增加一种形状的支持，只需要修改工厂类中的create()一个方法，而没有使用工厂模式，则要修改调用形状的代码块。

3. 观察者模式

观察者模式为您提供了避免组件之间紧密耦合的另一种方法。该模式非常简单：一个对象通过添加一个方法（该方法允许另一个对象，即观察者注册自己）使本身变得可观察。当可观察的对象更改时，它会将消息发送到已注册的观察者。这些观察者使用该信息执行的操作与可观察的对象无关。结果是对象可以相互对话，而不必了解原因。

一个简单的示例：当听众在收听电台时（即电台加入一个新听众），它将发送出一条提示消息，通过发送消息的日志观察者可以观察这些消息。

  1. <?php 
  2. // 观察者接口 
  3. interface IObserver { 
  4.   function onListen($sender, $args); 
  5.   function getName(); 
  6. } 
  7. // 可被观察接口 
  8. interface IObservable { 
  9.   function addObserver($observer); 
  10.   function removeObserver($observer_name); 
  11. } 
  12. // 观察者类 
  13. abstract class Observer implements IObserver { 
  14.   protected $name; 
  15.   public function getName() { 
  16.     return $this->name; 
  17.   } 
  18. } 
  19. // 可被观察类 
  20. class Observable implements IObservable { 
  21.   protected $observers = array(); 
  22.   public function addObserver($observer) { 
  23.     if (!($observer instanceof IObserver)) { 
  24.       return; 
  25.     } 
  26.     $this->observers[] = $observer; 
  27.   } 
  28.   public function removeObserver($observer_name) { 
  29.     foreach ($this->observers as $index => $observer) { 
  30.       if ($observer->getName() === $observer_name) { 
  31.         array_splice($this->observers, $index, 1); 
  32.         return; 
  33.       } 
  34.     } 
  35.   } 
  36. } 
  37. // 模拟一个可以被观察的类：RadioStation 
  38. class RadioStation extends Observable { 
  39.   public function addListener($listener) { 
  40.     foreach ($this->observers as $observer) { 
  41.       $observer->onListen($this, $listener); 
  42.     } 
  43.   } 
  44. } 
  45. // 模拟一个观察者类 
  46. class RadioStationLogger extends Observer { 
  47.   protected $name = 'logger'; 
  48.   public function onListen($sender, $args) { 
  49.     echo $args, ' join the radiostation.<br/>'; 
  50.   } 
  51. } 
  52. // 模拟另外一个观察者类 
  53. class OtherObserver extends Observer { 
  54.   protected $name = 'other'; 
  55.   public function onListen($sender, $args) { 
  56.     echo 'other observer..<br/>'; 
  57.   } 
  58. } 
  59. $rs = new RadioStation(); 
  60. // 注入观察者 
  61. $rs->addObserver(new RadioStationLogger()); 
  62. $rs->addObserver(new OtherObserver()); 
  63. // 移除观察者 
  64. $rs->removeObserver('other'); 
  65. // 可以看到观察到的信息 
  66. $rs->addListener('cctv'); 
  67. ?>

Tags: PHP单例模式 PHP工厂模式

分享到：

相关文章

推荐文章

热门文章

最新评论文章