欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  后端开发

代码均来源于《PHP设计模式》一书

程序员文章站 2022-05-05 10:48:49
...
代码均来源于《PHP设计模式》一书
  1. ?/**
  2. * 转自 《PHP设计模式》 第六章： 装饰器模式
  3. *
  4. * 装饰器设计模式适用于下列工作场合： 需求变化是快速和细小的，而且几乎不影响应用程序的其他部分。()
  5. * 使用装饰器设计模式设计类的目标是： 不必重写任何已有的功能性代码，而是对某个基于对象应用增量变化。
  6. * 装饰器设计模式采用这样的构建方式： 在主代码流中应该能够直接插入一个或多个更改或“装饰”目标对象的装饰器，同时不影响其他代码流。
  7. *
  8. */
  9. class CD {
  10. public $trackList;
  12. public function __construct() {
  13. $this->trackList = array();
  14. }
  16. public function addTrack($track) {
  17. $this->trackList[] = $track;
  18. }
  20. public function getTrackList() {
  21. $output = '';
  23. foreach ($this->trackList as $num => $track) {
  24. $output .= ($num + 1) . ") {$track}.";
  25. }
  27. return $output;
  28. }
  29. }
  31. $tracksFroExternalSource = array("What It Means", "Brr", "Goodbye");
  33. $myCD = new CD();
  34. foreach ($tracksFroExternalSource as $track) {
  35. $myCD->addTrack($track);
  36. }
  38. print "The CD contains:{$myCD->getTrackList()}\n";
  40. /**
  41. * 需求发生小变化： 要求每个输出的参数都采用大写形式. 对于这么小的变化而言， 最佳的做法并非修改基类或创建父 - 子关系，
  42. 而是创建一个基于装饰器设计模式的对象。
  43. *
  44. */
  45. class CDTrackListDecoratorCaps {
  46. private $_cd;
  48. public function __construct(CD $cd) {
  49. $this->_cd = $cd;
  50. }
  52. public function makeCaps() {
  53. foreach ($this->_cd->trackList as & $track) {
  54. $track = strtoupper($track);
  55. }
  56. }
  57. }
  59. $myCD = new CD();
  60. foreach ($tracksFroExternalSource as $track) {
  61. $myCD->addTrack($track);
  62. }
  64. //新增以下代码实现输出参数采用大写形式
  65. $myCDCaps = new CDTrackListDecoratorCaps($myCD);
  66. $myCDCaps->makeCaps();
  68. print "The CD contains:{$myCD->getTrackList()}\n";
  70. /* End of Decorator.class.php */
  71. /* Location the file Design/Decorator.class.php */
