PHP 中的設計模式

segmentfault發表於2016-04-09

　　本文主要討論下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應用的開發中，常常用於允許在執行時為某個特定的類建立一個可訪問的例項。

<?php
/**
 * Singleton class
 */
final class Product
{

    /**
     * @var self
     */
    private static $instance;

    /**
     * @var mixed
     */
    public $mix;


    /**
     * Return self instance
     *
     * @return self
     */
    public static function getInstance() {
        if (!(self::$instance instanceof self)) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    private function __construct() {
    }

    private function __clone() {
    }
}

$firstProduct = Product::getInstance();
$secondProduct = Product::getInstance();

$firstProduct->mix = 'test';
$secondProduct->mix = 'example';

print_r($firstProduct->mix);
// example
print_r($secondProduct->mix);
// example

　　在很多情況下，需要為系統中的多個類建立單例的構造方式，這樣，可以建立一個通用的抽象父工廠方法：

<?php

abstract class FactoryAbstract {

    protected static $instances = array();

    public static function getInstance() {
        $className = static::getClassName();
        if (!(self::$instances[$className] instanceof $className)) {
            self::$instances[$className] = new $className();
        }
        return self::$instances[$className];
    }

    public static function removeInstance() {
        $className = static::getClassName();
        if (array_key_exists($className, self::$instances)) {
            unset(self::$instances[$className]);
        }
    }

    final protected static function getClassName() {
        return get_called_class();
    }

    protected function __construct() { }

    final protected function __clone() { }
}

abstract class Factory extends FactoryAbstract {

    final public static function getInstance() {
        return parent::getInstance();
    }

    final public static function removeInstance() {
        parent::removeInstance();
    }
}
// using:

class FirstProduct extends Factory {
    public $a = [];
}
class SecondProduct extends FirstProduct {
}

FirstProduct::getInstance()->a[] = 1;
SecondProduct::getInstance()->a[] = 2;
FirstProduct::getInstance()->a[] = 3;
SecondProduct::getInstance()->a[] = 4;

print_r(FirstProduct::getInstance()->a);
// array(1, 3)
print_r(SecondProduct::getInstance()->a);
// array(2, 4)

　　Registry

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

<?php
/**
* Registry class
*/
class Package {

    protected static $data = array();

    public static function set($key, $value) {
        self::$data[$key] = $value;
    }

    public static function get($key) {
        return isset(self::$data[$key]) ? self::$data[$key] : null;
    }

    final public static function removeObject($key) {
        if (array_key_exists($key, self::$data)) {
            unset(self::$data[$key]);
        }
    }
}


Package::set('name', 'Package name');

print_r(Package::get('name'));
// Package name

　　Factory(工廠模式)

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

<?php

interface Factory {
    public function getProduct();
}

interface Product {
    public function getName();
}

class FirstFactory implements Factory {

    public function getProduct() {
        return new FirstProduct();
    }
}

class SecondFactory implements Factory {

    public function getProduct() {
        return new SecondProduct();
    }
}

class FirstProduct implements Product {

    public function getName() {
        return 'The first product';
    }
}

class SecondProduct implements Product {

    public function getName() {
        return 'Second product';
    }
}

$factory = new FirstFactory();
$firstProduct = $factory->getProduct();
$factory = new SecondFactory();
$secondProduct = $factory->getProduct();

print_r($firstProduct->getName());
// The first product
print_r($secondProduct->getName());
// Second product

　　AbstractFactory(抽象工廠模式)

　　有些情況下我們需要根據不同的選擇邏輯提供不同的構造工廠，而對於多個工廠而言需要一個統一的抽象工廠：

<?php

class Config {
    public static $factory = 1;
}

interface Product {
    public function getName();
}

abstract class AbstractFactory {

    public static function getFactory() {
        switch (Config::$factory) {
            case 1:
                return new FirstFactory();
            case 2:
                return new SecondFactory();
        }
        throw new Exception('Bad config');
    }

