php精粹php设计模式

1，选择一个最合适的设计模式

没有任何事物是完美的，也没有人说过设计模式一个严格的放之四海而皆准的解决方法。因此你可以改变这些模式，使它们更适合手头的工作。对于某些设计模式而言，他们就是所属程序固有的天性；而对于其他的一些设计模式，你可以改变其自身的模式。模式之间互相配合、协同工作已经很常见。它们构成了整个应用（至少一部分）的基础。

2.单例模式

3. // The Database class represents our global DB connection

4. class Database{
5. // A static variable to hold our single instance
6. private static $_instance = null;
8. // Make the constructor private to ensure singleton
9. private function __construct()
10. {
11. echo 'constructor';
12. }

13. // A method to get our singleton instance

14. public static function getInstance()
15. {
16. if (!(self::$_instance instanceof Database)) {
17. self::$_instance = new Database();
18. }
20. return self::$_instance;
21. }
22. }

23. $database = Database::getInstance();

24. var_dump($database);

问题：使用单例模式不能创建两个实例，可用Traits解决创建两个不同类型的实例的问题,但仍然不能解决创建两个相同实例的问题（可用注册表模式解决）。

创建两个不同类的实例 代码：

2. trait Singleton {
3. private static $_instance = null;
5. public static function getInstance() {
6. $class = __CLASS__;
8. if(!(self::$_instance instanceof $class)) {
9. self::$_instance = new $class;
10. }
12. return self::$_instance;
13. }
15. }
16. class DB {
17. }
19. class DBWriteConnection extends DB {
20. use Singleton;
22. private function __construct() {
23. echo 'DBWriteConnection
    ';
24. }
25. }
27. class DBReadConnection extends DB {
28. use Singleton;
30. private function __construct() {
31. echo 'DBReadConnection
    ';
32. }
33. }
35. $dbWriteConnection = DBWriteConnection::getInstance();
36. var_dump($dbWriteConnection);

3.注册表模式 注册表模式仅仅是一个单独的全局类，在你需要的时候允许代码检索一个对象的相同实例，也可以在你需要的时创建另一个实例（一经要求将再次访问那些全局实例）。

Registry类：

3. class Registry {

4. /**
5. * @var array The store for all of our objects
6. */
7. static private $_store = array();
9. /**
10. * Add an object to the registry
11. *
12. * If you do not specify a name the classname is used
13. *
14. * @param mixed $object The object to store
15. * @param string $name Name used to retrieve the object
16. * @return void
17. * @throws Exception
18. */
19. static public function add($object, $name = null)
20. {
21. // Use the classname if no name given, simulates singleton
22. $name = (!is_null($name)) ?$name:get_class($object);
23. if (isset(self::$_store[$name])) {
24. throw new Exception("Object already exists in registry");
25. }
27. self::$_store[$name]= $object;
28. }
30. /**
31. * Get an object from the registry
32. *
33. * @param string $name Object name, {@see self::set()}
34. * @return mixed
35. * @throws Exception
36. */
37. static public function get($name)
38. {
39. if (!self::contains($name)) {
40. throw new Exception("Object does not exist in registry");
41. }

42. return self::$_store[$name];

43. }
45. /**
46. * Check if an object is in the registry
47. *
48. * @param string $name Object name, {@see self::set()}
49. * @return bool
50. */
51. static public function contains($name)
52. {
53. if (!isset(self::$_store[$name])) {
54. return false;
55. }
57. return true;
58. }
60. /**
61. * Remove an object from the registry
62. *
63. * @param string $name Object name, {@see self::set()}
64. * @returns void
65. */
66. static public function remove($name)
67. {
68. if (self::contains($name)) {
69. unset(self::$_store[$name]);
70. }
71. }
72. }

在类外部，使用Registry类：

3. require 'Registry.php';

4. class DBReadConnection {}

5. class DBWriteConnection {}

6. $read = new DBReadConnection;

7. Registry::add($read);

8. $write = new DBWriteConnection;

9. Registry::add($write);

10. // To get the instances, anywhere in our code:

11. $read = Registry::get('DBReadConnection');
12. $write = Registry::get('DBWriteConnection');

13. var_dump($read);

14. var_dump($write);

在类内部使用Registry表类，使用者不与Registry交互。

示例代码：

3. require 'Registry.php';