复制代码
  1. ?/**
  2. * 转自 《PHP设计模式》 第七章： 委托模式
  3. * 当一个对象包含复杂单独立的，必须基于判决执行的功能性的若*分时，最佳的方法是适用基于委托设计模式的对象。
  4. *
  5. */
  7. /**
  8. * 示例： Web站点具有创建MP3文件播放列表的功能， 也具有选择以 M3U 或 PLS 格式下载播放列表的功能。
  9. *
  10. * 以下代码示例展示常规与委托两种模式实现
  11. *
  12. */
  13. //常规实现
  14. class Playlist {
  16. private $_songs;
  18. public function __construct() {
  19. $this->_songs = array();
  20. }
  22. public function addSong($location, $title) {
  23. $song = array("location" => $location, "title" => $title);
  24. $this->_songs[] = $song;
  25. }
  27. public function getM3U() {
  28. $m3u = "#EXTM3U\n\n";
  30. foreach ($this->_songs as $song) {
  31. $m3u .= "#EXTINF: -1, {$song['title']}\n";
  32. $m3u .= "{$song['location']}\n";
  33. }
  35. return $m3u;
  36. }
  38. public function getPLS() {
  39. $pls = "[playlist]]\nNumberOfEntries = ". count($this->_songs) . "\n\n";
  41. foreach ($this->_songs as $songCount => $song) {
  42. $counter = $songCount + 1;
  43. $pls .= "File{$counter} = {$song['location']}\n";
  44. $pls .= "Title{$counter} = {$song['title']}\n";
  45. $pls .= "LengthP{$counter} = -1 \n\n";
  46. }
  48. return $pls;
  49. }
  50. }
  52. $playlist = new Playlist();
  54. $playlist->addSong("/home/aaron/music/brr.mp3", "Brr");
  55. $playlist->addSong("/home/aaron/music/goodbye.mp3", "Goodbye");
  57. $externalRetrievedType = "pls";
  59. if ($externalRetrievedType == "pls") {
  60. $playlistContent = $playlist->getPLS();
  61. } else {
  62. $playlistContent = $playlist->getM3U();
  63. }
  65. echo $playlistContent;
  67. //委托模式实现
  68. class newPlaylist {
  70. private $_songs;
  71. private $_tyepObject;
  73. public function __construct($type) {
  74. $this->_songs = array();
  75. $object = "{$type}Playlist";
  76. $this->_tyepObject = new $object;
  77. }
  79. public function addSong($location, $title) {
  80. $song = array("location" => $location, "title" => $title);
  81. $this->_songs[] = $song;
  82. }
  84. public function getPlaylist() {
  85. $playlist = $this->_tyepObject->getPlaylist($this->_songs);
  86. return $playlist;
  87. }
  88. }
  90. class m3uPlaylist {
  91. public function getPlaylist($songs) {
  92. $m3u = "#EXTM3U\n\n";
  94. foreach ($songs as $song) {
  95. $m3u .= "#EXTINF: -1, {$song['title']}\n";
  96. $m3u .= "{$song['location']}\n";
  97. }
  99. return $m3u;
  100. }
  101. }
  103. class plsPlaylist {
  104. public function getPlaylist($songs) {
  105. $pls = "[playlist]]\nNumberOfEntries = ". count($songs) . "\n\n";
  107. foreach ($songs as $songCount => $song) {
  108. $counter = $songCount + 1;
  109. $pls .= "File{$counter} = {$song['location']}\n";
  110. $pls .= "Title{$counter} = {$song['title']}\n";
  111. $pls .= "LengthP{$counter} = -1 \n\n";
  112. }
  114. return $pls;
  115. }
  116. }
  118. $externalRetrievedType = "pls";
  119. $playlist = new newPlaylist($externalRetrievedType);
  121. $playlist->addSong("/home/aaron/music/brr.mp3", "Brr");
  122. $playlist->addSong("/home/aaron/music/goodbye.mp3", "Goodbye");
  124. $playlistContent = $playlist->getPlaylist();
  126. echo $playlistContent;
  128. /* End of Delegate.class.php */
  129. /* Location the file Design/Delegate.class.php */
复制代码
  1. ?/**
  2. * 转自 《PHP设计模式》 第八章： 外观模式
  3. * 外观设计模式的目标是： 控制外部错综复杂的关系， 并且提供简单的接口以利用上述组件的能力。
  4. * 为了隐藏复杂的，执行业务进程某个步骤所需的方法和逻辑组，就应当使用基于外观设计模式的类。
  5. *
  6. */
  7. /**
  8. * 代码示例： 获取CD对象，对其所有属性应用大写形式，并且创建一个要提交给Web服务的，格式完整的XML文档。
  9. *
  10. */
  11. class CD {
  13. public $tracks = array();
  14. public $band = '';
  15. public $title = '';
  17. public function __construct($tracks, $band, $title) {
  18. $this->tracks = $tracks;
  19. $this->band = $band;
  20. $this->title = $title;
  21. }
  23. }
  25. class CDUpperCase {
  27. public static function makeString(CD $cd, $type) {
  28. $cd->$type = strtoupper($cd->$type);
  29. }
  31. public static function makeArray(CD $cd, $type) {
  32. $cd->$type = array_map("strtoupper", $cd->$type);
  33. }
  34. }
  36. class CDMakeXML {
  38. public static function create(CD $cd) {
  39. $doc = new DomDocument();
  41. $root = $doc->createElement("CD");
  42. $root = $doc->appendChild($root);
  44. $title = $doc->createElement("TITLE", $cd->title);
  45. $title = $root->appendChild($title);
  47. $band = $doc->createElement("BAND", $cd->band);
  48. $band = $root->appendChild($band);
  50. $tracks = $doc->createElement("TRACKS");
  51. $tracks = $root->appendChild($tracks);
  53. foreach ($cd->tracks as $track) {
  54. $track = $doc->createElement("TRACK", $track);
  55. $track = $tracks->appendChild($track);
  56. }
  58. return $doc->saveXML();
  59. }
  60. }
  62. class WebServiceFacade {
  64. public static function makeXMLCall(CD $cd) {
  65. CDUpperCase::makeString($cd, "title");
  66. CDUpperCase::makeString($cd, "band");
  67. CDUpperCase::makeArray($cd, "tracks");
  69. $xml = CDMakeXML::create($cd);
  71. return $xml;
  72. }
  73. }
  75. $tracksFromExternalSource = array("What It Means", "Brr", "Goodbye");
  76. $band = "Never Again";
  77. $title = "Waster of a Rib";
  79. $cd = new CD($tracksFromExternalSource, $band, $title);
  81. $xml = WebServiceFacade::makeXMLCall($cd);
  83. echo $xml;
  86. /* End of Facade.class.php */
  87. /* Location the file Design/Facade.class.php */
