搜尋

首頁 >後端開發 >php教程 >PHP 實戰之設計模式：PHP 中的設計模式

PHP 實戰之設計模式：PHP 中的設計模式

WBOY
WBOY原創
2016-07-23 08:54:42828瀏覽
PHP

本文為翻譯文章

原文網址：Design Patterns in PHP
如果打算學習php的童鞋可以參考下筆者的程式語言學習知識體係要點列表

本文主要討論下web開發中，準確而言，是php開發中的相關的設計模式及其應用。有經驗的開發者肯定對於​​設計模式非常熟悉，但是本文主要是針對那些初級的開發者。首先我們要搞清楚到底什麼是設計模式，設計模式並不是用來解釋的模式，它們並不是像鍊錶那樣的常見的資料結構，也不是某種特殊的應用或框架設計。事實上，設計模式的解釋如下：

descriptions of communicating objects and classes that are customized to solve a general design problem in a particular context.

另一方面，設計模式提供了一種廣泛的可重用的方式來解決我們日常程式設計中常常遇見的問題。設計模式並不一定就是一個類別庫或第三方框架，它們更多的表現為一種想法並且廣泛地應用在系統中。它們也表現為一種模式或模板，可以在多個不同的場景下用於解決問題。設計模式可以用於加速開發，並且將許多大的想法或設計以簡單地方式實現。當然，雖然設計模式在開發中很有作用，但是千萬要避免在不適當的場景誤用它們。

目前常見的設計模式主要有23種，依使用目標的差異可以分為以下三大類：

建立模式：用於建立物件從而將某個物件從實作中解耦合。

架構模式：用於在不同的物件之間建構大的物件結構。

行為模式：用於在不同的物件之間管理演算法、關係以及職責。

Creational Patterns Singleton(單例模式)

單例模式是最常見的模式之一，在Web應用的開發中，常用於允許在執行時間為某個特定的類別建立一個可存取的實例。

  1. /**
  2. * 單例類別
  3. */
  4. final class Product
  5. {
  7. /**
  8. * @var self
  9. */
  10. private static $instance;
  12. /**
  13. * @var 混合
  14. */
  15. public $mix;
  18. /**
  19. * 回傳自身實例
  20. *
  21. * @return self
  22. */
  23. public static function getInstance() {
  24. if (!(self::$instance instanceof self)) {
  25. self::$instance = new self();
  26. }
  27. return self: :$instance;
  28. }
  30. private function __construct() {
  31. }
  33. private function __clone() {
  34. }
  35. private function __clone() {
  36. }
  37. > $firstProduct = Product::getInstance();
  38. $secondProduct = Product::getInstance();
  40. $firstProduct->mix = 'test';
  41. $secondProduct->mix = '0 ';
  43. print_r($firstProduct->mix);
  44. // example
  45. print_r($secondProduct->mix);
  46. // example
複製程式碼

在許多情況下，需要為系統中的多個類別建立單例的構造方式，這樣，可以建立一個通用的抽象父工廠方法：
  3. abstract class FactoryAbstract {
  5. protected static $instances = array();
  7. public instances = array();
  9. public static function(Ingetst); 🎜> $className = static::getClassName();
  10. if (!(self::$instances[$className] instanceof $className)) {
  11. self::$instances[$className] = new $className ();
  12. }
  13. return self::$instances[$className];
  14. }
  16. public static function removeInstance() {
  17. $className = static::getClassName() ;
  18. if (array_key_exists($className, self::$instances)) {
  19. unset(self::$instances[$className]);
  20. }
  21. }
  22. final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final🎜> final protected static function getClassName() {
  23. return get_called_class();
  24. }
  26. protected function __construct() { }
  28. final protected function protect(
  30. abstract class Factory extends FactoryAbstract {
  32. final public static function getInstance() {
  33. return parent::getInstance();
  34. }
  35. return parent::getInstance();
  36. }
  37. function removeInstance() {
  38. parent::removeInstance();
  39. }
  40. }
  41. // using:
  43. class FirstProduct extends Factory {
  45. class FirstProduct extends Factory {
  46. public $🎜> ;
  47. }
  48. class SecondProduct extends FirstProduct {
  49. }
  51. FirstProduct::getInstance()->a[] = 1;
  52. SecondProduct::getgetstance()->( ] = 2;
  53. FirstProduct::getInstance()->a[] = 3;
  54. SecondProduct::getInstance()->a[] = 4;
  56. print_r(FirstProduct::getInstance ()->a);
// array(1, 3)
print_r(SecondProduct::getInstance()->a);// array(2, 4)
複製程式碼Registry

註冊台模式並不是很常見，它也不是一個典型的創建模式，只是為了利用靜態方法更方便的存取資料。

  1. /**
  2. * 註冊表類
  3. */
  4. class Package {
  6. protected static $data = array();
  8. public static function set($key, $value) {
  9. self::$data[$key] = $value;
  10. }
  12. public static function get($ key) {
  13. return isset(self::$data[$key]) ? self::$data[$key] : null;
  14. }
  16. final public static function removeObject($key ) {
  17. if (array_key_exists($key, self::$data)) {
  18. unset(self::$data[$key]);
  19. }
  20. }
  21. }
  24. Package::set('name', 'Package name');
  26. print_r(Package::get('name'));
  27. // Package name
複製程式碼
Factory(工廠模式)

工廠模式是另一種非常常用的模式，正如其名字所示：確實是物件實例的生產工廠。在某些意義上，工廠模式提供了通用的方法有助於我們去獲取對象，而不需要關心其具體的內在的實現。

  2. interface Factory {
  3. public function getProduct();
  4. }
  5. public function getProduct();
  6. }
  7. face public function getName();
  8. }
  10. class FirstFactory implements Factory {
  12. public function getProduct() {
  13. return newProduct();
  14. >}
  16. class SecondFactory implements Factory {
  18. public function getProduct() {
  19. return new SecondProduct();
  20. }
  21. return new SecondProduct();
  22. }
  23. > implements Product {
  25. public function getName() {
  26. return 'The first product';
  27. }
  28. }
  30. class SecondProduct imple🎜>}
  32. class SecondProduct implelments Product> public function getName() {
  33. return 'Second product';
  34. }
  35. }
  37. $factory = new FirstFactory();
  38. $firstProduct = $factory = new FirstFactory();
  39. $firstProduct = $factory-getProduct(actory) ;
  40. $factory = new SecondFactory();
  41. $secondProduct = $factory->getProduct();
  43. print_r($firstProduct->getName());
  44. print_r($firstProduct->getName());
  45. // The first product
  46. print_r($secondProduct->getName());
