Category Archives: PHP

优化 PHP 建议

src: http://www.phpchina.com/78/viewspace_25713.html

1.如果一个方法可静态化,就对它做静态声明。速率可提升至4倍。

2.echo 比 print 快。

3.使用echo的多重参数(译注:指用逗号而不是句点)代替字符串连接。

4.在执行for循环之前确定最大循环数,不要每循环一次都计算最大值。

5.注销那些不用的变量尤其是大数组,以便释放内存。

6.尽量避免使用__get,__set,__autoload。

7.require_once()代价昂贵。

8.在包含文件时使用完整路径,解析操作系统路径所需的时间会更少。

9.如果你想知道脚本开始执行(译注:即服务器端收到客户端请求)的时刻,使用$_SERVER[‘REQUEST_TIME’]要好于time()。

10.函数代替正则表达式完成相同功能。

11.str_replace函数比preg_replace函数快,但strtr函数的效率是str_replace函数的四倍。

12.如果一个字符串替换函数,可接受数组或字符作为参数,并且参数长度不太长,那么可以考虑额外写一段替换代码,使得每次传递参数是一个字符,而不是只写一行代码接受数组作为查询和替换的参数。

13.使用选择分支语句(译注:即switch case)好于使用多个if,else if语句。

14.用@屏蔽错误消息的做法非常低效。

15.打开apache的mod_deflate模块。

16.数据库连接当使用完毕时应关掉。

17.$row[‘id’]的效率是$row[id]的7倍。

18.错误消息代价昂贵。

19.尽量不要在for循环中使用函数,比如for ($x=0; $x < count($array); $x)每循环一次都会调用count()函数。

20.在方法中递增局部变量,速度是最快的。几乎与在函数中调用局部变量的速度相当。

21.递增一个全局变量要比递增一个局部变量慢2倍。

22.递增一个对象属性(如:$this->prop++)要比递增一个局部变量慢3倍。

23.递增一个未预定义的局部变量要比递增一个预定义的局部变量慢9至10倍。

24.仅定义一个局部变量而没在函数中调用它,同样会减慢速度(其程度相当于递增一个局部变量)。PHP大概会检查看是否存在全局变量。

25.方法调用看来与类中定义的方法的数量无关,因为我(在测试方法之前和之后都)添加了10个方法,但性能上没有变化。

26.派生类中的方法运行起来要快于在基类中定义的同样的方法。

27.调用带有一个参数的空函数,其花费的时间相当于执行7至8次的局部变量递增操作。类似的方法调用所花费的时间接近于15次的局部变量递增操作。

28.用单引号代替双引号来包含字符串,这样做会更快一些。因为PHP会在双引号包围的字符串中搜寻变量,单引号则不会。当然,只有当你不需要在字符串中包含变量时才可以这么做。

29.输出多个字符串时,用逗号代替句点来分隔字符串,速度更快。注意:只有echo能这么做,它是一种可以把多个字符串当作参数的“函数”(译注:PHP手册中说echo是语言结构,不是真正的函数,故把函数加上了双引号)。

30.Apache解析一个PHP脚本的时间要比解析一个静态HTML页面慢2至10倍。尽量多用静态HTML页面,少用脚本。

31.除非脚本可以缓存,否则每次调用时都会重新编译一次。引入一套PHP缓存机制通常可以提升25%至100%的性能,以免除编译开销。

32.尽量做缓存,可使用memcached。memcached是一款高性能的内存对象缓存系统,可用来加速动态Web应用程序,减轻数据库负载。对运算码 (OP code)的缓存很有用,使得脚本不必为每个请求做重新编译。

33. 当操作字符串并需要检验其长度是否满足某种要求时,你想当然地会使用strlen()函数。此函数执行起来相当快,因为它不做任何计算,只返回在zval 结构(C的内置数据结构,用于存储PHP变量)中存储的已知字符串长度。但是,由于strlen()是函数,多多少少会有些慢,因为函数调用会经过诸多步 骤,如字母小写化(译注:指函数名小写化,PHP不区分函数名大小写)、哈希查找,会跟随被调用的函数一起执行。在某些情况下,你可以使用isset() 技巧加速执行你的代码。