复制代码
  1. ?/**
  2. * 转自 《PHP设计模式》 第九章： 工厂模式
  3. * 工厂设计模式： 提供获取某个对象的新实例的一个接口， 同时使调用代码避免确定实际实例化基类的步骤
  4. *
  5. */
  6. //基础标准CD类
  7. class CD {
  9. public $tracks = array();
  10. public $band = '';
  11. public $title = '';
  13. public function __construct() {}
  15. public function setTitle($title) {
  16. $this->title = $title;
  17. }
  19. public function setBand($band) {
  20. $this->band = $band;
  21. }
  23. public function addTrack($track) {
  24. $this->tracks[] = $track;
  25. }
  27. }
  29. //增强型CD类， 与标准CD的唯一不同是写至CD的第一个track是数据track("DATA TRACK")
  30. class enhadcedCD {
  32. public $tracks = array();
  33. public $band = '';
  34. public $title = '';
  36. public function __construct() {
  37. $this->tracks = "DATA TRACK";
  38. }
  40. public function setTitle($title) {
  41. $this->title = $title;
  42. }
  44. public function setBand($band) {
  45. $this->band = $band;
  46. }
  48. public function addTrack($track) {
  49. $this->tracks[] = $track;
  50. }
  51. }
  53. //CD工厂类，实现对以上两个类具体实例化操作
  54. class CDFactory {
  56. public static function create($type) {
  57. $class = strtolower($type) . "CD";
  59. return new $class;
  60. }
  61. }
  63. //实例操作
  64. $type = "enhadced";
  66. $cd = CDFactory::create($type);
  68. $tracksFromExternalSource = array("What It Means", "Brr", "Goodbye");
  70. $cd->setBand("Never Again");
  71. $cd->setTitle("Waste of a Rib");
  72. foreach ($tracksFromExternalSource as $track) {
  73. $cd->addTrack($track);
  74. }
  77. /* End of Factory.class.php */
  78. /* End of file Design/Factory.class.php */
复制代码
  1. ?/**
  2. * 转自 《PHP设计模式》 第十章： 解释器模式
  3. * 解释器： 解释器设计模式用于分析一个实体的关键元素，并且针对每个元素都提供自己的解释或相应的动作。
  4. * 解释器设计模式最常用于PHP/HTML 模板系统。
  5. *
  6. */
  7. class User {
  9. protected $_username = "";
  11. public function __construct($username) {
  12. $this->_username = $username;
  13. }
  15. public function getProfilePage() {
  16. $profile = "

    I like Never Again !

    ";
  17. $profile .= "I love all of their songs. My favorite CD:
    ";
  18. $profile .= "{{myCD.getTitle}}!!";
  20. return $profile;
  21. }
  22. }
  24. class userCD {
  26. protected $_user = NULL;
  28. public function setUser(User $user) {
  29. $this->_user = $user;
  30. }
  32. public function getTitle() {
  33. $title = "Waste of a Rib";
  35. return $title;
  36. }
  37. }
  39. class userCDInterpreter {
  41. protected $_user = NULL;
  43. public function setUser(User $user) {
  44. $this->_user = $user;
  45. }
  47. public function getInterpreted() {
  48. $profile = $this->_user->getProfilePage();
  50. if (preg_match_all('/\{\{myCD\.(.*?)\}\}/', $profile, $triggers, PREG_SET_ORDER)) {
  51. $replacements = array();
  53. foreach ($triggers as $trigger) {
  54. $replacements[] = $trigger[1];
  55. }
  57. $replacements = array_unique($replacements);
  59. $myCD = new userCD();
  60. $myCD->setUser($this->_user);
  62. foreach ($replacements as $replacement) {
  63. $profile = str_replace("{{myCD.{$replacement}}}", call_user_func(array($myCD, $replacement)), $profile);
  64. }
  65. }
  67. return $profile;
  68. }
  70. }
  72. $username = "aaron";
  73. $user = new User($username);
  74. $interpreter = new userCDInterpreter();
  75. $interpreter->setUser($user);
  77. print "

    {$username}'s Profile

    ";
  78. print $interpreter->getInterpreted();
  80. /* End of Interpreter.class.php */
  81. /* Location the file Design/Interpreter.class.php */
