Home > Tutorials > PHP Tutorials

PHP design pattern: Design Patterns in PHP

Source: Internet
Author: User
Tags learn php
Developer on Alibaba Coud: Build your first app with APIs, SDKs, and tutorials on the Alibaba Cloud. Read more ＞

This article is for translating articles

Original address: Design Patterns in PHP
If you intend to learn PHP children's shoes can refer to the author's programming language learning Knowledge system Essentials List

This article mainly discusses in the web development, is accurate, is the PHP development the related design pattern and the application. Experienced developers are sure to be familiar with design patterns, but this article is intended primarily for novice developers. First we need to figure out what the design pattern is, design patterns are not a pattern to interpret, they are not a common data structure like linked lists, or a particular application or framework design. In fact, the design pattern is explained as follows:

Descriptions of communicating objects and classes that is customized to solve a general design problem in a particular CO ntext.

On the other hand, design patterns provide a broad and reusable way to solve the problems we often encounter in our daily programming. Design patterns are not necessarily a class library or a third-party framework, they are more of a thought and widely used in the system. They also represent a pattern or template that can be used to solve problems in several different scenarios. Design patterns can be used to speed up development, and many large ideas or designs are implemented in a simple way. Of course, while design patterns work well in development, it's important to avoid misusing them in inappropriate scenarios.

At present, there are 23 kinds of design patterns, which can be divided into the following three categories according to the use target:

Create pattern: Used to create an object to decouple an object from the implementation.

Schema mode: Used to construct large object structures between different objects.

Behavior patterns: Used to manage algorithms, relationships, and responsibilities between different objects.

Creational Patternssingleton (singleton mode)

Singleton mode is one of the most common patterns that are often used in Web application development to allow an accessible instance to be created at run time for a particular class.

  2. /**
  4. * Singleton Class
  6. */
  8. Final class Product
  10. {
  14. /**
  16. * @var Self
  18. */
  20. private static $instance;
  24. /**
  26. * @var Mixed
  28. */
  30. Public $mix;
  36. /**
  38. * Return Self instance
  40. *
  42. * @return Self
  44. */
  46. public static function getinstance () {
  48. if (! ( Self:: $instance instanceof Self)) {
  50. Self:: $instance = new self ();
  52. }
  54. Return self:: $instance;
  56. }
  60. Private Function __construct () {
  62. }
  66. Private Function __clone () {
  68. }
  70. }
  74. $firstProduct = Product::getinstance ();
  76. $secondProduct = Product::getinstance ();
  80. $firstProduct->mix = ' Test ';
  82. $secondProduct->mix = ' example ';
  86. Print_r ($firstProduct->mix);
  88. Example
  90. Print_r ($secondProduct->mix);
  92. Example
Copy Code

In many cases, it is necessary to create a singleton construct for multiple classes in the system, so that a common abstract parent factory method can be established:

  4. Abstract class Factoryabstract {
  8. protected static $instances = Array ();
  12. public static function getinstance () {
  14. $className = Static::getclassname ();
  16. if (! ( Self:: $instances [$className] instanceof $className)) {
  18. Self:: $instances [$className] = new $className ();
  20. }
  22. Return self:: $instances [$className];
  24. }
  28. public static function RemoveInstance () {
  30. $className = Static::getclassname ();
  32. if (Array_key_exists ($className, Self:: $instances)) {
  34. Unset (self:: $instances [$className]);
  36. }
  38. }
  42. Final protected static function GetClassName () {
  44. return Get_called_class ();
  46. }
  50. protected function __construct () {}
  54. Final protected function __clone () {}
  56. }
  60. Abstract class Factory extends Factoryabstract {
  64. Final public static function getinstance () {
  66. return Parent::getinstance ();
  68. }
  72. Final public static function RemoveInstance () {
  74. Parent::removeinstance ();
  76. }
  78. }
  80. Using
  84. Class Firstproduct extends Factory {
  86. Public $a = [];
  88. }
  90. Class Secondproduct extends Firstproduct {
  92. }
  96. Firstproduct::getinstance ()->a[] = 1;
  98. Secondproduct::getinstance ()->a[] = 2;
  100. Firstproduct::getinstance ()->a[] = 3;
  102. Secondproduct::getinstance ()->a[] = 4;
  106. Print_r (Firstproduct::getinstance ()->a);
  108. Array (1, 3)
  110. Print_r (Secondproduct::getinstance ()->a);
  112. Array (2, 4)