(举例如下)
if (strlen($foo) < 5) { echo "Foo is too short"; }
(与下面的技巧做比较)
if (!isset($foo{5})) { echo "Foo is too short"; }

调用isset()恰巧比strlen()快,因为与后者不同的是,isset()作为一种语言结构,意味着它的执行不需要函数查找和字母小写化。也就是说,实际上在检验字符串长度的顶层代码中你没有花太多开销。

34. 当执行变量$i的递增或递减时,$i++会比++$i慢一些。这种差异是PHP特有的,并不适用于其他语言,所以请不要修改你的C或Java代码并指望它 们能立即变快,没用的。++$i更快是因为它只需要3条指令(opcodes),$i++则需要4条指令。后置递增实际上会产生一个临时变量,这个临时变 量随后被递增。而前置递增直接在原值上递增。这是最优化处理的一种,正如Zend的PHP优化器所作的那样。牢记这个优化处理不失为一个好主意,因为并不 是所有的指令优化器都会做同样的优化处理,并且存在大量没有装配指令优化器的互联网服务提供商(ISPs)和服务器。

35.并不是事必面向对象(OOP),面向对象往往开销很大,每个方法和对象调用都会消耗很多内存。

36.并非要用类实现所有的数据结构,数组也很有用。

37.不要把方法细分得过多,仔细想想你真正打算重用的是哪些代码?

38.当你需要时,你总能把代码分解成方法。

39.尽量采用大量的PHP内置函数。

40.如果在代码中存在大量耗时的函数,你可以考虑用C扩展的方式实现它们。

41.评估检验(profile)你的代码。检验器会告诉你,代码的哪些部分消耗了多少时间。Xdebug调试器包含了检验程序,评估检验总体上可以显示出代码的瓶颈。

42.mod_zip可作为Apache模块,用来即时压缩你的数据,并可让数据传输量降低80%。

Read: 821

php中的MVC模式运用

首先我来举个例子:
一个简单的文章显示系统
简单期间,我们假定这个文章系统是只读的,也就是说这个例子将不涉及文章的发布,现在开始了。
由于只涉及数据库的读取,所以我定义了两个interface

Interface DataOperation
{
    public function select($info);
    public function selectNum($info);
}
上面这interface定义了读取数据的接口,select方法将返回所需要的文章。selectNum方法返回文章的总数,这是分页显示时用到的。$info是一个数组,用来存放查询条件
Interface DataSource
{
    public static function getInstance();
}
这里我们假定我们操作的是数据库,DataSource定义一个接口,所有实现该接口的实例类将得到一个静态对象
Interface Controller
{
    public function pop();
    public function push();
    public function execute();
}
Interface View
{
    public function display();
}
好了,我们来实现.
下面定义一个类来实现DataSource接口,这个类运用了单例模式
class DataBaseSource implements DataSource
{
    public static $instance = null;
    public static function getInstance()
    {
        if(self::$instance == null)
        {
            self::$instance == new PDO("mysql:host=localhost;dbname=article","root","123456");
        }
        return self::$instance;
    }
}
定义一个抽象类来实现DataOperation,我们要共享一个数据库连接,所以我在抽象类中将这个数据库对象初始化,这样,所有的子类都能共享这个对象
abstract class DataBaseOperation implements DataOperation
{
    protected $db = null;
    public function __construct()
    {
        $this->db = DataBaseSource::getInstance();
    }
    public function select($info);
    public function select($info);
}
下面我来写一个业务子类来实现抽象类DataBaseOperation
class Tech extends DataBaseOperation
{
    public function select($info)
    {
        //在这里实现你的代码
    }
    public function selectNum($info)
    {
        //在这里实现你的代码
    }
}
业务逻辑层我们实现了,下面是控制层
class ViewController implements Controller
{
    private $mod = array();
    public function push($key,$value);
    {
        //实现你的代码,将类注册进$this->mod;
    }
    public function pop($key)
    {       
        //实现你的代码,将$this->mod[$key]值为null;
    }
    public function execute($key)
    {
        //在这里实现你的代码,生成实例.注意利用php5新的特性,异常的处理
    }
}
好了,下面是表现层,这里将实现Interface View
abstract ArticleView implements View
{
    protected $smarty = null;
    public function __construct()
    {
        $this->smarty = new Smarty();
        ///下面你可以定义smarty的一些属性值
    }
}
具体的页面,例如科技文章的显示页面
class TechArticleView extends ArticleView
{
    public function display()
    {
        //实现你的代码,调用Tech类和更多的DataBaseOperation子类
    }
}
好了,下面是总入口 index.php
try
{
    $viewController = new ViewController();
    $viewController->push("tech",TechArticleView);
//持续的增加
    $mod = $_GET["mod"]:$_GET["mod"]:$_POST["mod"];
    //最后
    $viewController->execute($key);
}
catch(Exception $e)
{
        //如何处理异常就是你的事了
}

