PHP设计模式之原型模式定义与用法详解

本文实例讲述了php设计模式之原型模式定义与用法。分享给大家供大家参考，具体如下：

原型设计模式(prototype design pattern)很有意思, 因为它使用了一种克隆技术来复制实例化的对象. 新对象是通过复制原型实例来创建的. 在这里, 实例是批实例化的具体类.原型设计模式的目的是通过使用克隆来减少实例化对象的开销.与其从一个类实例化新对象, 完全可以使用一个已有实例的克隆.

克隆函数

php中使用原型设计模式的关键是要了解如何使用内置函数__clone().

<?php
abstract class cloneobject
{
  public $name;
  public $picture;
  abstract function __clone();
}
class boy extends cloneobject
{
  public function __construct()
  {
    $this->face = "handsome";
    $this->name = "chenqionghe";
  }
  public function display()
  {
    echo 'look : '.$this->face;;
    echo '<br />'.$this->name.'<br />';
  }
  public function __clone() {}
}
$boy = new boy();
$boy->display();
$cloneboy = clone $boy;
$cloneboy->face = "still handsome";
$cloneboy->display();

运行结果如下

look : handsome
chenqionghe
look : still handsome
chenqionghe

$cloneboy实例是通过克隆boy的实例$boy, 它可以像$boy一样访问相同的属性, 而且像boy类的直接实例一样改变这些属性.

注意: 对于所克隆的实例 , clone关键字会为该实例的类实例化另一个实例(使用克隆关键字可以创建一个类的副本, 如果可能, 会自动调用对象的__clone方法, 但不能直接调用 对象的__clone方法), 关于过程, 有一点需要注意的是, 克隆不会不会启动构造函数中的动作.

简单的原型例子

我们以研究果蝇为例.研究的目标是建立一个原型果蝇, 然后一旦出现变异, 就构建这个变异果蝇

抽象类接口和具体实现

原型(iprototype)的两个具体类实现分别表示不同性别的果蝇, 包括性别变量(gender)和不同性别的和行为.

iprototype.php

<?php
abstract class iprototype
{
  public $eyecolor;
  public $winbeat;
  public $uniteypes;
  abstract function __clone();
}

iprototype的这两个实现的区别体现在性别上, 性别用常量标识, 一个是male,另一个是femail.雄果蝇有一个$mated布尔变量, 雄果蝇交配后,这个布尔变量会设置为true, 雌果蝇有一个$fecundity变量,其中包含一个数字值, 表示这只雄果蝇的繁殖能力(产卵个数):

maleproto.php

<?php
include_once('iprototype.php');
class maleproto extends iprototype
{
  const gender = "male";
  public $mated;
  public function __construct()
  {
    $this->eyecolor = "red";
    $this->winbeat = "220";
    $this->uniteypes = "760";
  }
  public function __clone(){}
}

femaleproto.php

<?php
include_once('iprototype.php');
class femaleproto extends iprototype
{
  const gender = "femail";
  public $fecundity;
  public function __construct()
  {
    $this->eyecolor = "red";
    $this->winbeat = "220";
    $this->uniteypes = "760";
  }
  public function __clone(){}
}

客户

在原型设计模式中,clien类确实是一个不可缺少的部分.原因在于, 尽管要将子类具体实现作为实例的模板,但使用相同的模板克隆实例的具体工作是由client类完成的

client.php