复制代码
  1. ?/**
  2. * 转自 《PHP设计模式》 第十一章： 迭代器模式
  3. * 迭代器：迭代器设计模式可帮助构造特定对象， 那些对象能够提供单一标准接口循环或迭代任何类型的可计数数据。
  4. * 处理需要遍历的可计数数据时， 最佳的解决办法是创建一个基于迭代器设计模式的对象。
  5. *
  6. */
  7. class CD {
  9. public $band = "";
  10. public $title = "";
  11. public $trackList = array();
  13. public function __construct($band, $title) {
  14. $this->band = $band;
  15. $this->title = $title;
  16. }
  18. public function addTrack($track) {
  19. $this->trackList[] = $track;
  20. }
  21. }
  23. class CDSearchByBandIterator implements Iterator {
  25. private $_CDs = array();
  26. private $_valid = FALSE;
  28. public function __construct($bandName) {
  29. $db = mysql_connect("localhost", "root", "root");
  30. mysql_select_db("test");
  32. $sql = "select CD.id, CD.band, CD.title, tracks.tracknum, tracks.title as tracktitle ";
  33. $sql .= "from CD left join tracks on CD.id = tracks.cid ";
  34. $sql .= "where band = '" . mysql_real_escape_string($bandName) . "' ";
  35. $sql .= "order by tracks.tracknum";
  37. $results = mysql_query($sql);
  39. $cdID = 0;
  40. $cd = NULL;
  42. while ($result = mysql_fetch_array($results)) {
  43. if ($result["id"] !== $cdID) {
  44. if ( ! is_null($cd)) {
  45. $this->_CDs[] = $cd;
  46. }
  48. $cdID = $result['id'];
  49. $cd = new CD($result['band'], $result['title']);
  50. }
  52. $cd->addTrack($result['tracktitle']);
  53. }
  55. $this->_CDs[] = $cd;
  56. }
  58. public function next() {
  59. $this->_valid = (next($this->_CDs) === FALSE) ? FALSE : TRUE;
  60. }
  62. public function rewind() {
  63. $this->_valid = (reset($this->_CDs) === FALSE) ? FALSE : TRUE;
  64. }
  66. public function valid() {
  67. return $this->_valid;
  68. }
  70. public function current() {
  71. return current($this->_CDs);
  72. }
  74. public function key() {
  75. return key($this->_CDs);
  76. }
  77. }
  79. $queryItem = "Never Again";
  81. $cds = new CDSearchByBandIterator($queryItem);
  83. print "

    Found the Following CDs

    ";
  84. print "";
  85. foreach ($cds as $cd) {
  86. print "
    87. ";
  87. }
  88. print "
    89. Band Ttile Num Tracks
    {$cd->band} {$cd->title} ";
  89. print count($cd->trackList). "
    		90.
    ";
  91. /* End of Iterator.class.php */
  92. /* Location the file Design/Iterator.class.php */
