PHP 中的设计模式详解

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)

结构型模式

十七、Composite,组合模式

《Java Design Pattern:
Composite》

十八、Facade,外观模式

《Java Design Pattern:
Facade》

十九、Proxy,代理模式

《Java Design Pattern Story for Proxy – A Slutty
Lady》

二十、Adapter,适配器模式

《案例:模式的秘密—适配器模式(中文视频)》

所谓适配器,就是连接“源”和“目标”的纽带。本课程由生活中常见的例子入手,讲述适配器模式的组成和应用,为你的
Java 达人锻造添砖加瓦

二十一、Decrator,装饰模式

《Java Design Pattern: Decorator – Decorate your
girlfriend》

二十二、Bridge,桥模式

《讲故事,学(Java)设计模式—桥接模式》

简单来讲,桥接模式是一个两层的抽象。桥接模式是用于“把抽象和实现分开,这样它们就能独立变化”。
桥接模式使用了封装、聚合,可以用继承将不同的功能拆分为不同的类。

二十三、Flyweight,享元模式

《Java Design Pattern:
Flyweight》

赞 16 收藏 1
评论

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

关于作者:伯小乐

澳门新葡亰娱乐在线 1

伯乐在线小编一枚~~~~PS:我不是@小编辑,不要问我了
个人主页 ·
我的文章 ·
261

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" );

行为型模式

六、Iterator,迭代器模式

澳门新葡亰娱乐在线,《Java Design Pattern:
Iterator》

七、Observer,观察者模式

《讲故事,学(Java)设计模式—观察者模式》

简而言之,观察者模式=发布者+注册者。观察者模式用来对GUI中的动作做侦听。Swing
GUI的例子就表明了动作侦听是怎样实现观察者模式的。

八、Template Method,模板方法

《案例:模式的秘密—模板方法模式(中文视频)》

模板方法模式是在日常开发中使用最为广泛的设计模式之一。通过本视频,你可以了解什么是模板方法模式,如何用
Java 语言实现模板方法模式。@Arthur
将用简单生动的例子带你领略模板方法模式的真意,最后还将用实际的行业案例告诉你模板方法模式的强大功能。

九、Command,命令模式

《Java Design Pattern:
Command》

十、State,状态模式

《Java Design Pattern:
State》

十一、Strategy,策略模式

《Java Design Pattern:
Strategy》

十二、Chain of Responsibility,职责链模式

《Java Design Pattern: Chain of
Responsibility》

十三、Mediator,中介者模式

《Java Design Pattern:
Mediator》

十四、Visitor,访问者模式

《Java Design Pattern:
Visitor》

十五、Interpreter,解释器模式

《Java Design Pattern:
Interpreter》

十六、Memento,备忘录模式

《Java Design Pattern:
Memento》

Structural Patterns

创建型模式

一、Singleton,单例模式

《案例:模式的秘密—单例模式(视频)》

设计模式是前辈们在多年开发工作中经验的总结,可以提高代码的可重用性、可靠性和规范性,让代码更容易理解,而单例模式是其中最重要、最简单、最常用的设计模式之一,让我们一起来揭开它的神秘面纱吧。

《讲故事,学(Java)设计模式—单例模式》

单例模式是Java中最常用的设计模式之一,它通过阻禁止外部实例化和修改,对象的方式来控制所创建的对象的数量。这个概念可以被广泛地推广到仅使用有一个现存的对象能更高效运行的系统,或者是限制在若干个对象实例化为特定的数目的高效系统环境系统中。

二、Abstract Factory,抽象工厂

《讲故事,学(Java)设计模式—抽象工厂模式》

抽象工厂模式是在工厂模式的基础上增加的一层抽象概念。如果比较抽象工厂模式和工厂模式,我们不难发现前者只是增加了一层抽象的概念。抽象工厂是一个父类工厂,可以创建其它工厂类。故我们也叫它“工厂的工厂”。

三、Factory,工厂模式

《讲故事,学(Java)设计模式—工厂模式》

工厂模式是根据不同的参数创建对象。例如用工厂创建人。
如果我们想要一个男孩,工厂就会为我们生产一个男孩;如果我们需要一个女孩,工厂则会为我们生产一个女孩。工厂会根据不同的参数,为我们提供不同的物品。

四、Builder,建造者模式

《讲故事,学(Java)设计模式—建造者模式》

建造者模式的关键特性是它将一个建造过程分解成很多步骤,也可以说,每个产品的建造会遵循同样的流程,不过流程内的每一个步骤都不尽相同。

五、Prototype,原型模式

《讲故事,学(Java)设计模式—原型模式》

原型模式被用在频繁调用且极其相似的对象上,它会克隆对象并设置改变后的属性,而且消耗的资源较少。

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

本文作者: 伯乐在线 –
伯小乐
。未经作者许可,禁止转载!
欢迎加入伯乐在线 专栏作者。

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;
    }
}

学习设计模式的方法有很多。全面深入地学习,可以选择经典设计模式书籍。或者通过简短、清晰的教程快速了解设计模式。本文整理了23个设计模式的简明教程,其中多篇以讲故事的方式来学习设计模式。

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]);
    }
}

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

另一方面,设计模式提供了一种广泛的可重用的方式来解决我们日常编程中常常遇见的问题。设计模式并不一定就是一个类库或者第三方框架,它们更多的表现为一种思想并且广泛地应用在系统中。它们也表现为一种模式或者模板,可以在多个不同的场景下用于解决问题。设计模式可以用于加速开发,并且将很多大的想法或者设计以一种简单地方式实现。当然,虽然设计模式在开发中很有作用,但是千万要避免在不适当的场景误用它们。

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);

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/>";
}

发表评论

电子邮件地址不会被公开。 必填项已用*标注

相关文章

网站地图xml地图