The codes are all from the book 'PHP Design Patterns'

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

?/**
 * Reprinted from "PHP Design Patterns" Chapter 6: Decorator Pattern
 *
 * The decorator design pattern is suitable for the following workplaces: Changes in requirements are fast and small, and have little impact on other parts of the application. ()
 * The goal of designing a class using the decorator design pattern is to apply incremental changes to an object without having to rewrite any existing functional code.
 * The decorator design pattern is built in such a way that it should be possible to directly insert one or more decorators that change or "decorate" the target object in the main code flow without affecting other code flows.
 *
*/
class CD {
	public $trackList;

	public function __construct() {
		$this->trackList = array();
	}

	public function addTrack($track) {
		$this->trackList[] = $track;
	}

	public function getTrackList() {
		$output = '';

		foreach ($this->trackList as $num => $track) {
			$output .= ($num + 1) . ") {$track}.";
		}

		return $output;
	}
}

$tracksFroExternalSource = array("What It Means", "Brr", "Goodbye");

$myCD = new CD();
foreach ($tracksFroExternalSource as $track) {
	$myCD->addTrack($track);
}

print "The CD contains:{$myCD->getTrackList()}n";

/**
 * Small change in requirements: require each output parameter to be in uppercase. For such a small change, the best approach is not to modify the base class or create a parent-child relationship,
 but to create a decorator-based design Pattern object.
 *
*/
class CDTrackListDecoratorCaps {
	private $_cd;

	public function __construct(CD $cd) {
		$this->_cd = $cd;
	}

	public function makeCaps() {
		foreach ($this->_cd->trackList as & $track) {
			$track = strtoupper($track);
		}
	}
}

$myCD = new CD();
foreach ($tracksFroExternalSource as $track) {
	$myCD->addTrack($track);
}

//新增以下代码实现输出参数采用大写形式
$myCDCaps = new CDTrackListDecoratorCaps($myCD);
$myCDCaps->makeCaps();

print "The CD contains:{$myCD->getTrackList()}n";

/* End of Decorator.class.php */
/* Location the file Design/Decorator.class.php */

?/**
 * Reprinted from "PHP Design Patterns" Chapter 7: Delegation Pattern
 * When an object contains several parts of complex, independent functionality that must be executed based on decisions, the best method is to apply an object based on the delegation design pattern.
 *
*/

/**
 * Example: The website has the function of creating a playlist of MP3 files, and also has the function of selecting to download the playlist in M3U or PLS format.
 *
 * The following code examples show the implementation of two modes, regular and delegated
 *
*/
//常规实现
class Playlist {

	private $_songs;

	public function __construct() {
		$this->_songs = array();
	}

	public function addSong($location, $title) {
		$song = array("location" => $location, "title" => $title);
		$this->_songs[] = $song;
	}

	public function getM3U() {
		$m3u = "#EXTM3Unn";

		foreach ($this->_songs as $song) {
			$m3u .= "#EXTINF: -1, {$song['title']}n";
			$m3u .= "{$song['location']}n";
		}

		return $m3u;
	}

	public function getPLS() {
		$pls = "[playlist]]nNumberOfEntries = ". count($this->_songs) . "nn";

		foreach ($this->_songs as $songCount => $song) {
			$counter = $songCount + 1;
			$pls .= "File{$counter} = {$song['location']}n";
			$pls .= "Title{$counter} = {$song['title']}n";
			$pls .= "LengthP{$counter} = -1 nn";
		}

		return $pls;
	}
}

$playlist = new Playlist();

$playlist->addSong("/home/aaron/music/brr.mp3", "Brr");
$playlist->addSong("/home/aaron/music/goodbye.mp3", "Goodbye");

$externalRetrievedType = "pls";

if ($externalRetrievedType == "pls") {
	$playlistContent =  $playlist->getPLS();
} else {
	$playlistContent =  $playlist->getM3U();
}

echo $playlistContent;

//委托模式实现
class newPlaylist {

	private $_songs;
	private $_tyepObject;

	public function __construct($type) {
		$this->_songs = array();
		$object = "{$type}Playlist";
		$this->_tyepObject = new $object;
	}

	public function addSong($location, $title) {
		$song = array("location" => $location, "title" => $title);
		$this->_songs[] = $song;
	}

	public function getPlaylist() {
		$playlist = $this->_tyepObject->getPlaylist($this->_songs);
		return $playlist;
	}
}