<?php
function __autoload($class_name)
{
  include_once $class_name.'.php';
}
class client
{
  //用于直接实例化
  private $fly1;
  private $fly2;
  //用于克隆
  private $c1fly;
  private $c2fly;
  private $updatedclonefly;
  public function __construct()
  {
    //实例化
    $this->fly1 = new maleproto();
    $this->fly2 = new femaleproto();
    //克隆
    $this->c1fly = clone $this->fly1;
    $this->c2fly = clone $this->fly2;
    $this->updatedclonefly = clone $this->fly2;
    //更新克隆
    $this->c1fly->mated = "true";
    $this->c2fly->fecundity = '186';
    $this->updatedclonefly->eyecolor = "purple";
    $this->updatedclonefly->winbeat = "220";
    $this->updatedclonefly->uniteyes = '750';
    $this->updatedclonefly->fecundity = '92';
    //通过类型提示方法发送
    $this->showfly($this->c1fly);
    $this->showfly($this->c2fly);
    $this->showfly($this->updatedclonefly);
  }
  private function showfly(iprototype $fly)
  {
    echo "eye color: ".$fly->eyecolor."<br />";
    echo "wing beats/second: ".$fly->winbeat."<br />";
    echo "eye units: ".$fly->uniteypes."<br />";
    $gendernow = $fly::gender;
    echo "gender: ".$gendernow."<br />";
    if($gendernow == "femail")
    {
      echo "number of eggs: ".$fly->fecundity."<hr />";
    }
    else
    {
      echo "mated: ".$fly->mated."<hr />";
    }
  }
}
$worker = new client();

运行结果如下

eye color: red
wing beats/second: 220
eye units: 760
gender: male
mated: trueeye color: red
wing beats/second: 220
eye units: 760
gender: femail
number of eggs: 186eye color: purple
wing beats/second: 220
eye units: 760
gender: femail
number of eggs: 92

原型模式要依赖客户通过 不念克隆过程使用具体原型.在这个设计过程中, 客户是完成克隆的参与者, 由于克隆是原型设计中的关键要素, 所以客户是一个基本参与者, 而不仅仅是一个请求类.

现代企业组织

在创建型设计模式方面,现代企业组织就非常适合原型实现.现在企业组织往往是复杂而庞大的层次结构, 像面向对象编程一样,要为很多共同的特征建模.现在通过一个例子描述软件工程公司.

软件工程公司是一个典型的现代组织.工程部(engineering department)负责创建产品,管理部(management)处理资源的协调组织,市场部(marketing)负责产品的销售,推广和整体营销.

接口中的封装

在这个原型实现中,首先为程序的接口(一个抽象类)增加oop,与所有原型接口一样,这个接口包含一个克隆操作.另外它还包含一些抽象和具体的获取方法和设置方法.其中有一个抽象获取方法/设置方法对,但要由3个具体原型实现为这个抽象获取方法/设置方法对提供具体实现.其他获取方法和设置方法分分别应用于员工名,id码和照片等属性.注意所有这些属性都是保护属性(protected),所以尽管具体的获取方法和设置方法有公共可见性,但由于操作中使用的属性具有保护和可见性,这就提供了某种程度的封装:

<?php
abstract class iacmeprototype
{
  protected $name;
  protected $id;
  protected $employeepic;
  protected $department;
  //部门
  abstract function setdept($orgcode);
  abstract function getdept();
  //名字
  public function setname($emname)
  {
    $this->name = $emname;
  }
  public function getname()
  {
    return $this->name;
  }
  //id
  public function setid($emid)
  {
    $this->id = $emid;
  }
  public function getid()
  {
    return $this->id;
  }
  //雇员图像
  public function setpic($epic)
  {
    $this->employeepic = $epic;
  }
  public function getpic()
  {
    return $this->employeepic;
  }
  abstract function __clone();
}

利用这些获取方法和设置方法, 所有属性的值都通过继承的保护变量来设置.采用这种设计, 扩展类及其实例可以得到更好的封装.

接口实现

3个iacmeprototype子类都必须实现"dept"抽象方法以及__clone()方法.类似地, 每个具体原型类还包含一个常量unit,它提供一个赋值,可以由实例(包括克隆的对象)作为标识

首先来看市场部的marketing类:

marketing.php