    abstract public function getProduct();
}

class FirstFactory extends AbstractFactory {
    public function getProduct() {
        return new FirstProduct();
    }
}
class FirstProduct implements Product {
    public function getName() {
        return 'The product from the first factory';
    }
}

class SecondFactory extends AbstractFactory {
    public function getProduct() {
        return new SecondProduct();
    }
}
class SecondProduct implements Product {
    public function getName() {
        return 'The product from second factory';
    }
}

$firstProduct = AbstractFactory::getFactory()->getProduct();
Config::$factory = 2;
$secondProduct = AbstractFactory::getFactory()->getProduct();

print_r($firstProduct->getName());
// The first product from the first factory
print_r($secondProduct->getName());
// Second product from second factory

　　Object pool(物件池)

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

<?php

class Product {

    protected $id;

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

    public function getId() {
        return $this->id;
    }
}

class Factory {

    protected static $products = array();

    public static function pushProduct(Product $product) {
        self::$products[$product->getId()] = $product;
    }

    public static function getProduct($id) {
        return isset(self::$products[$id]) ? self::$products[$id] : null;
    }

    public static function removeProduct($id) {
        if (array_key_exists($id, self::$products)) {
            unset(self::$products[$id]);
        }
    }
}


Factory::pushProduct(new Product('first'));
Factory::pushProduct(new Product('second'));

print_r(Factory::getProduct('first')->getId());
// first
print_r(Factory::getProduct('second')->getId());
// second

　　Lazy Initialization(延遲初始化)

　　對於某個變數的延遲初始化也是常常被用到的，對於一個類而言往往並不知道它的哪個功能會被用到，而部分功能往往是僅僅被需要使用一次。

<?php

interface Product {
    public function getName();
}

class Factory {

    protected $firstProduct;
    protected $secondProduct;

    public function getFirstProduct() {
        if (!$this->firstProduct) {
            $this->firstProduct = new FirstProduct();
        }
        return $this->firstProduct;
    }

    public function getSecondProduct() {
        if (!$this->secondProduct) {
            $this->secondProduct = new SecondProduct();
        }
        return $this->secondProduct;
    }
}

class FirstProduct implements Product {
    public function getName() {
        return 'The first product';
    }
}

class SecondProduct implements Product {
    public function getName() {
        return 'Second product';
    }
}


$factory = new Factory();

print_r($factory->getFirstProduct()->getName());
// The first product
print_r($factory->getSecondProduct()->getName());
// Second product
print_r($factory->getFirstProduct()->getName());
// The first product

　　Prototype(原型模式)

　　有些時候，部分物件需要被初始化多次。而特別是在如果初始化需要耗費大量時間與資源的時候進行預初始化並且儲存下這些物件。

<?php

interface Product {
}

class Factory {

    private $product;

    public function __construct(Product $product) {
        $this->product = $product;
    }

    public function getProduct() {
        return clone $this->product;
    }
}

class SomeProduct implements Product {
    public $name;
}


$prototypeFactory = new Factory(new SomeProduct());

$firstProduct = $prototypeFactory->getProduct();
$firstProduct->name = 'The first product';

$secondProduct = $prototypeFactory->getProduct();
$secondProduct->name = 'Second product';

print_r($firstProduct->name);
// The first product
print_r($secondProduct->name);
// Second product

　　Builder(構造者)

　　構造者模式主要在於建立一些複雜的物件：

<?php

class Product {

    private $name;