4. abstract class DBConnection {

5. static public function getInstance($name = null)
6. {
7. // Get the late-static-binding version of __CLASS__
8. $class = get_called_class();
9. // Allow passing in a name to get multiple instances
10. // If you do not pass a name, it functions as a singleton
11. $name = (!is_null($name)) ? $name:$class;
12. if (!Registry::contains($name)) {
13. $instance = new $class();
14. Registry::add($instance, $name);
15. }
16. return Registry::get($name);
17. }
18. }

19. class DBWriteConnection extends DBConnection {

20. public function __construct()
21. {
22. echo 'DBWriteConnection
    ';
23. }
24. }

25. class DBReadConnection extends DBConnection {

26. public function __construct()
27. {
28. echo 'DBReadConnection
    ';
29. }
30. }

31. $dbWriteConnection = DBWriteConnection::getInstance('abc');

32. var_dump($dbWriteConnection);
33. $dbReadConnection = DBReadConnection::getInstance();
34. var_dump($dbReadConnection);

4.工厂模式 工厂（factory）模式制造对象，就像工业界与它同名的钢筋混泥土行业一样。通常，我们将工厂模式用于初始化相同抽象类或者接口的具体实现。

在通常方式下，虽然人们极少采用工厂模式，但是它仍是最适合初始化基于驱动安装的许多变种的一种。例如不同的配置、会话或缓存存储引擎。工厂模式的最大价值在于它可以将多个对象设置封装成单一、简单的方法调用。

2. /**
3. * Log Factory
4. *
5. * Setup and return a file, mysql, or sqlite logger
6. */
7. class Log_Factory {
8. /**
9. * Get a log object
10. *
11. * @param string $type The type of logging backend, file, mysql or sqlite
12. * @param array $options Log class options
13. */
14. public function getLog($type = 'file', array $options)
15. {
16. // Normalize the type to lowercase
17. $type = strtolower($type);
19. // Figure out the class name and include it
20. $class = "Log_" .ucfirst($type);
21. require_once str_replace('_', DIRECTORY_SEPARATOR, $class) . '.php';
23. // Instantiate the class and set the appropriate options
24. $log = new $class($options);
25. switch ($type) {
26. case 'file':
27. $log->setPath($options['location']);
28. break;
29. case 'mysql':
30. $log->setUser($options['username']);
31. $log->setPassword($options['password']);
32. $log->setDBName($options['location']);
33. break;
34. case 'sqlite':
35. $log->setDBPath($otions['location']);
36. break;
37. }
39. return $log;
40. }
41. }

5.迭代模式 迭代模式允许我们将foreach的性能添加到任何对象的内部存储数据，而不仅仅添加到公共属性。它覆盖了默认的foreach行为，并允许我们为循环注入业务逻辑。

（1）使用Iterator迭代器接口

3. class BasicIterator implements Iterator {

4. private $key = 0;
5. private $data = array(
6. "hello",
7. "world",
8. );

9. public function __construct() {

10. $this->key = 0;
11. }

12. public function rewind() {

13. $this->key = 0;
14. }

15. public function current() {

16. return $this->data[$this->key];
17. }

18. public function key() {

19. return $this->key;
20. }

21. public function next() {

22. $this->key++;
23. return true;
24. }

25. public function valid() {

26. return isset($this->data[$this->key]);
27. }
28. }

29. $iterator = new BasicIterator();

30. $iterator->rewind();

31. do {

32. $key = $iterator->key();
33. $value = $iterator->current();
34. echo $key .': ' .$value . PHP_EOL;
35. } while ($iterator->next() && $iterator->valid());

37. $iterator = new BasicIterator();
38. foreach ($iterator as $key => $value) {
39. echo $key .': ' .$value . PHP_EOL;
40. }

（2）使用RecursiveIteratorIterator迭代器遍历数组

3. $array = array(

4. "Hello", // Level 1
5. array(
6. "World" // Level 2
7. ),
8. array(
9. "How", // Level 2
10. array(
11. "are", // Level 3
12. "you" // Level 3
13. )
14. ),
15. "doing?" // Level 1
16. );

17. $recursiveIterator = new RecursiveArrayIterator($array);

18. $recursiveIteratorIterator = new RecursiveIteratorIterator($recursiveIterator);