Copy CodeRegistry

The registry mode is not very common, it is not a typical creation mode, just to make use of static methods more convenient access to data.

    1. /**
    2. * Registry Class
    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
Copy CodeFactory (Factory mode)

The factory pattern is another very common pattern, as its name implies: it is indeed the production factory of the object instance. In some sense, the factory model provides a common approach that helps us get to the object without having to care about its specific intrinsic implementation.

  4. Interface Factory {
  6. Public function getproduct ();
  8. }
  12. Interface Product {
  14. Public function getName ();
  16. }
  20. Class Firstfactory implements Factory {
  24. Public Function getproduct () {
  26. return new Firstproduct ();
  28. }
  30. }
  34. Class Secondfactory implements Factory {
  38. Public Function getproduct () {
  40. return new Secondproduct ();
  42. }
  44. }
  48. Class Firstproduct implements Product {
  52. Public Function GetName () {
  54. Return ' the first product ';
  56. }
  58. }
  62. Class Secondproduct implements Product {
  66. Public Function GetName () {
  68. Return ' Second product ';
  70. }
  72. }
  76. $factory = new Firstfactory ();
  78. $firstProduct = $factory->getproduct ();
  80. $factory = new Secondfactory ();
  82. $secondProduct = $factory->getproduct ();
  86. Print_r ($firstProduct->getname ());
  88. The first product
  90. Print_r ($secondProduct->getname ());
  92. Second Product
Copy CodeAbstractfactory (abstract Factory mode)

In some cases we need to provide different construction plants based on different selection logic, whereas for multiple plants a unified abstraction plant is required:

  4. Class Config {
  6. public static $factory = 1;
  8. }
  12. Interface Product {
  14. Public function getName ();
  16. }
  20. Abstract class Abstractfactory {
  24. public static function GetFactory () {
  26. Switch (Config:: $factory) {
  28. Case 1:
  30. return new Firstfactory ();
  32. Case 2:
  34. return new Secondfactory ();
  36. }
  38. throw new Exception (' bad config ');
  40. }
  44. Abstract public Function getproduct ();
  46. }
  50. Class Firstfactory extends Abstractfactory {
  52. Public Function getproduct () {
  54. return new Firstproduct ();
  56. }
  58. }
  60. Class Firstproduct implements Product {
  62. Public Function GetName () {
  64. Return ' the product from the first factory ';
  66. }
  68. }
  72. Class Secondfactory extends Abstractfactory {
  74. Public Function getproduct () {
  76. return new Secondproduct ();
  78. }
  80. }
  82. Class Secondproduct implements Product {
  84. Public Function GetName () {
  86. Return ' the product from second factory ';
  88. }
  90. }
  94. $firstProduct = Abstractfactory::getfactory ()->getproduct ();
  96. Config:: $factory = 2;
  98. $secondProduct = Abstractfactory::getfactory ()->getproduct ();
  102. Print_r ($firstProduct->getname ());
  104. The first product from the first factory
  106. Print_r ($secondProduct->getname ());
  108. Second Product from Second factory
Copy CodeObject Pool

An object pool can be used to construct and hold a series of objects and get calls when needed:

  4. Class Product {
  8. protected $id;
  12. Public function __construct ($id) {
  14. $this->id = $id;
  16. }
  20. Public Function getId () {
  22. return $this->id;
  24. }
  26. }
  30. Class Factory {
  34. protected static $products = Array ();
  38. public static function Pushproduct (Product $product) {
  40. Self:: $products [$product->getid ()] = $product;
  42. }
  46. public static function GetProduct ($id) {
  48. Return Isset (self:: $products [$id])? Self:: $products [$id]: null;
  50. }
  54. public static function Removeproduct ($id) {
  56. if (Array_key_exists ($id, Self:: $products)) {
  58. Unset (self:: $products [$id]);
  60. }
  62. }
  64. }
  70. Factory::p ushproduct (New Product (' first '));
  72. Factory::p ushproduct (New Product (' second '));
  76. Print_r (Factory::getproduct (' first ')->getid ());
  78. First
  80. Print_r (Factory::getproduct (' second ')->getid ());
  82. Second
Copy CodeLazy initialization (deferred initialization)

Lazy initialization of a variable is often used, and for a class it is often not known which function is used, and some functions are often used only once.

  4. Interface Product {
  6. Public function getName ();
  8. }
  12. Class Factory {
  16. protected $firstProduct;
  18. protected $secondProduct;
  22. Public Function getfirstproduct () {
  24. if (! $this->firstproduct) {
  26. $this->firstproduct = new Firstproduct ();
  28. }
  30. return $this->firstproduct;
  32. }
  36. Public Function getsecondproduct () {
  38. if (! $this->secondproduct) {
  40. $this->secondproduct = new Secondproduct ();
  42. }
  44. return $this->secondproduct;
  46. }
  48. }
  52. Class Firstproduct implements Product {
  54. Public Function GetName () {
  56. Return ' the first product ';
  58. }
  60. }
  64. Class Secondproduct implements Product {
  66. Public Function GetName () {
  68. Return ' Second product ';
  70. }
  72. }
  78. $factory = new Factory ();
  82. Print_r ($factory->getfirstproduct ()->getname ());
  84. The first product
  86. Print_r ($factory->getsecondproduct ()->getname ());
  88. Second Product
  90. Print_r ($factory->getfirstproduct ()->getname ());
  92. The first product
Copy CodePrototype (prototype mode)

Sometimes, some objects need to be initialized multiple times. And especially if initialization takes a lot of time and resources to pre-initialize and store those objects.

    1. !--? php
    2. interface Product {
    3. }
    5. class Factory {
    7. private $product;
    9. Public Function __construct (Product $product) {
    10. $this->product = $product;
    11. }
    13. public Function getproduct () {
    14. return clone $this->product;
    15. }
    16. }
    18. class Someproduct implements Product {
    19. public $name;
    20. }
    23. $prototypeFactory = new Factory (new Someproduct ());
    25. $firstProduct = $prototypeFactory->getproduct ();
    26. $firstProduct->name = ' the first product ';
    28. $secondProduct = $prototypeFactory->getproduct ();
    29. $secondProduct->name = ' Second product ';
    31. print_r ($firstProduct->name);
    32. //The first product
    33. Print_r ($secondProduct->name);
    34. //Second product
Copy CodeBuilder (constructor)

The constructor pattern is primarily about creating complex objects:

  4. Class Product {
  8. Private $name;
  12. Public Function SetName ($name) {
  14. $this->name = $name;
  16. }
  20. Public Function GetName () {
  22. return $this->name;
  24. }
  26. }
  30. Abstract class Builder {
  34. protected $product;
  38. Final public Function getproduct () {
  40. return $this->product;
  42. }
  46. Public Function buildproduct () {
  48. $this->product = new product ();
  50. }
  52. }
  56. Class Firstbuilder extends Builder {
  60. Public Function buildproduct () {
  62. Parent::buildproduct ();
  64. $this->product->setname (' The product of the first builder ');
  66. }
  68. }
  72. Class Secondbuilder extends Builder {
  76. Public Function buildproduct () {
  78. Parent::buildproduct ();
  80. $this->product->setname (' The product of Second Builder ');
  82. }
  84. }
  88. Class Factory {
  92. Private $builder;
  96. Public function __construct (Builder $builder) {
  98. $this->builder = $builder;
  100. $this->builder->buildproduct ();
  102. }
  106. Public Function getproduct () {
  108. return $this->builder->getproduct ();
  110. }
  112. }
  116. $firstDirector = new Factory (new Firstbuilder ());
  118. $secondDirector = new Factory (new Secondbuilder ());
  122. Print_r ($firstDirector->getproduct ()->getname ());
  124. The product of the first builder
  126. Print_r ($secondDirector->getproduct ()->getname ());
  128. The product of second builder
Copy CodeStructural Patternsdecorator (Adorner mode)

Adorner mode allows us to dynamically add different behavioral actions to an object's invocation, depending on the runtime's different scenarios.

  2. Class Htmltemplate {
  4. Any parent class methods
  6. }
  10. Class Template1 extends Htmltemplate {
  12. protected $_html;
  16. Public Function __construct () {
  18. $this->_html = "

    __text__

    ";
  20. }
  24. Public function set ($html) {
  26. $this->_html = $html;
  28. }
  32. Public function render () {
  34. Echo $this->_html;
  36. }
  38. }
  42. Class Template2 extends Htmltemplate {
  44. protected $_element;
  48. Public function __construct ($s) {
  50. $this->_element = $s;
  52. $this->set ("

    " . $this->_html. "

    ");
  54. }
  58. Public Function __call ($name, $args) {
  60. $this->_element-> $name ($args [0]);
  62. }
  64. }
  68. Class Template3 extends Htmltemplate {
  70. protected $_element;
  74. Public function __construct ($s) {
  76. $this->_element = $s;
  78. $this->set ("". $this->_html. "");
  80. }
  84. Public Function __call ($name, $args) {
  86. $this->_element-> $name ($args [0]);
  88. }
  90. }
Copy CodeAdapter (Adapter mode)

This mode allows the use of different interfaces to refactor a class, allowing calls to be made using different invocation methods:

  4. Class Simplebook {
  8. Private $author;
  10. Private $title;
  14. function __construct ($author _in, $title _in) {
  16. $this->author = $author _in;
  18. $this->title = $title _in;
  20. }
  24. function Getauthor () {
  26. return $this->author;
  28. }
  32. function GetTitle () {
  34. return $this->title;
  36. }
  38. }
  42. Class Bookadapter {
  46. Private $book;
  50. function __construct (Simplebook $book _in) {
  52. $this->book = $book _in;
  54. }
  56. function Getauthorandtitle () {
  58. return $this->book->gettitle (). ' By '. $this->book->getauthor ();
  60. }
  62. }
  66. Usage
  68. $book = new Simplebook ("Gamma, Helm, Johnson, and Vlissides", "Design Patterns");
  70. $bookAdapter = new Bookadapter ($book);
  72. Echo ' Author and Title: '. $bookAdapter->getauthorandtitle ();
  76. function echo $line _in) {
  78. echo $line _in. "
    ";
  80. }
Copy CodeBehavioral Patternsstrategy (Policy mode)

The test pattern is primarily intended to allow the customer class to better use certain algorithms without needing to know their specific implementations.

    2. Interface Outputinterface {
    3. Public function load ();
    4. }
    6. Class Serializedarrayoutput implements Outputinterface {
    7. Public function load () {
    8. Return serialize ($arrayOfData);
    9. }
    10. }
    12. Class Jsonstringoutput implements Outputinterface {
    13. Public function load () {
    14. Return Json_encode ($arrayOfData);
    15. }
    16. }
    18. Class Arrayoutput implements Outputinterface {
    19. Public function load () {
    20. return $arrayOfData;
    21. }
    22. }
Copy CodeObserver (Viewer mode)

An object can be set to be observable, as long as it allows other objects to be registered as observers in some way. Whenever the object being observed changes, a message is sent to the observer.

    1. !--? php
    2. interface Observer {
    3. function onChanged ($sender, $args);
    4. }
    6. interface Observable {
    7. function addobserver ($observer);
    8. }
    10. class CustomerList implements Observable {
    11. private $_observers = Array ();
    13. Public Function Addcustomer ($name) {
    14. foreach ($this->_observers as $obs)
    15. $obs OnChanged ($this, $name);
    16. }
    18. public Function Addobserver ($observer) {
    19. $this->_observers []= $observer;
    20. }
    21. }
    23. class Customerlistlogger implements Observer {
    24. public function Onchan Ged ($sender, $args) {
    25. echo ("' $args ' Customer have been added to the list \ n");
    26. }
    27. }
    29. $ul = new UserList ();
    30. $ul->addobserver (New Customerlistlogger ());
    31. $ul->addcustomer ("Jack");
Copy CodeChain of responsibility (responsibility chain mode)

This pattern has another salutation: Control chain mode. It consists primarily of a series of processors for certain commands, each of which is passed in the processor-formed chain of responsibility, at each junction by the processor to determine if they need to be responded to and handled. Each handler pauses when the processor processes the requests.

  4. Interface Command {
  6. function OnCommand ($name, $args);
  8. }
  12. Class Commandchain {
  14. Private $_commands = Array ();
  18. Public Function AddCommand ($cmd) {
  20. $this->_commands[]= $cmd;
  22. }
  26. Public Function RunCommand ($name, $args) {
  28. foreach ($this->_commands as $cmd) {
  30. if ($cmd->oncommand ($name, $args))
  32. Return
  34. }
  36. }
  38. }
  42. Class Custcommand implements Command {
  44. Public Function OnCommand ($name, $args) {
  46. if ($name! = ' Addcustomer ')
  48. return false;
  50. Echo ("This is Customercommand handling ' Addcustomer ' \ n");
  52. return true;
  54. }
  56. }
  60. Class Mailcommand implements Command {
  62. Public Function OnCommand ($name, $args) {
  64. if ($name! = ' mail ')
  66. return false;
  68. Echo ("This is Mailcommand handling ' mail ' \ n");
  70. return true;
  72. }
  74. }
  78. $CC = new Commandchain ();
  80. $CC->addcommand (New Custcommand ());
  82. $CC->addcommand (New Mailcommand ());
  84. $CC->runcommand (' Addcustomer ', null);
  86. $CC->runcommand (' mail ', null);
Copy Code
Php

    • This article is an English version of an article which is originally in the Chinese language on aliyun.com and is provided for information purposes only. This website makes no representation or warranty of any kind, either expressed or implied, as to the accuracy, completeness ownership or reliability of the article or any translations thereof. If you have any concerns or complaints relating to the article, please send an email, providing a detailed description of the concern or complaint, to info-contact@alibabacloud.com. A staff member will contact you within 5 working days. Once verified, infringing content will be removed immediately.

    Related Keywords:
    php design patterns php design patterns book php adapter design pattern design patterns in php with example composite design pattern php form design in php creational design patterns in java

    Contact Us

    The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

    If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

    What's Trending
    Top 10 Tags
    datastax versions naming convention zookeeper client class definition md5 microsoft sql server 2005 data structures exception handling error handling
    Top 10 Keywords
    microsoft download center down wordpress address url site address url wordpress address url windows installer 4 0 download 302 not found web address url definition site address url wordpress db2 integer mac os installation step by step pdf abbreviation for return

    A Free Trial That Lets You Build Big!

    Start building with 50+ products and up to 12 months usage for Elastic Compute Service

    Get Started for Free

    • Sales Support

      1 on 1 presale consultation

      Chat Contact Sales

    • After-Sales Support

      24/7 Technical Support 6 Free Tickets per Quarter Faster Response

      Open a Ticket

    • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.

      Learn More