<?php
include_once('iacmeprototype.php');
class marketing extends iacmeprototype
{
  const unit = "marketing";
  private $sales = "sales";
  private $promotion = "promotion";
  private $strategic = "strategic planning";
  public function setdept($orgcode)
  {
    switch($orgcode)
    {
      case 101:
        $this->department = $this->sales;
        break;
      case 102:
        $this->department = $this->promotion;
        break;
      case 103:
        $this->department = $this->strategic;
        break;
      default :
        $this->department = "未识别的市场部";
    }
  }
  public function getdept()
  {
    return $this->department;
  }
  public function __clone() {}
}

setdept()方法的实现使用了一个参数.并不是直接输入市场部的部门,这个方法的参数是一个数字码, 通过一个switch语句,限制了3种可接受的情况和默认情况,别外两个原型实现也类似

management.php

<?php
include_once('iacmeprototype.php');
class management extends iacmeprototype
{
  const unit = "management";
  private $research = "research";
  private $plan = "planning";
  private $operations = "operations";
  public function setdept($orgcode)
  {
    switch($orgcode)
    {
      case 201:
        $this->department = $this->research;
        break;
      case 202:
        $this->department = $this->plan;
        break;
      case 203:
        $this->department = $this->operations;
        break;
      default :
        $this->department = "未识别的管理部";
    }
  }
  public function getdept()
  {
    return $this->department;
  }
  public function __clone() {}
}

engineering.php

<?php
include_once('iacmeprototype.php');
class engineering extends iacmeprototype
{
  const unit = "engineering";
  private $development = "development";
  private $design = "design";
  private $sysad = "system administration";
  public function setdept($orgcode)
  {
    switch($orgcode)
    {
      case 301:
        $this->department = $this->development;
        break;
      case 302:
        $this->department = $this->design;
        break;
      case 303:
        $this->department = $this->sysad;
        break;
      default :
        $this->department = "未识别的工程部";
    }
  }
  public function getdept()
  {
    return $this->department;
  }
  public function __clone() {}
}

以上这3个具体原型实现分别有其特定用途,不过它们都符合接口,可以创建各个原型实现的一个实例, 然后根据需要克隆多个实例.这个克隆的工作由client类完成

客户

客户的设置非常简单: 分别创建各个具体原型的一个实例, 然后按以下列表来克隆各个实例:

市场部门实例:
-----市场部门克隆
-----市场部门克隆
管理部门实例
-----管理部门克隆
工程部门实例
-----工程部门克隆
-----工程部门克隆

将来只使用这些克隆对象.使用获取方法和设置方法将各个特定情况的信息赋给这些克隆对象.以下是client的实现

client.php

<?php
function __autoload($class_name)
{
  include_once $class_name.'.php';
}
class client
{
  private $market;
  private $manage;
  private $engineer;
  public function __construct()
  {
    $this->makeconproto();
    $tess = clone $this->market;
    $this->setemployee($tess, "tess smith" , 101, 'ts101-1234', 'tess.png');
    $this->showemployee($tess);
    $jacob = clone $this->market;
    $this->setemployee($jacob, "jacob jones" , 101, 'jj101-2234', 'jacob.png');
    $this->showemployee($jacob);
    $ricky = clone $this->manage;
    $this->setemployee($ricky, "ricky rodriguez" , 203, 'rr101-5634', 'ricky.png');
    $this->showemployee($ricky);
    $olivaia = clone $this->engineer;
    $this->setemployee($olivaia, "olivaia perez" , 302, 'op301-1278', 'olivia.png');
    $this->showemployee($olivaia);
    $john = clone $this->engineer;
    $this->setemployee($john, "john jacson" , 101, 'jj301-14548', 'john.png');
    $this->showemployee($john);
  }
  private function makeconproto()
  {
    $this->market = new marketing();
    $this->manage = new management();
    $this->engineer = new engineering();
  }
  private function showemployee(iacmeprototype $employeenow)
  {
    $px = $employeenow->getpic();
    echo "<img src=$px width='150' height='150' /><br />";
    echo $employeenow->getname().'<br />';
    echo $employeenow->getdept().':'.$employeenow::unit.'<br />';
    echo $employeenow->getid().'<hr />';
  }
  private function setemployee(iacmeprototype $employeenow, $nm, $dp, $id, $px)
  {
    $employeenow->setname($nm);
    $employeenow->setdept($dp);
    $employeenow->setid($id);
    $employeenow->setpic($px);
  }
}
$worker = new client();