19. foreach ($recursiveIteratorIterator as $key => $value) {

20. echo "Depth: " . $recursiveIteratorIterator->getDepth() . PHP_EOL;
21. echo "Key: " . $key . PHP_EOL;
22. echo "Value: " .$value . PHP_EOL;
23. }

（3）用FilterIterator迭代器实现过滤

3. class EvenFilterIterator extends FilterIterator {

4. /**
5. * Accept only even-keyed values
6. *
7. * @return bool
8. */
9. public function accept()
10. {
11. // Get the actual iterator
12. $iterator = $this->getInnerIterator();
14. // Get the current key
15. $key = $iterator->key();
17. // Check for even keys
18. if ($key % 2 == 0) {
19. return true;
20. }
22. return false;
23. }
24. }

25. $array = array(

26. 0 => "Hello",
27. 1 => "Everybody Is",
28. 2 => "I'm",
29. 3 => "Amazing",
30. 4 => "The",
31. 5 => "Who",
32. 6 => "Doctor",
33. 7 => "Lives"
34. );

35. // Create an iterator from our array

36. $iterator = new ArrayIterator($array);

37. // Create our FilterIterator

38. $filterIterator = new EvenFilterIterator($iterator);

39. // Iterate

40. foreach ($filterIterator as $key => $value) {
41. echo $key .': '. $value . PHP_EOL;
42. }
43. ?>

（4）RegexIterator迭代器

3. // Create a RecursiveDirectoryIterator

4. $directoryIterator = new RecursiveDirectoryIterator("./");

5. // Create a RecursiveIteratorIterator to recursively iterate

6. $recursiveIterator = new RecursiveIteratorIterator($directoryIterator);

7. // Createa filter for *Iterator*.php files

8. $regexFilter = new RegexIterator($recursiveIterator, '/(.*?)Iterator(.*?)\.php$/');

9. // Iterate

10. foreach ($regexFilter as $key => $file) {
11. /* @var SplFileInfo $file */
12. echo $file->getFilename() . PHP_EOL;
13. }

功能：找到所有的php文件

（4）LimitItertor迭代器，像SQL中的LIMIT

3. // Define the array

4. $array = array(
5. 'Hello',
6. 'World',
7. 'How',
8. 'are',
9. 'you',
10. 'doing?'
11. );

12. // Create the iterator

13. $iterator = new ArrayIterator($array);

14. // Create the limiting iterator, to get the first 2 elements

15. $limitIterator = new LimitIterator($iterator, 0, 2);

16. // Iterate

17. foreach ($limitIterator as $key => $value) {
18. echo $key .': '. $value . PHP_EOL;
19. }

6.观察者模式（observer）

观察者模式的核心在于云霄你的应用程序注册一个回调，当某个特定的事件发生时便会促发它

3. /**

4. * The Event Class
5. *
6. * With this class you can register callbacks that will
7. * be called (FIFO) for a given event.
8. */
9. class Event {
10. /**
11. * @var array A multi-dimentional array of events => callbacks
12. */
13. static protected $callbacks = array();
15. /**
16. * Register a callback
17. *
18. * @param string $eventName Name of the triggering event
19. * @param mixed $callback An instance of Event_Callback or a Closure
20. */
21. static public function registerCallback($eventName, $callback)
22. {
23. if (!($callback instanceof Event_Callback) && !($callback instanceof Closure)) {
24. throw new Exception("Invalid callback!");
25. }
27. $eventName = strtolower($eventName);
29. self::$callbacks[$eventName][] = $callback;
30. }
32. /**
33. * Trigger an event
34. *
35. * @param string $eventName Name of the event to be triggered
36. * @param mixed $data The data to be sent to the callback
37. */
38. static public function trigger($eventName, $data)
39. {
40. $eventName = strtolower($eventName);
42. if (isset(self::$callbacks[$eventName])) {
43. foreach (self::$callbacks[$eventName] as $callback) {
44. self::callback($callback, $data);
45. }
46. }
47. }
49. /**
50. * Perform the callback
51. *
52. * @param mixed $callback An instance of Event_Callback or a Closure
53. * @param mixed $data The data sent to the callback
54. */
55. static protected function callback($callback, $data)
56. {
57. if ($callback instanceof Closure) {
58. $callback($data);
59. } else {
60. $callback->run($data);
61. }
62. }
63. }