    public function setName($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Builder {

    protected $product;

    final public function getProduct() {
        return $this->product;
    }

    public function buildProduct() {
        $this->product = new Product();
    }
}

class FirstBuilder extends Builder {

    public function buildProduct() {
        parent::buildProduct();
        $this->product->setName('The product of the first builder');
    }
}

class SecondBuilder extends Builder {

    public function buildProduct() {
        parent::buildProduct();
        $this->product->setName('The product of second builder');
    }
}

class Factory {

    private $builder;

    public function __construct(Builder $builder) {
        $this->builder = $builder;
        $this->builder->buildProduct();
    }

    public function getProduct() {
        return $this->builder->getProduct();
    }
}

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

print_r($firstDirector->getProduct()->getName());
// The product of the first builder
print_r($secondDirector->getProduct()->getName());
// The product of second builder

　Structural Patterns

　　Decorator(裝飾器模式)

　　裝飾器模式允許我們根據執行時不同的情景動態地為某個物件呼叫前後新增不同的行為動作。

<?php
class HtmlTemplate {
    // any parent class methods
}
 
class Template1 extends HtmlTemplate {
    protected $_html;
     
    public function __construct() {
        $this->_html = "<p>__text__</p>";
    }
     
    public function set($html) {
        $this->_html = $html;
    }
     
    public function render() {
        echo $this->_html;
    }
}
 
class Template2 extends HtmlTemplate {
    protected $_element;
     
    public function __construct($s) {
        $this->_element = $s;
        $this->set("<h2>" . $this->_html . "</h2>");
    }
     
    public function __call($name, $args) {
        $this->_element->$name($args[0]);
    }
}
 
class Template3 extends HtmlTemplate {
    protected $_element;
     
    public function __construct($s) {
        $this->_element = $s;
        $this->set("<u>" . $this->_html . "</u>");
    }
     
    public function __call($name, $args) {
        $this->_element->$name($args[0]);
    }
}

　　Adapter(介面卡模式)

　　這種模式允許使用不同的介面重構某個類，可以允許使用不同的呼叫方式進行呼叫：

<?php

class SimpleBook {

    private $author;
    private $title;

    function __construct($author_in, $title_in) {
        $this->author = $author_in;
        $this->title  = $title_in;
    }

    function getAuthor() {
        return $this->author;
    }

    function getTitle() {
        return $this->title;
    }
}

class BookAdapter {

    private $book;

    function __construct(SimpleBook $book_in) {
        $this->book = $book_in;
    }
    function getAuthorAndTitle() {
        return $this->book->getTitle().' by '.$this->book->getAuthor();
    }
}

// Usage
$book = new SimpleBook("Gamma, Helm, Johnson, and Vlissides", "Design Patterns");
$bookAdapter = new BookAdapter($book);
echo 'Author and Title: '.$bookAdapter->getAuthorAndTitle();

function echo $line_in) {
  echo $line_in."<br/>";
}

　Behavioral Patterns

　　Strategy(策略模式)

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

<?php

interface OutputInterface {
    public function load();
}

class SerializedArrayOutput implements OutputInterface {
    public function load() {
        return serialize($arrayOfData);
    }
}

class JsonStringOutput implements OutputInterface {
    public function load() {
        return json_encode($arrayOfData);
    }
}

class ArrayOutput implements OutputInterface {
    public function load() {
        return $arrayOfData;
    }
}

　　Observer(觀察者模式)

　　某個物件可以被設定為是可觀察的，只要通過某種方式允許其他物件註冊為觀察者。每當被觀察的物件改變時，會傳送資訊給觀察者。

<?php

interface Observer {
  function onChanged($sender, $args);
}

interface Observable {
  function addObserver($observer);
}

class CustomerList implements Observable {
  private $_observers = array();

  public function addCustomer($name) {
    foreach($this->_observers as $obs)
      $obs->onChanged($this, $name);
  }

  public function addObserver($observer) {
    $this->_observers []= $observer;
  }
}

class CustomerListLogger implements Observer {
  public function onChanged($sender, $args) {
    echo( "'$args' Customer has been added to the list \n" );
  }
}

$ul = new UserList();
$ul->addObserver( new CustomerListLogger() );
$ul->addCustomer( "Jack" );

　　Chain of responsibility(責任鏈模式)

　　這種模式有另一種稱呼：控制鏈模式。它主要由一系列對於某些命令的處理器構成，每個查詢會在處理器構成的責任鏈中傳遞，在每個交匯點由處理器判斷是否需要對它們進行響應與處理。每次的處理程式會在有處理器處理這些請求時暫停。

<?php

interface Command {
    function onCommand($name, $args);
}

class CommandChain {
    private $_commands = array();

    public function addCommand($cmd) {
        $this->_commands[]= $cmd;
    }

