五种常见的PHP设计模式

清单 1. factory1.php

<?php
interface iuser
{
  function getname();
}

class user implements iuser
{
  public function __construct( $id ) { }

  public function getname()
  {
    return "jack";
  }
}

class userfactory
{
  public static function create( $id )
  {
    return new user( $id );
  }
}

$uo = userfactory::create( 1 );
echo( $uo->getname()."/n" );
?>
 

iuser 接口定义用户对象应执行什么操作。iuser 的实现称为 user，userfactory 工厂类则创建 iuser 对象。此关系可以用图 1 中的 uml 表示。

图 1. 工厂类及其相关 iuser 接口和用户类

如果您使用 php 解释器在命令行上运行此代码，将得到如下结果：

% php factory1.php
jack
%
 

测试代码会向工厂请求 user 对象，并输出 getname 方法的结果。

有一种工厂模式的变体使用工厂方法。类中的这些公共静态方法构造该类型的对象。如果创建此类型的对象非常重要，此方法非常有用。例如，假设您需要先创建对象，然后设置许多属性。此版本的工厂模式会将该进程封装在单个位置中，这样，不用复制复杂的初始化代码，也不必将复制好的代码在在代码库中到处粘贴。

清单 2 显示使用工厂方法的一个示例。

清单 2. factory2.php

<?php
interface iuser
{
  function getname();
}

class user implements iuser
{
  public static function load( $id )
  {
        return new user( $id );
  }

  public static function create( )
  {
        return new user( null );
  }

  public function __construct( $id ) { }

  public function getname()
  {
    return "jack";
  }
}

$uo = user::load( 1 );
echo( $uo->getname()."/n" );
?>
 

这段代码要简单得多。它仅有一个接口 iuser 和一个实现此接口的 user 类。user 类有两个创建对象的静态方法。此关系可用图 2 中的 uml 表示。

图 2. iuser 接口和带有工厂方法的 user 类
 
在命令行中运行脚本产生的结果与清单 1 的结果相同，如下所示：

% php factory2.php
jack
%
 
如上所述，有时此类模式在规模较小的环境中似乎有些大材小用。不过，最好还是学习这种扎实的编码形式，以便应用于任意规模的项目中。

单元素模式

某些应用程序资源是独占的，因为有且只有一个此类型的资源。例如，通过数据库句柄到数据库的连接是独占的。您希望在应用程序中共享数据库句柄，因为在保持连接打开或关闭时，它是一种开销，在获取单个页面的过程中更是如此。

单元素模式可以满足此要求。如果应用程序每次包含且仅包含一个对象，那么这个对象就是一个单元素（singleton）。清单 3 中的代码显示了 php v5 中的一个数据库连接单元素。

清单 3. singleton.php

<?php
require_once("db.php");

class databaseconnection
{
  public static function get()
  {
    static $db = null;
    if ( $db == null )
      $db = new databaseconnection();
    return $db;
  }

  private $_handle = null;

  private function __construct()
  {
    $dsn = 'mysql://root:[email protected]/photos';
    $this->_handle =& db::connect( $dsn, array() );
  }
 
  public function handle()
  {
    return $this->_handle;
  }
}

print( "handle = ".databaseconnection::get()->handle()."/n" );
print( "handle = ".databaseconnection::get()->handle()."/n" );
?>
 

此代码显示名为 databaseconnection 的单个类。您不能创建自已的 databaseconnection，因为构造函数是专用的。但使用静态 get 方法，您可以获得且仅获得一个 databaseconnection 对象。此代码的 uml 如图 3 所示。

图 3. 数据库连接单元素
 
在两次调用间，handle 方法返回的数据库句柄是相同的，这就是最好的证明。您可以在命令行中运行代码来观察这一点。

% php singleton.php
handle = object id #3
handle = object id #3
%

返回的两个句柄是同一对象。如果您在整个应用程序中使用数据库连接单元素，那么就可以在任何地方重用同一句柄。

您可以使用全局变量存储数据库句柄，但是，该方法仅适用于较小的应用程序。在较大的应用程序中，应避免使用全局变量，并使用对象和方法访问资源。

观察者模式

观察者模式为您提供了避免组件之间紧密耦合的另一种方法。该模式非常简单：一个对象通过添加一个方法（该方法允许另一个对象，即观察者 注册自己）使本身变得可观察。当可观察的对象更改时，它会将消息发送到已注册的观察者。这些观察者使用该信息执行的操作与可观察的对象无关。结果是对象可以相互对话，而不必了解原因。

一个简单示例是系统中的用户列表。清单 4 中的代码显示一个用户列表，添加用户时，它将发送出一条消息。添加用户时，通过发送消息的日志观察者可以观察此列表。

清单 4. observer.php

<?php
interface iobserver
{
  function onchanged( $sender, $args );
}

interface iobservable
{
  function addobserver( $observer );
}