class m3uPlaylist {
	public function getPlaylist($songs) {
		$m3u = "#EXTM3Unn";

		foreach ($songs as $song) {
			$m3u .= "#EXTINF: -1, {$song['title']}n";
			$m3u .= "{$song['location']}n";
		}

		return $m3u;
	}
}

class plsPlaylist {
	public function getPlaylist($songs) {
		$pls = "[playlist]]nNumberOfEntries = ". count($songs) . "nn";

		foreach ($songs as $songCount => $song) {
			$counter = $songCount + 1;
			$pls .= "File{$counter} = {$song['location']}n";
			$pls .= "Title{$counter} = {$song['title']}n";
			$pls .= "LengthP{$counter} = -1 nn";
		}

		return $pls;
	}
}

$externalRetrievedType = "pls";
$playlist = new newPlaylist($externalRetrievedType);

$playlist->addSong("/home/aaron/music/brr.mp3", "Brr");
$playlist->addSong("/home/aaron/music/goodbye.mp3", "Goodbye");

$playlistContent = $playlist->getPlaylist();

echo $playlistContent;

/* End of Delegate.class.php */
/* Location the file Design/Delegate.class.php */

?/**
 * Reprinted from "PHP Design Patterns" Chapter 8: Appearance Pattern
 * The goal of the Appearance Design Pattern is to: control the intricate external relationships, and provide a simple interface to utilize the capabilities of the above components.
 * In order to hide the complex methods and logical groups required to perform a certain step of the business process, classes based on the appearance design pattern should be used.
 *
*/
/**
 * Code example: Get the CD object, apply uppercase to all its properties, and create a fully formatted XML document to be submitted to the web service.
 *
*/
class CD {

	public $tracks = array();
	public $band   = '';
	public $title  = '';

	public function __construct($tracks, $band, $title) {
		$this->tracks = $tracks;
		$this->band   = $band;
		$this->title  = $title;
	}

}

class CDUpperCase {

	public static function makeString(CD $cd, $type) {
		$cd->$type = strtoupper($cd->$type);
	}

	public static function makeArray(CD $cd, $type) {
		$cd->$type = array_map("strtoupper", $cd->$type);
	}
}

class CDMakeXML {

	public static function create(CD $cd) {
		$doc  = new DomDocument();

		$root = $doc->createElement("CD");
		$root = $doc->appendChild($root);

		$title = $doc->createElement("TITLE", $cd->title);
		$title = $root->appendChild($title);

		$band = $doc->createElement("BAND", $cd->band);
		$band = $root->appendChild($band);

		$tracks = $doc->createElement("TRACKS");
		$tracks = $root->appendChild($tracks);

		foreach ($cd->tracks as $track) {
			$track = $doc->createElement("TRACK", $track);
			$track = $tracks->appendChild($track);
		}

		return $doc->saveXML();
	}
}

class WebServiceFacade {

	public static function makeXMLCall(CD $cd) {
		CDUpperCase::makeString($cd, "title");
		CDUpperCase::makeString($cd, "band");
		CDUpperCase::makeArray($cd, "tracks");

		$xml = CDMakeXML::create($cd);

		return $xml;
	}
}

$tracksFromExternalSource = array("What It Means", "Brr", "Goodbye");
$band  = "Never Again";
$title = "Waster of a Rib";

$cd = new CD($tracksFromExternalSource, $band, $title);

$xml = WebServiceFacade::makeXMLCall($cd);

echo $xml;


/* End of Facade.class.php */
/* Location the file Design/Facade.class.php */

?/**
 * Reprinted from "PHP Design Patterns" Chapter 9: Factory Pattern
 * Factory Design Pattern: Provides an interface to obtain a new instance of an object, while allowing the calling code to avoid determining the steps to actually instantiate the base class
 *
*/
//Basic standard CD class
class CD {

 public $tracks = array();
 public $band = '';
 public $ title = '';

 public function __construct() {}

 public function setTitle($title) {
 $this->title = $title;
 }

 public function setBand($band) {
 $this ->band = $band;
 }

 public function addTrack($track) {
 $this->tracks[] = $track;
 }

}

//Enhanced CD class, and standard CD The only difference is that the first track written to CD is the data track("DATA TRACK")
class enhadcedCD {

 public $tracks = array();
 public $band = '';
 public $title = '' ;

 public function __construct() {
 $this->tracks = "DATA TRACK";
 }

 public function setTitle($title) {
 $this->title = $title;
 }

 public function setBand($band) {
 $this->band = $band;
 }

 public function addTrack($track) {
 $this->tracks[] = $track;
 }
}