Read: 741

[转]PHP 中实现 Factory 模式

转自:http://blog.chinaunix.net/u/10599/showart_329537.html

有这么一种观点:似乎没有 “Factory 模式”一说,GoF 的 23 个模式中与 Factory 相关的有两个:Factory Method 和 Abstract Factory ,《深入浅出设计模式》中则定义了一个 Simple Factory 模式。而本人( Hick ) 翻阅了一下相关资料,Robert C. Martin 的《Agile Software Development: Principles, Patterns, and Pracitces》直接提的是“Factory 模式”。具体情况有兴趣的可以去详细考证。

“Factory 模式允许我们之依赖于抽象接口就能够创建出具体对象的实例”,是 DIP (依赖倒置原则)的体现。我们能够通过给一个工厂(factory)不同的需求来生产不同但是相似的产品(实例化对象)。

嘿嘿,人说,最好的文档就是代码。我不仅仅这样说,我还可以证明给你看(在这里的显示效果不好,建议拷贝到 PHP 编辑器中看),下面分别是《PHP 手册》、《Core PHP Programming》和《PHP 5 Power Programming》中 Factory 模式的实例解析:

<?php
/**
* factory 模式
*
* factory 的概念不像 Singleton 等模式那样, factory 模式比较
* 灵活。通常根据不同的要求能够"生产不同对象"(实例化类)就可以
* 归为 factory 模式或者其变体。
*/

/**
* 先用手册中一个简单的例子说明 factory 模式
*
* 注意下面这段代码并不可执行,因为需要定义相应的数据库[Driver]类。
*/

class DbFactory
{
  
// factory 方法
  
public static function factory($type)
  
{
  
// 注意这里的包含文件应该是相关数据库的[Driver]类
  
if (include_once 'Drivers/' . $type . '.php') {
  
$classname = 'Driver_' . $type;
  
return new $classname;
  
} else {
  
throw new Exception ('Driver not found');
  
}
  
}
}

// 生成数据库(MySQL)连接对象,
$DbCon = DbFactory::factory('MySQL');
// $DbCon = DbFactory::factory('SQLite');

/**
* "Core PHP Programming" 中的例子
*/

class Factory
{
  
private $registeredClasses = array();
  
  
static private $instance = NULL;

   private function __construct() {}

   static function getInstance()
  
{
  
if(self::$instance == NULL)
  
{
  
self::$instance = new Factory();
  
}
  
return self::$instance;
  
}

   function registerClass($id, $creator_func)
  
{
  
$this->registeredClasses[$id] = $creator_func;
  
}

   function createObject($id, $args)
  
{
  
if(!isset($this->registeredClasses[$id]))
  
{
  
return(NULL);
  
}
  
return($this->registeredClasses[$id]($args));
  
}
}

class MyClass
{
  
private $created;
  
public function __construct()
  
{
  
$created = time();
  
}