64. /**

65. * The Event Callback interface
66. *
67. * If you do not wish to use a closure
68. * you can define a class that extends
69. * this instead. The run method will be
70. * called when the event is triggered.
71. */
72. interface Event_Callback {
73. public function run($data);
74. }

75. /**

76. * Logger callback
77. */
78. class LogCallback implements Event_Callback {
79. public function run($data)
80. {
81. echo "Log Data" . PHP_EOL;
82. var_dump($data);
83. }
84. }

85. // Register the log callback

86. Event::registerCallback('save', new LogCallback());

87. // Register the clear cache callback as a closure

88. Event::registerCallback('save', function ($data) {
89. echo "Clear Cache" . PHP_EOL;
90. var_dump($data);
91. });

92. class MyDataRecord {

93. public function save()
94. {
95. // Save data
97. // Trigger the save event
98. Event::trigger('save', array("Hello", "World"));
99. }
100. }

101. // Instantiate a new data record

102. $data = new MyDataRecord();
103. $data->save(); // 'save' Event is triggered here

7.依赖注入模式 依赖注入模式允许类的使用这为这个类注入依赖的行为。

3. /**

4. * Log Class
5. */
6. class Log {
7. /**
8. * @var Log_Engine_Interface
9. */
10. protected $engine = false;
12. /**
13. * Add an event to the log
14. *
15. * @param string $message
16. */
17. public function add($message)
18. {
19. if (!$this->engine) {
20. throw new Exception('Unable to write log. No Engine set.');
21. }
23. $data['datetime'] = time();
24. $data['message'] = $message;
26. $session = Registry::get('session');
27. $data['user'] = $session->getUserId();
29. $this->engine->add($data);
30. }
32. /**
33. * Set the log data storage engine
34. *
35. * @param Log_Engine_Interface $Engine
36. */
37. public function setEngine(Log_Engine_Interface $engine)
38. {
39. $this->engine = $engine;
40. }
42. /**
43. * Retrieve the data storage engine
44. *
45. * @return Log_Engine_Interface
46. */
47. public function getEngine()
48. {
49. return $this->engine;
50. }
51. }

52. interface Log_Engine_Interface {

53. /**
54. * Add an event to the log
55. *
56. * @param string $message
57. */
58. public function add(array $data);
59. }

60. class Log_Engine_File implements Log_Engine_Interface {

61. /**
62. * Add an event to the log
63. *
64. * @param string $message
65. */
66. public function add(array $data)
67. {
68. $line = '[' .data('r', $data['datetime']). '] ' .$data['message']. ' User: ' .$data['user'] . PHP_EOL;
70. $config = Registry::get('site-config');
72. if (!file_put_contents($config['location'], $line, FILE_APPEND)) {
73. throw new Exception("An error occurred writing to file.");
74. }
75. }
76. }

77. $engine = new Log_Engine_File();

78. $log = new Log();

79. $log->setEngine($engine);

80. // Add it to the registry

81. Registry::add($log);

依赖注入不想工厂模式，日之类无需了解每一个不同的存储引擎的相关知识。这就意味着任何使用日志类的开发者可以添加他们自己的存储引擎，主要他们复合接口就行。

8.模型-视图-控制器 模型-视图-控制器又称为MVC模式，是描述应用程序3个不同层次之间关系的一种方式。 模型-数据层 所有的输出数据都来自模型。它可能是一个数据库、web服务或者文件。 视图-表现层 负责将数据从模型中取出并输出给用户。 控制器-应用程序流层 根据用户的请求调用相应的模型检索出请求的数据，然后调用视图将操作的结果显示给用户。

一个典型的MVC架构图：

您可能感兴趣的文章：

• php设计模式之单例模式、工厂模式与观察者模式
• 深入php设计模式实例详解
• php设计模式实例之命令模式
• php设计模式实例之观察者模式(2)
• PHP设计模式实例之观察者模式
• php设计模式实例之工厂模式
• php设计模式实例之单例模式
• PHP设计模式之观察者模式的例子
• php设计模式之工厂模式的实例代码
• php设计模式之单例模式的实例代码
• php常用设计模式之工厂模式与单例模式介绍
• 学习php设计模式之单例模式
• php常用的三种设计模式的学习笔记
• php设计模式之单例模式学习