// Second product
複製程式碼

AbstractFactory(抽象工廠模式)

有些情況下我們需要根據不同的選擇邏輯提供不同的構造工廠，而對於多個工廠而言需要一個統一的抽象工廠：
  2. php
  4. class Config {
  5. public static $factory = 1;
  6. }
  8. interface Product {
  9. public function getName();
  10. interface Product {
  11. public function getName();
  14. abstract class AbstractFactory {
  16. public static function getFactory() {
  17. switch (Config::$factory) {
  18. case 1:
  19. return new？ 2:
  20. return new SecondFactory();
  21. }
  22. throw new Exception('Bad config');
  23. }
  25. abstract public function getProduct(); 🎜>
  26. class FirstFactory extends AbstractFactory {
  27. public function getProduct() {
  28. return new FirstProduct();
  29. }
  30. }
  31. class FirstProdupmplements Product class Pro () {
  32. return 'The product from the first factory';
  33. }
  34. }
  36. class SecondFactory extends AbstractFactory {
  37. public function getProduct() return }
  38. }
  39. class SecondProduct implements Product {
  40. public function getName() {
  41. return 'The product from second factory';
  42. }
  43. }
  44. >
  45. $firstProduct = AbstractFactory::getFactory()->getProduct();
  46. Config::$factory = 2;
  47. $secondProduct = AbstractFactory::getFactory()->getProduct();getProduct(); >
  48. print_r($firstProduct->getName());
  49. // The first product from the first factory
  50. print_r($secondProduct->getName());
  51. // Second product from second factory
  54. 複製程式碼
Object pool(物件池)

物件池可以用於建構並且存放一系列的物件並在需要時取得呼叫：

  2. class Product {
  4. protected $id;
  6. public function __construct($id) {
  7. $this->id = $id;
  8. }
  9. public ftion getId() {
  10. return $this->id;
  11. }
  12. }
  14. class Factory {
  16. protected static $products = array();
  18. publicy();
  20. 我static function pushProduct(Product $product) {
  21. self::$products[$product->getId()] = $product;
  22. }
  24. public static function getProduct($id) { 🎜> return isset(self::$products[$id]) ? self::$products[$id] : null;
  25. }
  27. public static function removeProduct($id) {
  28. public static function removeProduct($id) {
  29. if (array_key_exists($id, self::$products)) {
  30. unset(self::$products[$id]);
  31. }
  32. }
  33. }
  36. Factory::pushProduct(new Product('first'));
  37. Factory::pushProduct(new Product('second'));
  39. print_r(Factory::getProduct('first') ->getId());
  40. // first
  41. print_r(Factory::getProduct('second')->getId());
// second
複製程式碼

Lazy Initialization(延遲初始化)

對於某個變數的延遲初始化也是常常被用到的，對於一個類別而言往往並不知道它的哪個功能會被用到，而部分功能往往是僅僅被需要使用一次。
  3. interface Product {
  4. public function getName();
  5. }
  7. 🎜>
  8. protected $firstProduct;
  9. protected $secondProduct;
  11. public function getFirstProduct() {
  12. if (!$this->firstProduct() {
  13. if (!$this->firstProduct) new FirstProduct();
  14. }
  15. return $this->firstProduct;
  16. }
  18. public function getSecondProduct() {
  19. if (!$this->secondProduct） > $this->secondProduct = new SecondProduct();
  20. }
  21. return $this->secondProduct;
  22. }
  23. }
  25. class FirstProduct implements Product { return 'The first product';
  26. }
  27. }
  29. class SecondProduct implements Product {
  30. public function getName() {
  31. return 'Second ;
  32. }
  33. }
  36. $factory = new Factory();
  38. print_r($factory->getFirstProduct()->getName()); >// The first product
  39. print_r($factory->getSecondProduct()->getName());
  40. // Second product
  41. print_r($factory->getFirstProduct()->getName()) ;
  42. // The first product
  45. 複製程式碼
Prototype(原型模式) 有些時候，部分物件需要被初始化多次。而特別是在如果初始化需要耗費大量時間與資源的時候進行預初始化並且儲存下這些物件。

    interface Product {
  1. }
  3. class Factory {
  6. $ate $
  8. public function __construct(Product $product) {
  9. $this->product = $product;
  10. }
  12. public function getProduct() {
  13. ->product;
  14. }
  15. }
  17. class SomeProduct implements Product {
  18. public $name;
  19. }
  22. $prototypeFactory = new new new 樣0 SomeProduct());
  24. $firstProduct = $prototypeFactory->getProduct();
  25. $firstProduct->name = 'The first product';
  27. $secFactorct getProduct();
  28. $secondProduct->name = 'Second product';
  30. print_r($firstProduct->name);
  31. // The first product
  32. print_rct($ name);
  33. // Second product