   public function getCreated()
  
{
  
return($this->created);
  
}
}

function MyClassCreator()
{
  
return(new MyClass());
}

$factory = Factory::getInstance();
$factory->registerClass(1234, "MyClassCreator");
$instance = $factory->createObject(1234, array());

/**
* "PHP 5 Power Programming" 中的对 factory 模式的诠释
*
* 一个 Factory 类通常都有一个方法负责接受参数,根据参数的不同来决定
* "生产"哪个类的实例。下面拿网站的用户作为例子,作为实际运用:把网站
* 用户分成匿名用户,普通(注册)用户,管理员。我们在类中进行用户的权限
* 控制---这样能够更好的展现 factory 类在整个类体系中所扮演的角色。
*/

/**
* 基类 User
*/

abstract class User
{
  
public $name = null;
  
  
public function __construct($name)
  
{
  
$this->name = $name;
  
}
  
  
function getName()
  
{
  
return $this->name;
  
}
  
  
// 权限控制方法
  
function hasReadPermission()
  
{
  
return true;
  
}
  
  
function hasModifyPermission()
  
{
  
return false;
  
}
  
  
function hasDeletePermission()
  
{
  
return false;
  
}
}

// 匿名用户类
class GuestUser extends User
{}

// 注册用户类
class CustomerUser extends User
{
  
function hasModifyPermission()
  
{
  
return true;
  
}
}

// 管理员类
class AdminUser extends User {
  
function hasModifyPermission()
  
{
  
return true;
  
}

   function hasDeletePermission()
  
{
  
return true;
  
}
}

/**
* 用户 factory 类
*/

class UserFactory {
  
private static $users =
  
array("Andi"=>"admin", "Hick"=>"guest",
  
"Derick"=>"customer");

   static function Create($name)
  
{
  
if (!isset(self::$users[$name])) {
  
// 如果不存在对应的用户类,则提示错误
  
}
  
switch (self::$users[$name]) {
  
case "guest": return new GuestUser($name);
  
case "customer": return new CustomerUser($name);
  
case "admin": return new AdminUser($name);
  
default: // 默认应该报错
  
}
  
}
}

// 使用 factory 类实例化用户
$HickUser = UserFactory::Create('Hick');
echo $HickUser->name;
?>

Read: 732

[转]PHP 中实现 Singleton 模式和 Monostate 模式

转自:http://blog.chinaunix.net/u/10599/showart_329555.html

通常来说,类和对象(类的实例)之间是一对多的关系。但是某些情况下,我们只
需要一个类的一个实例。比如多个实例的多样性反倒会带来一些不可控因素,多
次的实例化,是一种资源的浪费,降低了效率;又如他们是工厂对象(factory
object),用来创建系统中的其他对象,等等。这时候,较好的处理方式就是让类
的实例具有单一性:保障这个类在运行过程中最多生成一个实例( Singleton 模
式),或者让所有的实例保持一致( Monostate 模式)。

PHP 下实现 Singleton 模式示例:

<?php
class Singleton
{
  
private static $instance;

   private function __construct()
  
{
  
}

   public static function instance()
  
{
  
if(self::$instance == null)
  
{
  
self::$instance = new Singleton();
  
}

   return self::$instance;
  
}
}
?>

创建 singleton 类实例就只能够是这样了:

$instance = Singleton::instance();
// 这样是错误的: $instance = new Singleton();

详细分析一下 PHP 下实现的 singleton 模式的特征:

1. 一个 static, private 属性:用来保存一个实例,static 保证类不被实例化
也能够被类方法调用, private 保证它不被类的实例等改变。

2. 一个 private 的构造方法:不允许该类在本类之外的地方实例化。

3. 一个 static, public 方法:负责创建实例并保证其唯一性。static 使该方
法可以不被实例化即可被调用。

跟下面的 monostate 比,它的优点在于:

1. 适应任何类,满足上面的三个特征即可。
2. 可以统购派生创建,给定一个类,可以创建它的一个 singleton 子类。

缺点:

1. singleton 特性不能够被继承,其子类就不是 singleton 类了。
2. 使用不通明,使用者必须知道它使用的是一个 singleton 类,而不能够通过
new 来实例化。

monostate 模式的基本原理就是让 monostate 类的所有实例使用起来是同一个实
例一样。实际上把类的所有属性都使用 static 声明即可:

<?php
class monostate
{
  
private static $itsX = 0;
  
  
public function __construct()
  
{
  
  
}
  
  
public function setX($x)
  
{
  
self::$itsX = $x;
  
}
  
  
public function getX()
  
{
  
return self::$itsX;
  
}
}
?>

具体就不再详细介绍,其优缺点基本上刚好跟 singleton 模式相反。

参考资料:《敏捷软件开发:原则、模式与实践》

Read: 660

[转]五种常见的PHP设计模式

转自:http://blog.csdn.net/kenwyn/archive/2007/03/26/1541443.aspx

设计模式只是为 Java 架构师准备的 —— 至少您可能一直这样认为。实际上,设计模式对于每个人都非常有用。如果这些工具不是 “架构太空人” 的专利,那么它们又是什么?为什么说它们在 应用程序中非常有用?本文解释了这些问题。PHP

设计模式 一书将设计模式引入软件社 区,该书的作者是 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides Design(俗称 “四人帮”)。所介绍的设计模式背后的核心概念非常简单。经过多年的软件开发实践,Gamma 等人发现了某些具有固定设计的模式,就像建筑师设计房子和建筑物一样,可以为浴室的位置或厨房的构造方式开发模板。使用这些模板或者说设计模式 意味着可以更快地设计更好的建筑物。同样的概念也适用于软件。

设计模式不仅代表着更快开发健壮软件的有用方法,而且还提供了以友好的术语封装大型理念的方法。例如,您可以说您正在编写一个提供松散耦合的消息传递系统,也可以说你正在编写名称为观察者 的模式。

用 较小的示例展示模式的价值是非常困难的。这往往有些大材小用的意味,因为模式实际上是在大型代码库中发挥作用的。本文不展示大型应用程序,所以您需要思索 的是在您自己的大型应用程序中应用示例原理的方法 —— 而不是本文演示的代码本身。这不是说您不应该在小应用程序中使用模式。很多良好的应用程序都以小应用程序为起点,逐渐发展到大型应用程序,所以没有理由不 以此类扎实的编码实践为基础。

既然您已经了解了设计模式以及它们的有用之处,现在我们来看看 PHP V5 的五种常用模式。

工厂模式

最初在设计模式 一书中,许多设计模式都鼓励使用松散耦合。要理解这个概念,让我们最好谈一下许多开发人员从事大型系统的艰苦历程。在更改一个代码片段时,就会发生问题,系统其他部分 —— 您曾认为完全不相关的部分中也有可能出现级联破坏。

该问题在于紧密耦合 。系统某个部分中的函数和类严重依赖于系统的其他部分中函数和类的行为和结构。您需要一组模式,使这些类能够相互通信,但不希望将它们紧密绑定在一起,以避免出现联锁。

在大型系统中,许多代码依赖于少数几个关键类。需要更改这些类时,可能会出现困难。例如,假设您有一个从文件读取的 User 类。您希望将其更改为从数据库读取的其他类,但是,所有的代码都引用从文件读取的原始类。这时候,使用工厂模式会很方便。

工厂模式 是一种类,它具有为您创建对象的某些方法。您可以使用工厂类创建对象,而不直接使用 new。这样,如果您想要更改所创建的对象类型,只需更改该工厂即可。使用该工厂的所有代码会自动更改。

清单 1 显示工厂类的一个示列。等式的服务器端包括两个部分:数据库和一组 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:password@localhost/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 listn" );
}
}

$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 应用程序中使用的几种最常见的设计模式。在设计模式 一书中演示了更多的设计模式。不要因架构的神秘性而放弃。模式是一种绝妙的理念,适用于任何编程语言、任何技能水平。

Read: 661