PHP 实战之设计模式：PHP 中的设计模式

2450184176 发布于2019-06-27 11:35 / 2988人阅读

摘要：事实上，设计模式的解释如下另一方面，设计模式提供了一种广泛的可重用的方式来解决我们日常编程中常常遇见的问题。原型模式有些时候，部分对象需要被初始化多次。

本文为翻译文章

原文地址：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设计模式之（五）——代理模式

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/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