複製程式碼
Builder（建造者）

建構者模式主要提供創建一些複雜的物件：

  2. class Product {
  4. private $ name ;
  6. public function setName($name) {
  7. $this->name = $name;
  8. }
  10. public function getName() {
  11. return $this this- >name;
  12. }
  13. }
  15. 抽象類別Builder {
  17. protected $product;
  19. 最終公用函數->product;
  20. }
  22. public function buildProduct() {
  23. $this->product = new Product();
  24. }
  25. }
  28. }
  29. }
  32. extends Builder {
  34. public function buildProduct() {
  35. parent::buildProduct();
  36. $this->product->setName('第一個的乘積
  37. }
  38. }
  40. class SecondBuilder extends Builder {
  42. public function buildProduct() {
  43. parent::buildProduct();
  44. $) {
  45. parent::buildProduct(); $) {
  46. parent:: '第二個建構器的產品');
  47. }
  48. }
  50. class Factory {
  52. private $builder;
  54. public function __construct(Builder $ builder) {
  55. $this->builder = $builder;
  56. $this->builder->buildProduct();
  57. }
  59. public function getProduct() {
  60. return $🎜> public function getProduct() {
  61. return $🎜> public function getProduct() {
  62. return $🎜> public function getProduct() {
  63. return $🎜> public function getProduct() {
    64.
return $ this->builder->getProduct();
}}
$firstDirector = new Factory(new FirstBuilder());

$secondDirector = new Factory(new FirstBuilder());

$secondDirector = new Factory(new FirstBuilderondBuilder(new) ;
print_r($firstDirector->getProduct()->getName());
    // 第一個建構器的產品
  1. print_r($secondDirector->getProduct()->getName ());
  2. // 第二個建構器的乘積
  5. 複製程式碼
  7. 結構模式 Decorator(裝飾器模式)
  8. 裝飾器模式允許我們根據不同的場景動態地運行某個物件呼叫前後添加不同的行為動作。
  13. class HtmlTemplate {
  14. // 任何父類方法
  15. }
  17. class Template1 extends Hthilate > protected $_html;
  19. public function __construct() {
  20. $ this->_html = "

    __text__

    ";
  21. }
  23. public function set ($html) {
  24. $this->_html = $html;
  25. }
  27. public function render() {
  28. echo $this->_html;
  29. }
  30. }
  31. }
  33. class Template2 extends HtmlTemplate {
  34. protected $ _element;
  36. public function __construct($s) {
  37. $this->_element = $s; ->set("

    " . $this-> ;_html . "

    ");
  38. }
  40. 公用函數__call($name, $args) {
  41. $this->_element->$name($args) [0]);
  42. }
  43. }
  45. class Template3 extends HtmlTemplate {
protected $_element;
public function __construct($s) {
$this ->_element = $s;

$this->set("" . $this->_html . "");

}
public function __call($name, $args) {
    $this->_element->$name($args[0] );
  1. }
  2. }
  5. 複製程式碼
  7. Adapter(適配器模式)
  8. 這種模式允許使用不同的介面重建某個類，可以允許使用不同的呼叫方式進行呼叫：
  14. class SimpleBook {
  16. private $author;
  17. private $title;
  19. function __construct($author_in, $title_in) {
  20. $this->author = $this->author = $authorin ;
  21. $this->author = $authorin ;
  22. $this->title = $title_in;
  23. }
  25. function getAuthor() {
  26. return $this->author;
  27. }
  29. function getTitle() {
  30. return $this->title;
  31. }
  32. }
  34. class BookAdapter {
  36. private $book;
  38. 函數
  39. private $book;
函數__🎜(SimpleBook__ book_in) {
$this->book = $book_in; } function getAuthorAndTitle() {
return $this->book->getTitle().' by '.$this-> book->getAuthor(); }}//用法$book = new SimpleBook("Gamma、Helm、Johnson 與Vlissides", "設計模式");$bookAdapter = new BookAdapter($book);echo '作者與標題：'.$bookAdapter->getAuthorAndTitle();function echo $line_in) { echoin_in. "
";}複製程式碼Behavioral Patterns Strategy(策略模式)

測試模式主要為了讓客戶類別能夠更好地使用某些演算法而不需要知道其具體的實作。

  2. interface OutputInterface {
  3. public function load();
  4. }
  5. public function load() {
  6. return serialize($arrayOfData);
  7. }
  8. }
  10. class JsonStringOutput implements OutputInterface {
  12. class JsonStringOutput implementsments > return json_encode($arrayOfData);
  13. }
  14. }
  16. class ArrayOutput implements OutputInterface {
  17. public function load() {
  18. return $arrayOfData; }
  21. 複製程式碼
Observer(觀察者模式) 某個物件可以被設定為是可觀察的，只要透過某種方式允許其他物件註冊為觀察者。每當被觀察的對象改變時，會傳送訊息給觀察者。

    interface Observer {
  1. function onChanged($sender, $args);
  2. }
  3. }
  5. interface Observable {
  6. function addObserver($observer);
  7. }
  9. class CustomerList implements Observable {
  10. private $_observers = array();
  11. foreach($this->_observers as $obs)
  12. $obs->onChanged($this, $name);
  13. }
  15. public function addObserver($observer) {
  16. $this->_observers []= $observer;
  17. }
  18. }
  20. class CustomerListLogger implements Observer {
  21. public function onChanged($sender, $argments > echo( "'$args' Customer has been added to the list n" );
  22. }
  23. }
  25. $ul = new UserList();
  26. $ul->addObserver( new CustomerListLogger() );
  27. $ul->addCustomer( "Jack" );
  30. 複製程式碼