class userlist implements iobservable
{
  private $_observers = array();

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

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

class userlistlogger implements iobserver
{
  public function onchanged( $sender, $args )
  {
    echo( "'$args' added to user list/n" );
  }
}

$ul = new userlist();
$ul->addobserver( new userlistlogger() );
$ul->addcustomer( "jack" );
?>
 

此代码定义四个元素：两个接口和两个类。iobservable 接口定义可以被观察的对象，userlist 实现该接口，以便将本身注册为可观察。iobserver 列表定义要通过怎样的方法才能成为观察者，userlistlogger 实现 iobserver 接口。图 4 的 uml 中展示了这些元素。

图 4. 可观察的用户列表和用户列表事件日志程序
 

如果在命令行中运行它，您将看到以下输出：

% php observer.php
'jack' added to user list
%
 

测试代码创建 userlist，并将 userlistlogger 观察者添加到其中。然后添加一个消费者，并将这一更改通知 userlistlogger。

认识到 userlist 不知道日志程序将执行什么操作很关键。可能存在一个或多个执行其他操作的侦听程序。例如，您可能有一个向新用户发送消息的观察者，欢迎新用户使用该系统。这种方法的价值在于 userlist 忽略所有依赖它的对象，它主要关注在列表更改时维护用户列表并发送消息这一工作。

此模式不限于内存中的对象。它是在较大的应用程序中使用的数据库驱动的消息查询系统的基础。

命令链模式

命令链 模式以松散耦合主题为基础，发送消息、命令和请求，或通过一组处理程序发送任意内容。每个处理程序都会自行判断自己能否处理请求。如果可以，该请求被处理，进程停止。您可以为系统添加或移除处理程序，而不影响其他处理程序。清单 5 显示了此模式的一个示例。

清单 5. chain.php

<?php
interface icommand
{
  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 usercommand implements icommand
{
  public function oncommand( $name, $args )
  {
    if ( $name != 'adduser' ) return false;
    echo( "usercommand handling 'adduser'/n" );
    return true;
  }
}

class mailcommand implements icommand
{
  public function oncommand( $name, $args )
  {
    if ( $name != 'mail' ) return false;
    echo( "mailcommand handling 'mail'/n" );
    return true;
  }
}

$cc = new commandchain();
$cc->addcommand( new usercommand() );
$cc->addcommand( new mailcommand() );
$cc->runcommand( 'adduser', null );
$cc->runcommand( 'mail', null );
?>
 

此代码定义维护 icommand 对象列表的 commandchain 类。两个类都可以实现 icommand 接口 —— 一个对邮件的请求作出响应，另一个对添加用户作出响应。 图 5 给出了 uml。

图 5. 命令链及其相关命令

如果您运行包含某些测试代码的脚本，则会得到以下输出：

% php chain.php
usercommand handling 'adduser'
mailcommand handling 'mail'
%
 
代码首先创建 commandchain 对象，并为它添加两个命令对象的实例。然后运行两个命令以查看谁对这些命令作出了响应。如果命令的名称匹配 usercommand 或 mailcommand，则代码失败，不发生任何操作。

为处理请求而创建可扩展的架构时，命令链模式很有价值，使用它可以解决许多问题。

策略模式

我们讲述的最后一个设计模式是策略 模式。在此模式中，算法是从复杂类提取的，因而可以方便地替换。例如，如果要更改搜索引擎中排列页的方法，则策略模式是一个不错的选择。思考一下搜索引擎的几个部分 —— 一部分遍历页面，一部分对每页排列，另一部分基于排列的结果排序。在复杂的示例中，这些部分都在同一个类中。通过使用策略模式，您可将排列部分放入另一个类中，以便更改页排列的方式，而不影响搜索引擎的其余代码。

作为一个较简单的示例，清单 6 显示了一个用户列表类，它提供了一个根据一组即插即用的策略查找一组用户的方法。

清单 6. strategy.php

<?php
interface istrategy
{
  function filter( $record );
}

class findafterstrategy implements istrategy
{
  private $_name;

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

  public function filter( $record )
  {
    return strcmp( $this->_name, $record ) <= 0;
  }
}

class randomstrategy implements istrategy
{
  public function filter( $record )
  {
    return rand( 0, 1 ) >= 0.5;
  }
}

class userlist
{
  private $_list = array();

  public function __construct( $names )
  {
    if ( $names != null )
    {
      foreach( $names as $name )
      {
        $this->_list []= $name;
      }
    }
  }

  public function add( $name )
  {
    $this->_list []= $name;
  }

  public function find( $filter )
  {
    $recs = array();
    foreach( $this->_list as $user )
    {
      if ( $filter->filter( $user ) )
        $recs []= $user;
    }
    return $recs;
  }
}

$ul = new userlist( array( "andy", "jack", "lori", "megan" ) );
$f1 = $ul->find( new findafterstrategy( "j" ) );
print_r( $f1 );

$f2 = $ul->find( new randomstrategy() );
print_r( $f2 );
?>
 

图 6. 用户列表和用于选择用户的策略

userlist 类是打包名称数组的一个包装器。它实现 find 方法，该方法利用几个策略之一来选择这些名称的子集。这些策略由 istrategy 接口定义，该接口有两个实现：一个随机选择用户，另一个根据指定名称选择其后的所有名称。运行测试代码时，将得到以下输出：

% php strategy.php
array
(
    [0] => jack
    [1] => lori
    [2] => megan
)
array
(
    [0] => andy
    [1] => megan
)
%
 

测试代码为两个策略运行同一用户列表，并显示结果。在第一种情况中，策略查找排列在 j 后的任何名称，所以您将得到 jack、lori 和 megan。第二个策略随机选取名称，每次会产生不同的结果。在这种情况下，结果为 andy 和 megan。

策略模式非常适合复杂数据管理系统或数据处理系统，二者在数据筛选、搜索或处理的方式方面需要较高的灵活性。

结束语

本文介绍的仅仅是 php 应用程序中使用的几种最常见的设计模式。在设计模式 一书中演示了更多的设计模式。不要因架构的神秘性而放弃。模式是一种绝妙的理念，适用于任何编程语言、任何技能水平。