    public function runCommand($name, $args) {
        foreach($this->_commands as $cmd) {
            if ($cmd->onCommand($name, $args))
                return;
        }
    }
}

class CustCommand implements Command {
    public function onCommand($name, $args) {
        if ($name != 'addCustomer')
            return false;
        echo("This is CustomerCommand handling 'addCustomer'\n");
        return true;
    }
}

class MailCommand implements Command {
    public function onCommand($name, $args) {
        if ($name != 'mail')
            return false;
        echo("This is MailCommand handling 'mail'\n");
        return true;
    }
}

$cc = new CommandChain();
$cc->addCommand( new CustCommand());
$cc->addCommand( new MailCommand());
$cc->runCommand('addCustomer', null);
$cc->runCommand('mail', null);

　　原文地址：Design Patterns in PHP

PHP 實戰之設計模式：PHP 中的設計模式
2016-07-18
PHP設計模式
php中的設計模式
2021-09-09
PHP設計模式
PHP 中的設計模式詳解
2016-04-09
PHP設計模式
PHP 設計模式
2020-02-27
PHP設計模式
php設計模式
2019-02-16
PHP設計模式
PHP設計模式—建立型設計模式
2017-05-13
PHP設計模式
PHP設計模式-代理模式
2021-09-09
PHP設計模式
php設計模式–策略模式
2017-11-07
PHP設計模式
PHP_設計模式
2017-05-26
PHP設計模式
PHP設計模式之外觀模式
2020-08-07
PHP設計模式
PHP 設計模式之流介面模式
2020-06-24
PHP設計模式
PHP 設計模式之策略模式
2020-06-16
PHP設計模式
PHP設計模式-- 單列模式
2019-03-28
PHP設計模式
PHP設計模式-- 工廠模式
2019-03-28
PHP設計模式
PHP設計模式-觀察者模式
2019-02-16
PHP設計模式
PHP設計模式（3）—— 策略模式
2018-11-30
PHP設計模式
PHP設計模式_工廠模式
2018-02-01
PHP設計模式
PHP設計模式_單例模式
2018-01-31
PHP設計模式單例
PHP設計模式（7）代理模式
2017-11-11
PHP設計模式
PHP設計模式——單例模式
2015-04-21
PHP設計模式單例
【設計模式】漢堡中的設計模式——策略模式
2021-12-03
設計模式
PHP 設計模式之單例模式
2020-06-14
PHP設計模式單例
PHP 設計模式之觀察者模式
2020-06-13
PHP設計模式
PHP 設計模式之橋接模式
2020-07-04
PHP設計模式橋接
PHP設計模式之模板方法模式
2020-08-09
PHP設計模式
PHP設計模式之觀察者模式
2020-07-31
PHP設計模式
PHP 設計模式之狀態模式
2020-01-07
PHP設計模式
PHP 設計模式之組合模式
2020-06-22
PHP設計模式
PHP 設計模式之——單例模式
2019-02-16
PHP設計模式單例
PHP 設計模式之——觀察者模式
2019-02-16
PHP設計模式
PHP設計模式（5）—— 觀察者模式
2018-11-30
PHP設計模式
php設計模式之註冊模式
2020-11-04
PHP設計模式
PHP設計模式之單例模式
2020-11-04
PHP設計模式單例
PHP設計模式之工廠模式
2020-11-04
PHP設計模式
PHP設計模式_註冊樹模式
2018-02-01
PHP設計模式
PHP設計模式_介面卡模式
2018-02-01
PHP設計模式
PHP設計模式 - 註冊樹模式
2018-03-13
PHP設計模式
php模式設計之觀察者模式
2015-09-22
PHP模式

PHP 中的設計模式

Creational Patterns

Singleton(單例模式)

Registry

Factory(工廠模式)

AbstractFactory(抽象工廠模式)

Object pool(物件池)

Lazy Initialization(延遲初始化)

Prototype(原型模式)

Builder(構造者)

Structural Patterns

Decorator(裝飾器模式)

Adapter(介面卡模式)

Behavioral Patterns

Strategy(策略模式)

Observer(觀察者模式)

Chain of responsibility(責任鏈模式)

相關文章

　Creational Patterns

　　Singleton(單例模式)

　　Registry

　　Factory(工廠模式)

　　AbstractFactory(抽象工廠模式)

　　Object pool(物件池)

　　Lazy Initialization(延遲初始化)

　　Prototype(原型模式)

　　Builder(構造者)

　Structural Patterns

　　Decorator(裝飾器模式)

　　Adapter(介面卡模式)

　Behavioral Patterns

　　Strategy(策略模式)

　　Observer(觀察者模式)

　　Chain of responsibility(責任鏈模式)