Chain of responsibility(責任鏈模式)
這種模式有另一種稱呼：控制鏈模式。它主要由一系列對於某些命令的處理器構成，每個查詢都會在處理器構成的責任鏈中傳遞，在每個交匯點由處理器判斷是否需要對它們進行回應與處理。每次的處理程序會在有處理器處理這些請求時暫停。

interface Command {
    function onCommand($name, $args);
  1. }
  4. class CommandChain {
  5. private $_commands = array();
  7. public function addCommand($cmd) {
  8. $this->_commands[]= $cmd;
  9. }
  10. }
  12. public function runCommand($name, $args) {
  13. foreach($this->_commands as $cmd) {
  14. if ($cmd->onCommand($name, $args))
  15. return ;
  16. }
  17. }
  18. }
  20. class CustCommand implements Command {
  21. public function onCommand($name, $args) {
  22. if ($name != 'addCustomer' )
  23. return false;
  24. echo("This is CustomerCommand handling 'addCustomer'n");
  25. return true;
  26. }
  27. }
  29. class Command
  30. public function onCommand($name, $args) {
  31. if ($name != 'mail')
  32. return false;
  33. echo("This is MailCommand handling 'mail'n");
  34. return true;
  35. }
  36. }
  38. $cc = new CommandChain();
  39. $cc->addCommand( new CustCommand());
  40. $cc->addCommand ( new MailCommand());
  41. $cc->runCommand('addCustomer', null);
  42. $cc->runCommand('mail', null);
複製程式碼
陳述：
本文內容由網友自願投稿，版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容，請聯絡admin@php.cn
上一篇：提升PHP編程效率的20個要素下一篇：提升PHP編程效率的20個要素

相關文章

看更多