/ /CD factory class, implements the specific instantiation operation of the above two classes
class CDFactory {

 public static function create($type) {
 $class = strtolower($type) . "CD";

 return new $class ;
 }
}

//Instance operation
$type = "enhadced";

$cd = CDFactory::create($type);

$tracksFromExternalSource = array("What It Means", "Brr", "Goodbye");

$cd->setBand("Never Again");
$cd->setTitle("Waste of a Rib");
foreach ($tracksFromExternalSource as $track) {
 $cd- >addTrack($track);
}


/* End of Factory.class.php */
/* End of file Design/Factory.class.php */

?/**
 * Reprinted from "PHP Design Patterns" Chapter 10: Interpreter Pattern
 * Interpreter: The interpreter design pattern is used to analyze the key elements of an entity and provide its own explanation or corresponding action for each element.
 * The interpreter design pattern is most commonly used in PHP/HTML template systems.
 *
*/
class User {

 protected $_username = "";

 public function __construct($username) {
 $this->_username = $ username;
 }

 public function getProfilePage() {
 $profile = "I like Never Again ! ";
 $profile .= "I love all of their songs. My favorite CD: ";
 $profile .= "{{myCD.getTitle}}!!";

 return $profile;
 }
}

class userCD {

 protected $_user = NULL;

 public function setUser(User $user) {
 $this->_user = $user;
 }

 public function getTitle() {
 $title = "Waste of a Rib";

 return $title;
 }
 }

class userCDInterpreter {

 protected $_user = NULL;

 public function setUser(User $user) {
 $this->_user = $user;
 }

 public function getInterpreted() {
 $profile = $this->_user->getProfilePage();

 if (preg_match_all('/{{myCD.(.*?)}}/', $profile, $triggers, PREG_SET_ORDER)) {
 $replacements = array ();

 foreach ($triggers as $trigger) {
 $replacements[] = $trigger[1];
 }

 $replacements = array_unique($replacements);

 $myCD = new userCD();
 $myCD->setUser($this->_user);

 foreach ($replacements as $replacement) {
 $profile = str_replace("{{myCD.{$replacement}}}", call_user_func(array($ myCD, $replacement)), $profile);
 }
 }

 return $profile;
 }

}

$username = "aaron";
$user = new User($username);
$interpreter = new userCDInterpreter();
$interpreter->setUser($user);

print "{$username}'s Profile";
print $interpreter->getInterpreted();

/* End of Interpreter.class.php */
/* Location the file Design/Interpreter.class.php */

?/**
 * Reprinted from "PHP Design Patterns" Chapter 11: Iterator Pattern
 * Iterator: The iterator design pattern helps construct specific objects that can provide a single standard interface for looping or iterating any type of countable data.
 * When dealing with countable data that needs to be traversed, the best solution is to create an object based on the iterator design pattern.
 *
*/
class CD {

	public $band  = "";
	public $title = "";
	public $trackList = array();

	public function __construct($band, $title) {
		$this->band  = $band;
		$this->title = $title;
	}

	public function addTrack($track) {
		$this->trackList[] = $track;
	}
}

class CDSearchByBandIterator implements Iterator {

	private $_CDs   = array();
	private $_valid = FALSE;

	public function __construct($bandName) {
		$db = mysql_connect("localhost", "root", "root");
		mysql_select_db("test");

		$sql  = "select CD.id, CD.band, CD.title, tracks.tracknum, tracks.title as tracktitle ";
		$sql .= "from CD left join tracks on CD.id = tracks.cid ";
		$sql .= "where band = '" . mysql_real_escape_string($bandName) . "' ";
		$sql .= "order by tracks.tracknum";

		$results = mysql_query($sql);

		$cdID = 0;
		$cd   = NULL;

		while ($result = mysql_fetch_array($results)) {
			if ($result["id"] !== $cdID) {
				if ( ! is_null($cd)) {
					$this->_CDs[] = $cd;
				}

				$cdID = $result['id'];
				$cd   = new CD($result['band'], $result['title']);
			}

			$cd->addTrack($result['tracktitle']);
		}

		$this->_CDs[] = $cd;
	}

	public function next() {
		$this->_valid = (next($this->_CDs) === FALSE) ? FALSE : TRUE;
	}

	public function rewind() {
		$this->_valid = (reset($this->_CDs) === FALSE) ? FALSE : TRUE;
	}

	public function valid() {
		return $this->_valid;
	}

	public function current() {
		return current($this->_CDs);
	}

	public function key() {
		return key($this->_CDs);
	}
}

