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

2450184176 發布于2019-06-27 11:35 / 3001人閱讀

摘要：事實上，設計模式的解釋如下另一方面，設計模式提供了一種廣泛的可重用的方式來解決我們日常編程中常常遇見的問題。原型模式有些時候，部分對象需要被初始化多次。

本文為翻譯文章

原文地址：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應用的開發中，常常用于允許在運行時為某個特定的類創建一個可訪問的實例。

mix = "test";
$secondProduct->mix = "example";

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

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

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

注冊臺模式并不是很常見，它也不是一個典型的創建模式，只是為了利用靜態方法更方便的存取數據。


Factory(工廠模式)
工廠模式是另一種非常常用的模式，正如其名字所示：確實是對象實例的生產工廠。某些意義上，工廠模式提供了通用的方法有助于我們去獲取對象，而不需要關心其具體的內在的實現。
getProduct();
$factory = new SecondFactory();
$secondProduct = $factory->getProduct();

print_r($firstProduct->getName());
// The first product
print_r($secondProduct->getName());
// Second product
AbstractFactory(抽象工廠模式)
有些情況下我們需要根據不同的選擇邏輯提供不同的構造工廠，而對于多個工廠而言需要一個統一的抽象工廠：
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(對象池)
對象池可以用于構造并且存放一系列的對象并在需要時獲取調用：
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(延遲初始化)
對于某個變量的延遲初始化也是常常被用到的，對于一個類而言往往并不知道它的哪個功能會被用到，而部分功能往往是僅僅被需要使用一次。
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(原型模式)
有些時候，部分對象需要被初始化多次。而特別是在如果初始化需要耗費大量時間與資源的時候進行預初始化并且存儲下這些對象。
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(構造者)
構造者模式主要在于創建一些復雜的對象：
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(裝飾器模式)
裝飾器模式允許我們根據運行時不同的情景動態地為某個對象調用前后添加不同的行為動作。
_html = "__text__";
    }
     
    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("" . $this->_html . "");
    }
     
    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("" . $this->_html . "");
    }
     
    public function __call($name, $args) {
        $this->_element->$name($args[0]);
    }
}
Adapter(適配器模式)
這種模式允許使用不同的接口重構某個類，可以允許使用不同的調用方式進行調用：
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."
";
}
Behavioral Patterns
Strategy(策略模式)
測試模式主要為了讓客戶類能夠更好地使用某些算法而不需要知道其具體的實現。

Observer(觀察者模式)
某個對象可以被設置為是可觀察的，只要通過某種方式允許其他對象注冊為觀察者。每當被觀察的對象改變時，會發送信息給觀察者。
_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 
" );
  }
}

$ul = new UserList();
$ul->addObserver( new CustomerListLogger() );
$ul->addCustomer( "Jack" );
Chain of responsibility(責任鏈模式)
這種模式有另一種稱呼：控制鏈模式。它主要由一系列對于某些命令的處理器構成，每個查詢會在處理器構成的責任鏈中傳遞，在每個交匯點由處理器判斷是否需要對它們進行響應與處理。每次的處理程序會在有處理器處理這些請求時暫停。
_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"
");
        return true;
    }
}

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

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

云服務器 GPU云服務器 php常用設計模式 php的設計模式 php設計模式源碼 Java設計模式之（五）——代理模式

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/21149.html

php資料集

摘要：簡單字符串緩存實戰完整實戰種設計模式設計模式是面向對象的最佳實踐成為專業程序員路上用到的各種優秀資料神器及框架成為一名專業程序員的道路上，需要堅持練習學習與積累，技術方面既要有一定的廣度，更要有自己的深度。微型新聞系統的開發（PHP 5.4 + MySQL 5.5）微型新聞系統的開發（PHP 5.4 + MySQL 5.5）九個很有用的 PHP 代碼 php 代碼國內值得關注的...

RobinQu 2019-06-28 14:30 評論0 收藏0
php設計模式

摘要：我們今天也來做一個萬能遙控器設計模式適配器模式將一個類的接口轉換成客戶希望的另外一個接口。今天要介紹的仍然是創建型設計模式的一種建造者模式。設計模式的理論知識固然重要，但計算機程序的思維邏輯 (54) - 剖析 Collections - 設計模式上節我們提到，類 Collections 中大概有兩類功能，第一類是對容器接口對象進行操作，第二類是返回一個容器接口對象，上節我們介紹了...

Dionysus_go 2019-06-28 14:37 評論0 收藏0
php設計模式

摘要：我們今天也來做一個萬能遙控器設計模式適配器模式將一個類的接口轉換成客戶希望的另外一個接口。今天要介紹的仍然是創建型設計模式的一種建造者模式。設計模式的理論知識固然重要，但計算機程序的思維邏輯 (54) - 剖析 Collections - 設計模式上節我們提到，類 Collections 中大概有兩類功能，第一類是對容器接口對象進行操作，第二類是返回一個容器接口對象，上節我們介紹了...

vspiders 2019-06-28 14:33 評論0 收藏0
PHPer書單

摘要：想提升自己，還得多看書多看書多看書下面是我收集到的一些程序員應該看得書單及在線教程，自己也沒有全部看完。共勉吧當然，如果你有好的書想分享給大家的或者覺得書單不合理，可以去通過進行提交。講師溫銘，軟件基金會主席，最佳實踐作者。想提升自己，還得多看書！多看書！多看書！下面是我收集到的一些PHP程序員應該看得書單及在線教程，自己也沒有全部看完。共勉吧！當然，如果你有好的書想分享給大家的或者...

jimhs 2019-07-01 12:35 評論0 收藏0
PHP基礎

摘要：分別為適配器模式，裝飾器模式，代理模式，外觀模式，橋接模式，組合模式，享元模式。設計模式五適配器模式適配器模式將某個對象的接生成器和協程的實現在這篇文章中，作者針對那些比較難以理解的概念，以一個更為通俗的方式去講明白。。 PHP 源碼注解 PHP 的詳細源碼注解 PHP 字符串操作整理一些有關字符串的常用操作。 Redis 常見七種使用場景 (PHP 實戰) 這篇文章主要介紹利用 R...

HtmlCssJs 2019-06-28 14:29 評論0 收藏0