解释:

客户client的构造函数类包含3个私有属性, 用来分别实例化3个具体原型类. makeconpro()方法生成必要的实例.

接下来,使用克隆技术创建一个"员工"实例.然后,这个实例向一个设置方法setemployee()发送特定的实例信息,这个设置方法使用iacmeprototype接口类型提示,不过需要说明, 它只对第一个参数使用类型提示,其他参数都没有类型提示, 并不要求它们派生自iacmeprototype接口.克隆"员工"可以使用iacmeprototype抽象类的所有设置方法以及具体原型类实现的setdept()方法.

要使用各个员工的数据,client类可以使用继承的获取方法.以下是运行client输出的结果

tess smith
sales:marketing
ts101-1234
jacob jones
sales:marketing
jj101-2234
ricky rodriguez
operations:management
rr101-5634
olivaia perez
design:engineering
op301-1278
john jacson
未识别的工程部:engineering
jj301-14548

可以根据需要增加更多的克隆, 而且只需要对具体原型类完成一次实例化.使用原型模式时, 并不是建立具体类的多个实例,而只需要一个类实例化和多个克隆.

完成修改,增加特性

要记住,最重要(可能也是最基本)的是, 设计模式允许开发人员修改和增补程序,而不必一切从头开始.例如, 假设总裁决定公司增加一个新的部门,比如研究部门(research), 这会很难吗?一点也不难.research可以扩展iacmeprototype抽象类, 然后实现抽象获取方法和设置方法来反映这个研究部门的组织.需要说明,client类中获取方法和设置方法使用的代码提示指示一个接口,而不是一个抽象类的具体实现.所以, 只要增加的单元正确地实现了这个接口,就能顺利地增加到应用中, 而不会带来波动,也不需要对程序中的其他参与者进行重构.

不仅可以增加更多的具体类, 还可以很容易地对各个类进行修改, 而不会造成破坏.例如假设这个组织的市场部决定,除了现有的部门外, 他们还需要一个特殊的在线市场部,. 这样一来, switch/case操作需要一个新的分支(case), 还要有一个新的私有属性(变量)来描述新增的这个部门.这个改变将封冻在单独的类中, 而不会影响其他参与者.由于这种改变不会带来破坏, 所以应用的规模越大, 这一点就越重要.可以看到原型设计模式不仅支持一致性, 还支持灵活的改变.

php世界中的原型

由于php是一个服务器端语言,也是与mysql数据库交互的一个重要工具,所以原型设计模式尤其适用 .并不是为数据库的第一个元素分别创建对象,php可以使用原型模式创建具体类的一个实例,然后利用数据库中的数据克隆其余的实例(记录).

了解克隆过程之后,与直接实例化的过程相比,你可能会问:"这有什么区别?" 换句话说,为什么克隆比直接实例化对象需要的资源少?它们的区别并不能直接看到. 一个对象通过克隆创建实例时, 它不会启动构造函数.克隆能得到原始类的所有属性, 甚至还包含父接口的属性,另外还继承了传递实例化对象的所有值.构造函数生成的所有值以及存储在对象属性中的值都会成为克隆对象的一部分.所以没有返回构造函数.如果发现你的克隆对象确实需要访问构造函数生成的值但又无法访问, 这说明需要对类进行重构,使实例能拥有它们需要的一切信息, 而且可以把这些数据传递给克隆对象.

总的来说, 原型模式在很多不同类型的php项目中都很适用, 如果解决一个问题需要乃至创建型模式, 都可以使用原型模式.

更多关于php相关内容感兴趣的读者可查看本站专题：《php面向对象程序设计入门教程》、《php基本语法入门教程》、《php数组(array)操作技巧大全》、《php字符串(string)用法总结》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家php程序设计有所帮助。