$queryItem = "Never Again";

$cds = new CDSearchByBandIterator($queryItem);

print "Found the Following CDs";
print "";foreach ($cds as $cd) {	print "";}print "

Band
Ttile
Num Tracks


{$cd->band}
{$cd->title}
";	print count($cd->trackList). "




";

/* End of Iterator.class.php */
/* Location the file Design/Iterator.class.php */

?/**
 * Reprinted from "PHP Design Patterns" Chapter 12: Mediator Pattern
 * Mediator: Mediator design should not be used to develop an object that can transmit or mediate interactions between similar objects without direct interaction with each other. Modifications to collections of these objects
 * When dealing with uncoupled objects that have similar properties and whose properties need to be kept in sync, the best practice is to use objects based on the Mediator design pattern.
 *
*/
/**
 * Test case description: The sample code not only allows the band to enter and manage their music collection, but also allows the band to update their configuration files, modify band related information and update their CD information
 *　　　　 Artists can now upload MP3 collections and download them from the Web The site pulled the CD. Therefore, the Web site needs to keep the corresponding CDs and MP3s synchronized with each other.
 *
*/
//CD类
class CD {

	public $band  = '';
	public $title = '';
	protected $_mediator;

	public function __construct(MusicContainerMediator $mediator = NULL) {
		$this->_mediator = $mediator;
	}

	public function save() {
		//具体实现待定
		var_dump($this);
	}

	public function changeBandName($bandname) {
		if ( ! is_null($this->_mediator)) {
			$this->_mediator->change($this, array("band" => $bandname));
		}
		$this->band = $bandname;
		$this->save();
	}
}

//MP3Archive类
class MP3Archive {

	protected $_mediator;

	public function __construct(MusicContainerMediator $mediator = NULL) {
		$this->_mediator = $mediator;
	}

	public function save() {
		//具体实现待定
		var_dump($this);
	}

	public function changeBandName($bandname) {
		if ( ! is_null($this->_mediator)) {
			$this->_mediator->change($this, array("band" => $bandname));
		}
		$this->band = $bandname;
		$this->save();
	}
}

//中介者类
class MusicContainerMediator {

	protected $_containers = array();

	public function __construct() {
		$this->_containers[] = "CD";
		$this->_containers[] = "MP3Archive";
	}

	public function change($originalObject, $newValue) {
		$title = $originalObject->title;
		$band  = $originalObject->band;

		foreach ($this->_containers as $container) {
			if ( ! ($originalObject instanceof $container)) {
				$object = new $container;
				$object->title = $title;
				$object->band  = $band;

				foreach ($newValue as $key => $val) {
					$object->$key = $val;
				}

				$object->save();
			}
		}
	}
}

//测试实例
$titleFromDB = "Waste of a Rib";
$bandFromDB  = "Never Again";

$mediator = new MusicContainerMediator();

$cd = new CD($mediator);
$cd->title = $titleFromDB;
$cd->band  = $bandFromDB;

$cd->changeBandName("Maybe Once More");

/* End of Mediator.class.php */
/* Location the file Design/Mediator.class.php */

/*
SQLyog 企业版 - MySQL GUI v8.14
MySQL - 5.1.52-community : Database - test
*********************************************************************
*/

/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
/*Table structure for table `cd` */

DROP TABLE IF EXISTS `cd`;

CREATE TABLE `cd` (
  `id` int(8) NOT NULL AUTO_INCREMENT,
  `band` varchar(500) COLLATE latin1_bin NOT NULL DEFAULT '',
  `title` varchar(500) COLLATE latin1_bin NOT NULL DEFAULT '',
  `bought` int(8) DEFAULT NULL,
  `amount` int(8) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=latin1 COLLATE=latin1_bin;

/*Data for the table `cd` */

insert  into `cd`(`id`,`band`,`title`,`bought`,`amount`) values (1,'Never Again','Waster of a Rib',1,98);

/*Table structure for table `tracks` */

DROP TABLE IF EXISTS `tracks`;

CREATE TABLE `tracks` (
  `cid` int(8) DEFAULT NULL,
  `tracknum` int(8) DEFAULT NULL,
  `title` varchar(500) COLLATE latin1_bin NOT NULL DEFAULT ''
) ENGINE=InnoDB DEFAULT CHARSET=latin1 COLLATE=latin1_bin;

/*Data for the table `tracks` */

insert  into `tracks`(`cid`,`tracknum`,`title`) values (1,3,'What It Means'),(1,3,'Brr'),(1,3,'Goodbye');

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;