复制代码
  1. ?/**
  2. * 转自 《PHP设计模式》 第十二章： 中介者模式
  3. * 中介者: 中介者设计莫用于开发一个对象，这个对象能够在类似对象相互之间不直接交互的情况下传送或调节对这些对象的集合的修改
  4. * 处理具有类似属性并且属性需要保持同步的非耦合对象时，最佳的做法是使用基于中介者设计模式的对象。
  5. *
  6. */
  7. /**
  8. * 测试用例描述：示例代码不仅允许乐队进入和管理他们的音乐合集，而且还允许乐队更新他们的配置文件，修改乐队相关信息以及更新其CD信息
  9. *　　　　　　　 现在，艺术家可上传MP3集合并从Web站点撤下CD。 因此， Web站点需要保持相对应的CD和MP3彼此同步。
  10. *
  11. */
  12. //CD类
  13. class CD {
  15. public $band = '';
  16. public $title = '';
  17. protected $_mediator;
  19. public function __construct(MusicContainerMediator $mediator = NULL) {
  20. $this->_mediator = $mediator;
  21. }
  23. public function save() {
  24. //具体实现待定
  25. var_dump($this);
  26. }
  28. public function changeBandName($bandname) {
  29. if ( ! is_null($this->_mediator)) {
  30. $this->_mediator->change($this, array("band" => $bandname));
  31. }
  32. $this->band = $bandname;
  33. $this->save();
  34. }
  35. }
  37. //MP3Archive类
  38. class MP3Archive {
  40. protected $_mediator;
  42. public function __construct(MusicContainerMediator $mediator = NULL) {
  43. $this->_mediator = $mediator;
  44. }
  46. public function save() {
  47. //具体实现待定
  48. var_dump($this);
  49. }
  51. public function changeBandName($bandname) {
  52. if ( ! is_null($this->_mediator)) {
  53. $this->_mediator->change($this, array("band" => $bandname));
  54. }
  55. $this->band = $bandname;
  56. $this->save();
  57. }
  58. }
  60. //中介者类
  61. class MusicContainerMediator {
  63. protected $_containers = array();
  65. public function __construct() {
  66. $this->_containers[] = "CD";
  67. $this->_containers[] = "MP3Archive";
  68. }
  70. public function change($originalObject, $newValue) {
  71. $title = $originalObject->title;
  72. $band = $originalObject->band;
  74. foreach ($this->_containers as $container) {
  75. if ( ! ($originalObject instanceof $container)) {
  76. $object = new $container;
  77. $object->title = $title;
  78. $object->band = $band;
  80. foreach ($newValue as $key => $val) {
  81. $object->$key = $val;
  82. }
  84. $object->save();
  85. }
  86. }
  87. }
  88. }
  90. //测试实例
  91. $titleFromDB = "Waste of a Rib";
  92. $bandFromDB = "Never Again";
  94. $mediator = new MusicContainerMediator();
  96. $cd = new CD($mediator);
  97. $cd->title = $titleFromDB;
  98. $cd->band = $bandFromDB;
  100. $cd->changeBandName("Maybe Once More");
  102. /* End of Mediator.class.php */
  103. /* Location the file Design/Mediator.class.php */
复制代码
  1. /*
  2. SQLyog 企业版 - MySQL GUI v8.14
  3. MySQL - 5.1.52-community : Database - test
  4. *********************************************************************
  5. */
  7. /*!40101 SET NAMES utf8 */;
  9. /*!40101 SET SQL_MODE=''*/;
  11. /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
  12. /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
  13. /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
  14. /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
  15. /*Table structure for table `cd` */
  17. DROP TABLE IF EXISTS `cd`;
  19. CREATE TABLE `cd` (
  20. `id` int(8) NOT NULL AUTO_INCREMENT,
  21. `band` varchar(500) COLLATE latin1_bin NOT NULL DEFAULT '',
  22. `title` varchar(500) COLLATE latin1_bin NOT NULL DEFAULT '',
  23. `bought` int(8) DEFAULT NULL,
  24. `amount` int(8) DEFAULT NULL,
  25. PRIMARY KEY (`id`)
  26. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=latin1 COLLATE=latin1_bin;
  28. /*Data for the table `cd` */
  30. insert into `cd`(`id`,`band`,`title`,`bought`,`amount`) values (1,'Never Again','Waster of a Rib',1,98);
  32. /*Table structure for table `tracks` */
  34. DROP TABLE IF EXISTS `tracks`;
  36. CREATE TABLE `tracks` (
  37. `cid` int(8) DEFAULT NULL,
  38. `tracknum` int(8) DEFAULT NULL,
  39. `title` varchar(500) COLLATE latin1_bin NOT NULL DEFAULT ''
  40. ) ENGINE=InnoDB DEFAULT CHARSET=latin1 COLLATE=latin1_bin;
  42. /*Data for the table `tracks` */
  44. insert into `tracks`(`cid`,`tracknum`,`title`) values (1,3,'What It Means'),(1,3,'Brr'),(1,3,'Goodbye');
  46. /*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
  47. /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
  48. /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
  49. /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
复制代码
相关标签： 代码均来源于《PHP设计模式》一书

上一篇： JavaScript函数详解_基础知识

下一篇： ODI中新增插件(OpenTools)介绍

推荐阅读