【图】PHP系列教程：设计模式介绍Ⅵ伪对象模式

上一节：《PHP设计模式介绍》第五章注册模式

《PHP设计模式介绍》第六章伪对象模式

面向对象的编程之所以丰富多彩，部分是由于对象间的相互联系与作用。一个单一的对象就能封装一个复杂的子系统，使那些很复杂的操作能够通过一些方法的调用而简化。（无所不在的数据库连接就是这样的一个对象实例。）

然而经常有这样的情况，对象间的交互性是如此复杂以至于我们不得不面对类似先有鸡还是先有蛋这样伤脑筋的问题：如何创建并测试这样一个对象，他要么依赖于很多已创建的对象，要么依赖于其他一些难以意识到的情况，如整个数据库的创建和测试。

问题

如何分隔并测试一个与其他对象和资源有关的代码段？又如何再创建一个或多个对象、程序来验证你的代码能正常运行？

解决方案

当用situ（或在一个仿真的程序环境中）测试一个对象代价不菲或困难重重时，就可用伪对象来模拟这个行为。伪对象有同真实对象一样的接口，但却能提供预编译响应，能跟踪方法调用，并验证调用次序。

伪对象是测试的特别力量。他们被秘密训练，渗透进目标代码，模拟并监视通信方式，回报结果。伪对象有助于查找和消除程序漏洞并能支持更多正常调试环境下的防危险操作。

注：The ServerStub
伪对象模式是另一种测试模式ServerStub的扩展。ServerStub模式替代一个资源并返回其方法所调用的相应值。当其参与指定次序的方法的调用时ServerStub就成了伪对象。

其并非是一个设计模式

本章与其他章不同，因为伪对象是一个测试模式而不是设计模式。这类似于一个附加的章节，但对它的使用确实很值得你纳入到编码进程中。另一个不同是我们不再关注这个模式如何编码之类的基础问题，而是强调如何在SimpleTest中使用伪对象。

本章先举一个非常简单的例子来示范SimpleTest下伪对象的基本机制。然后向你演示如何使用伪对象帮助重构已有代码与如何测试新的解决方案。

样本代码

伪对象是对象在测试中的一个替代品，用它测试代码更加简便。例如，替代一个真实的数据连接这个真实的数据连接由于一些原因而不能实际连接你就可以创建一个伪对象来模拟。这意味着伪对象需要准确地回应代码中所调用的相同的应用程序接口。

让我们创建一个伪对象来替代一个简单的名为Accumulator的类，这是一个求和的类。如下是最初的Accumulator类：

// PHP4
class Accumulator {
var $total=0;
function add($item) {
$this-total += $item;
}
function total() {
return $this-total;
}
}

这个类中add()函数先累加值到$total变量中，再交由total()函数返回。一个简单的累加也可以如下面这样（下面的代码被编写为一个函数，但它也可以写成一个类）。

function calc_total($items, &$sum) {
foreach($items as $item) {
$sum-add($item);
}
}
function calc_tax(&$amount, $rate=0.07) {
return round($amount-total() * $rate,2);
}

第一个函数calc_total()用一个累加的动作求一系列值的和。下面是简单的测试：

class MockObjectTestCase extends UnitTestCase {
function testCalcTotal() {
$sum =& new Accumulator;
calc_total(array(1,2,3), $sum);
$this-assertEqual(6, $sum-total());
}
}

让我们关注第二个例子。假设实现一个真实的累加动作的代价很大。那么用一个简单的对象来替代它并回应相关代码就是很好的做法了。使用SimpleTest，你可以用如下代码创建一个伪累加动作：

Mock::generate(‘Accumulator’);
class MockObjectTestCase extends UnitTestCase {

// ...
function testCalcTax() {
$amount =& new MockAccumulator($this);
$amount-setReturnValue(‘total’,200);
$this-assertEqual(
14, calc_tax($amount));
}
}

为了使用伪对象，具有代表性的做法是你亲自写一个新类（并不要求马上做）。幸运的是，SimpleTest有一种容易的手段来实现 Mock::generate() 方法。

[next]

在上面的例子中，这种手段创建了一个名为MockAccumulator的类来响应所有Accumulator类的方法。另外，伪累加的动作还有其他手段来操作伪对象自身的实例。例如 setReturnValue()。给出一个方法名和一个值，

setReturnValue()就可以改变伪对象而给出对应方法所调用的值。因此，这条语句$amount-setReturnValue(‘total’, 200)返回200而不论何时调用了total()方法。

一旦进行完初始化工作后，你可以传递MockAccumulator类到calc_tax()函数来演示一个在真实的Accumulator对象空间中的动作。

如果你止步于此即用一个对象来返回所调用函数的封装响应你只是使用了ServerStub模式。用伪对象来验证方法的调用不限于此，因为它可以不限次序与次数。

下面是一个通过对象来验证数据流的例子：

class MockObjectTestCase extends UnitTestCase {
// ...
function testCalcTax() {
$amount =& new MockAccumulator($this);
$amount-setReturnValue(‘total’,200);
$amount-expectOnce(‘total’);
$this-assertEqual(
14, calc_tax($amount));
$amount-tally();
}
}

这里expectOnce()方法使用了一个字符串，它包含你想调用的方法名。而tally()实际上用来检查你的想法是否实现。这里，如果MockAccumulator::total()只调用一次或不调用，测试将失败。

在很多情况下你可以使用伪对象的跟踪特性。例如，如果你传递一个具有三个值的数组到calc_total()，Accumulator::add()是否也如你所想的调用了三次呢？

class MockObjectTestCase extends UnitTestCase {
// ...
function testCalcTotalAgain() {
$sum =& new MockAccumulator($this);
$sum-expectOnce(‘add’);
calc_total(array(1,2,3), $sum);
$sum-tally();
}
}

那，这里发生了什么？传递调用的测试失败。SimpleTest的错误消息如下所示：

MockObject PHP4 Unit Test
1) Expected call count for [add] was [1] got [3] at line [51]
in testcalctotalagain in mockobjecttestcase
FAILURES!!!
Test cases run: 1/1, Passes: 2, Failures: 1, Exceptions: 0

错误消息指出了尽管add() 方法被调用三次，但expectOnce()却一次也没用到。取代expectOnce()的可行方法是使用expectCallCount()。

class MockObjectTestCase extends UnitTestCase {
// ...
function testCalcTotalAgain() {
$sum =& new MockAccumulator($this);
$sum-expectCallCount(‘add’, 3);
calc_total(array(1,2,3), $sum);
$sum-tally();
}
}

伪对象扮演了一个演员的角色这个角色由SeverStub提供合理的测试数据来响应方法的调用并且作为一个评判的角色，验证所调用的方法是否符合预想。

[next]

重构已有程序

下面让我们用伪对象来帮助重构一个已有程序。考虑一个简单的脚本，它可以模拟你在无数的 PHP程序中所期望的行为：例如一个当检查到你未登录时要求登录的页面；与此类似的还有表单处理页面；它能在成功登录后显示不同内容并提供登出的功能。让我们写一个这样的页面。首先，对还未登录的用户显示一个登录表单。

<html
<body
<form method=post
Name:<input type=text name=name Password:<input type=password name=passwd
<input type=submit value=Login
</form
</body
</html

接着，显示登录成功后的内容：

<html
<bodyWelcome <?php echo $_SESSION[‘name’]; ?
<brSuper secret member only content here.
<a href=<?php echo SELF; ??clearLogout</a
</body
</html

加入表单处理的功能，session（会话）开始，还有登出的功能，整体看起来应该类似这样：

session_start();
define(‘SELF’,
‘http://’.$_SERVER[‘SERVER_NAME’].$_SERVER[‘PHP_SELF’]);
if (array_key_exists(‘name’, $_REQUEST)
&& array_key_exists(‘passwd’, $_REQUEST)
&& ‘admin’ == $_REQUEST[‘name’]
&& ‘secret’ == $_REQUEST[‘passwd’]) {
$_SESSION[‘name’] = ‘admin’;
header(‘Location: ‘.SELF);
}
if (array_key_exists(‘clear’, $_REQUEST)) {
unset($_SESSION[‘name’]);
}
if (array_key_exists(‘name’, $_SESSION)
&& $_SESSION[‘name’]) { ?
<html
<bodyWelcome <?=$_SESSION[‘name’]?
<brSuper secret member only content here.
<a href=<?php echo SELF; ??clearLogout</a
</body
</html <?php
} else { ?
<html
<body
<form method=post
Name:<input type=text name=name Password:<input type=password name=passwd
<input type=submit value=Login
</form
</body
</html <?php
}

重构这个程序的一个目的应该是使其成为一个易于测试的程序。基于这个目的，如果你还选择一些PHP中的方便特性如超级全局变量你将失去测试上的简洁性。

例如，如果你直接就用了$_SESSION，即意味着只有一种途径可以测试这个代码，就是改变$_SESSION。如果你忘了将$_SESSION改回先前已知的状态，各种测试间就会互相干扰。

[next]

一个好的解决方法是封装$_SESSION到另一个类中，传递所封装类的实例到任何想要访问 $_SESSION的对象。如果你创建了一个已封装对象的伪对象用于测试，你能够完全控制对象对所调用方法的响应（就像ServerStub那样）并且你能核实它是如何调用的（那正是创建伪对象的目的）。

具备了这个思想，让我们看看如何封装$_SESSION之类的全局变量。

class Session {
function Session() {
$this-init();
}
function init() {
if (!isset($_SESSION)) {
if (headers_sent()) {
trigger_error(
‘Session not started before creating session object’);
} else {
session_start();
}
}
}
function isValid($key) {
return array_key_exists($key, $_SESSION);
}
function get($key) {
return (array_key_exists($key, $_SESSION))
? $_SESSION[$key]
: null;
}
function set($key, $value) {
$_SESSION[$key] = $value;
}
function clear($key) {
unset($_SESSION[$key]);
}
}

类Session封装了全局变量$_SESSION。对类SESSION的测试非常类似于对前期的已注册的类的改良测试（参见第5章），但是却无任何通过参数获得或设置相应值的意图。

你也许注意到了构造函数调用了Session::init()方法。为什么这个方法不是构造函数的一部分呢？这样分开的好处是你能静态调用它并确保session已经开始。下面是一个如何使用该类的例子。

Session::init();
$page =& new PageDirector(new Session);

大部分测试方面的文献很推崇伪对象并建议你亲自写一个。如果你打算那样做，开始测试时你就只需要充实那些你需要的方法就可以了。譬如，一个用于处理代码的ServerStub的Session类很可能是这样的：

class MyMockSessionUser1 {
function isValid($key) {
return (‘user_id’ == $key) ? true : false;
}
function get($key) {
if (‘user_id’ == $key) {
return 1;
}
}
}

幸运的是，你可以用SimpleTest来避免那些易范的错误。Mock::generate()方法允许你创建一个类来实例化或动态地配置你想要的结果。

注：伪对象技术
SimpleTest所使用的方法仅是伪对象的多种用法之一。伪对象的代码传递是另一种。随着PHP5的到来，你也许能看到伪对象以对象中的__call()方法来执行。

以下是如何用SimpleTest生成的伪对象来测试并重构MyMockSessionUser1类（如上例中）。

Mock::Generate(‘Session’);
class PageDirectorTestCase extends UnitTestCase {
function testSomethingWhichUsesSession() {
$session =& new MockSession($this);
$session-setReturnValue(‘isValid’, true);
$session-setReturnValue(‘get’, 1);
// ...
}
}

[next]

更进一步说，你能随心所欲的设置何种方法被调用以及调用多少次。你甚至可以验证那些根本不该被调用的方法。

下面是一个扩展型的测试，它用来建立和验证那些复杂的设计。

class PageDirectorTestCase extends UnitTestCase {
function testSomethingWhichUsesSession() {
$session =& new MockSession($this);
$session-setReturnValue(‘isValid’, true);
$session-setReturnValue(‘get’, 1);
$session-expectOnce(‘isValid’, array(‘user_id’));
$session-expectOnce(‘get’, array(‘user_id’));
$session-expectNever(‘set’);
// the actual code which uses $session
$session-tally();
}
}

使用伪对象的原因很多，方法也多样化。但在我们继续前，让我们把另外的一些类加入进来，使其来龙去脉更加清楚。

接下来的一部分是重构已有脚本，创建一个用于检查用户是否有相应权限的名为UserLogin的类。

class UserLogin {
var $_valid=true;
var $_id;
var $_name;
function UserLogin($name) { switch (strtolower($name)) { case ‘admin’:
$this-_id = 1;
$this-_name = ‘admin’;
break;
default:
trigger_error(Bad user name ‘$name’);
$this-_valid=false;
}
}
function name() {
if ($this-_valid) return $this-_name;
}
function Validate($user_name, $password) {
if (‘admin’ == strtolower($user_name)
&& ‘secret’ == $password) {
return true;
}
return false;
}
}

(在一个实际的程序中，你应当按照如上所示的逻辑来查询相应的数据表，这种小而且编写起来费神的类体现了你将如何运用ServerStub来组织代码ServerStub是一个小型的表达你想法的类，但它只是在一些限制环境下可用。)

最后一部分是创建响应。为了最终在浏览器中显示，我们必须处理那不断增长的HTML内容，如果必要的话我们也会讨论HTTP重定向。（你也可以执行其他的http头的操作这样说是为了能构隐藏它在一个成熟的做法中，但这里使用的是一段更简单的代码，是为了使例子容易理解与关注。）

class Response {
var $_head=’’;
var $_body=’’;
function addHead($content) {
$this-_head .= $content;
}
function addBody($content) {
$this-_body .= $content;
}
function display() {
echo $this-fetch();
}
function fetch() {
return ‘<html’
.’<head’.$this-_head.’</head’
.’<body’.$this-_body.’</body’
.’</html’;
}
function redirect($url, $exit=true) {
header(‘Location: ‘.$url);
if ($exit) exit;
}
}

给出了这些模块后，也是时候将这些新开发的、已测试的组件聚合到一个页面中了。让我们写一个最终的类来协调这个页面的所以行为，取个合适的名字PageDirector。类PageDirector具有一个很简单的运用程序接口：你在实例化后可以用调用它的run()方法。

这个bootstrap文件运行新程序时应如下所示：

<?php
require_once ‘classes.inc.php’;
define(‘SELF’, ‘http://www.example.com/path/to/page.php’);
$page =& new PageDirector(new Session, new Response);
$page-run();
?

该文件包含了所需的已定义类，并为自己定义了一个常量，给PageDirector类（其用于传递类Session 和类Response所依赖的实例来组成构造函数）创建了一个实例来执行PageDirector::run()方法。

[next]

现在让我们来创建一些测试的实例来详细说明重构后的运用程序应该有的功能。

require_once ‘simpletest/unit_tester.php’;
require_once ‘simpletest/reporter.php’; require_once ‘simpletest/mock_objects.php’; require_once ‘simpletest/web_tester.php’;
require_once ‘classes.inc.php’; Session::init();
class PageWebTestCase extends WebTestCase { /*...*/ } class ResponseTestCase extends UnitTestCase { /*...*/ } class UserLoginTestCase extends UnitTestCase { /*...*/ } class SessionTestCase extends UnitTestCase { /*...*/ }
class PageDirectorTestCase extends UnitTestCase { /*...*/ }
$test = new GroupTest(‘Application PHP4 Unit Test’);
$test-addTestCase(new PageWebTestCase);
$test-addTestCase(new ResponseTestCase);
$test-addTestCase(new UserLoginTestCase);
$test-addTestCase(new SessionTestCase);
$test-addTestCase(new PageDirectorTestCase);

这段代码或多或少的展示了一个典型的运用程序的测试文件该是何种模样。它一开始就包含了一些 SimpleTest文件，也包括了用伪对象来测试的mock_object.php文件。接着，那些辅助类被包含进来，方法Session::init ()被调用，seesion开始。

紧接着的全是以安全无害为目标而开始的测试实例，类WebTestCase确保所有程序按要求执行，然后是单独的用于新设计的类的测试（尽管这种类本章不会详述）。最后是我们接下去会讨论的PageDirectorTestCase类。

类PageDirector的核心任务是协调类Session和类Response的对象，产生最终的网页输出结果。

Mock::Generate(‘Session’);
Mock::Generate(‘Response’);
define(‘SELF’, ‘testvalue’);
class PageDirectorTestCase extends UnitTestCase {
// ...
}

在这段代码的一开始，Mock::generate()创建了伪对象类的定义并定义了一个后面将要用到的常量。

假设对类Session 和类 Response的测试已经存在，下一步就是创建伪Session来模拟类 Session的状态。这个伪对象的设置和我们一开始所演示的例子极其类似。

因为PageDirector::run()方法正回显内容，你可以用输出缓存内容的办法来捕获它，看看是否正确。

这段代码证明了在SimpleTest中使用伪对象的必要性。我们来看看其中创建伪对象的一行代码$session =&new MockSession($this)。你可以使用继承自SimpleStub类（参见http://simpletest.sf.net/SimpleTest/MockObjects/SimpleStub.html#sec-methodsummary)的方法来创建你所希望的从对象(如同你在测试代码时所做的那样)返回的结果.下一步，实例化PageDirector类并用MockSession代替正式使用时的类来实例化相关代码。

注：setReturnValue()方法
setReturnValue()方法通过指定当伪对象的特定方法被调用时返回何值来让伪对象以一个替身的身份融入代码。已经有了一些这种方法的变体：比如指定以一定次序返回一系列值的做法，还有以参数代替值来返回结果的做法。
expectOnce()方法
expectOnce()方法通过建立一些假想，这些假想是关于什么时候方法被调用以及多久调用一次，来允许你的伪对象以批评者的角色来测试代码。这些假想当你在测试中调用伪对象的tally()方法时会被报告。

class PageDirector {
var $session;
var $response;
function PageDirector(&$session, &$response) {
$this-session =& $session;
$this-response =& $response;
}
}

因为PageDirector类认为自己不是处于一个测试环境而是处于一个真实正常的运用程序环境中，它回显结果到浏览器。既然你实际上在测试时并不希望这个动作，你就可以通过PHP输出缓存的特性（参见http://php.net/outcontrol）来捕获执行时它往浏览器发送了什么。

class PageDirector {
// ...
function run() {
if (!$this-isLoggedIn()) {
$this-showLogin();
}
$this-response-display();
}
function isLoggedIn() {
return ($this-session-get(‘user_name’)) ? true : false;
}
function showLogin() {
$this-response-addBody(‘<form method=post’);
$this-response-addBody(‘Name:<input type=text name=name’);
$this-response-addBody(n);
$this-response-addBody(
‘Password:<input type=password name=passwd’);
$this-response-addBody(n);
$this-response-addBody(‘<input type=submit value=Login’);
$this-response-addBody(‘</form’);
}
}

如同这段程序代码一样，测试代码本身也可以进行重构。在本例中，你可以看到缓存输出的诀窍是其将被多次复用，因此使用析构法重构可以使测试本身简化。（重新调用的那些以test为开头的方法是随整个测试一起自动运行的；你也可以自己创建一些使测试更简洁的方法。）

[next]

下面的代码段演示了缓存输出被重构为runPage方法的结果，它给人的感觉就像是当用户登录时另一个对输出的测试。

class PageDirectorTestCase extends UnitTestCase {
// ...
function TestLoggedOutContent() {
$session =& new MockSession($this);
$session-setReturnValue(‘get’, null, array(‘user_name’));
$session-expectOnce(‘get’, array(‘user_name’));
$page =& new PageDirector($session, new Response);
$result = $this-runPage($page);
$this-assertNoUnwantedPattern(‘/secret.*content/i’, $result);
$this-assertWantedPattern(‘/<form.*<input[^]*text[^]*’
.’name.*<input[^]*password[^]*passwd/ims’
,$result);
$session-tally();
}
function TestLoggedInContent() {
$session =& new MockSession($this);
$session-setReturnValue(‘get’, ‘admin’, array(‘user_name’));
$session-expectAtLeastOnce(‘get’);
$page =& new PageDirector($session, new Response);
$result = $this-runPage($page);
$this-assertWantedPattern(‘/secret.*content/i’, $result);
$this-assertNoUnwantedPattern(‘/<form.*<input[^]*text[^]*’
.’name.*<input[^]*password[^]*passwd/ims’
,$result);
$session-tally();
}
function runPage(&$page) {
ob_start();
$page-run();
return ob_get_clean();
}
}

接下来，将加入一个检查条件到PageDirector::run()方法来看看用户是否已经登录并决定显示什么模板：

class PageDirector {
// ...
function run() {
if ($this-isLoggedIn()) {
$this-showPage(
new UserLogin($this-session-get(‘user_name’)));
} else {
$this-showLogin();
}
$this-response-display();
}
function showPage(&$user) {
$vars = array(
‘name’ = $user-name()
,’self’ = SELF
);
$this-response-addBodyTemplate(‘page.tpl’, $vars);
}
}

page.tpl看上去可能像这样：

Welcome <?php echo $name; ?
<brSuper secret member only content here.
<a href=<?php echo $self; ??clearLogout</a

此时，MockSession扮演了 ServerStub的角色来控制决定用户是否登录的条件。它的功能也类似评判者，决定这个信息是否通过如下两个途径被正确的使用：一个是明确地被预先定义并通过tally()被验证，另一个是不直接的生成正确的输出，而是通过ServerStub返回的值来生成。

为了继续重构这段代码，下一步要跳到前面的进程。将要做两个动作：清除已经登录的用户和验证登录页面提交的用户名和密码是否存在。

让我们从注销功能上开始：

class PageDirectorTestCase extends UnitTestCase {
// ...
function TestClearLoginFunctionality() {
$_REQUEST[‘clear’] = null;
$session =& new MockSession($this);
$session-expectOnce(‘clear’, array(‘user_name’));
$session-setReturnValue(‘get’, null, array(‘user_name’));
$session-expectAtLeastOnce(‘get’);
$response = new MockResponse($this);
$response-expectOnce(‘redirect’, array(SELF));
$page =& new PageDirector($session, $response);
$this-assertEqual(‘’, $this-runPage($page));
$response-tally();
$session-tally();
unset($_REQUEST[‘clear’]);
}
}

在这段代码中，response是个伪对象，然而，一旦在Response::redirect()方法中调用了exit()，脚本将会停止执行。由于伪对象的存在，你可以核实方法是否被调用和方法传回了什么参数，且不会产生任何负面影响如脚本停止或被实际执行。

[next]

下面是是一些帮助你认识测试功能的代码：

class PageDirector {
// ...
function run() {
$this-processLogin();
if ($this-isLoggedIn()) {
$this-showPage(
new UserLogin($this-session-get(‘user_name’)));
} else {
$this-showLogin();
}
$this-response-display();
}
function processLogin() {
if (array_key_exists(‘clear’, $_REQUEST)) {
$this-session-clear(‘user_name’);
$this-response-redirect(SELF);
}
}
}

最后是对登录表单的处理进行的测试。

class PageDirectorTestCase extends UnitTestCase {
// ...
function TestLoginFromRequest() {
$_REQUEST[‘name’] = ‘admin’;
$_REQUEST[‘passwd’] = ‘secret’;
$session =& new MockSession($this);
$session-expectOnce(‘set’, array(‘user_name’,’admin’));
$response = new MockResponse($this);
$response-expectOnce(‘redirect’, array(SELF));
$page =& new PageDirector($session, $response);
$this-assertEqual(‘’, $this-runPage($page));
$response-tally();
$session-tally();
unset($_REQUEST[‘name’]);
unset($_REQUEST[‘passwd’]);
}
}

如下是实现上面测试所要求特性的代码：

class PageDirector {
// ...
function processLogin() {
if (array_key_exists(‘clear’, $_REQUEST)) {
$this-session-clear(‘user_name’);
$this-response-redirect(SELF);
}
if (array_key_exists(‘name’, $_REQUEST)
&& array_key_exists(‘passwd’, $_REQUEST)
&& UserLogin::validate(
$_REQUEST[‘name’], $_REQUEST[‘passwd’])) {
$this-session-set(‘user_name’, $_REQUEST[‘name’]);
$this-response-redirect(SELF);
}
}
}

这段程序已经重构而且也有充分的测试，因此可以对其进行一些附加的重构来清除像主脚本访问Session类，查询不经UserLogin类认可的字段而去访问‘user_name’字段，及session被当成资源调用等的小毛病。

当$_REQUEST这个超级变量被封装为一个类似Session类的资源以便与伪对象的创建时，为何让代码访问它？这段代码有很多问题：但它毕竟是某种人为的用来逐渐了解这些概念的例子，它是为此而被创造的所以你不必深究。

更为重要的是，你已经学会利用伪对象测试模式来分离代码，以及在测试中分离$_SESSION之类的资源和避免相互关联的对象（如包含在Response类中的exit()）产生不希望的结果。

问题

使用伪对象来测试代码可以让你分离所开发的代码。你可以消除负面影响和潜在的问题，极大地减少你在整个测试工作中所花的时间。这是一个好消息，因为如果你花在测试上的时间越多，以后就会越省事，并且你也会希望测试不是只做一次，应该能够被重复进行。（译注：这句直译太别扭，所以加了些使其通顺的内容。）

在新重构的程序中仍然会有许多漏洞。比如$_REQUEST变量应该由一个类来封装以便于使用伪对象测试。又如 showLogin()方法的重新调用。再如所有那些addBody()方法的调用看起来是如此混乱。

这种编程风格的另一个缺点是你将无法使用任何所见即所得的HTML编辑工具，这是因为所有HTML代码都被包含在PHP的方法调用中了。为了避免这些限制，你可以加入一个简单的基于PHP的模板机制。你可以这样引入模板文件：

<form method=post
Name:<input type=text name=name Password:<input type=password name=passwd
<input type=submit value=Login
</form

然后需要使用一个方法来调用它：

class Response {
// ...
/**
* adds a simple template mechanism to the response class
* @param string $template the path and name of the template file
* @return void
*/
function addBodyTemplate($template, $vars=array()) {
if (file_exists($template)) {
extract($vars);
ob_start();
include $template;
$this-_body .= ob_get_clean();
}
}
}

很明显的，世上没有最完美的模板引擎，但它确实使本章的示例代码精简整洁了。

在GoF中这种按任务进行分隔的概念是被鼓励的：

分隔设计模式下对象被创建后，其子类的创建过程就可以不再关注了。

如果你忠实地在测试中运用它的话，这句话能让你获益良多：你可以用内部Factory方法来代替伪对象所代表的类的实例。传统的测试模式所遵循的是子类化你的代码，然后重写对象的方法。 Marcus Baker，SimpleTest的作者，为PHP创立了PartialMock技术，那是一种测试模式的捷径。在其他的伪对象创建时你可以插入PartialMock。

如果你对理解如何在编程中使用伪对象有困难，请参见附录B关于Partial MockObjectSimpleTest Testing Practices的一节。

资源

有一些对你更好地了解PHP下伪对象模式有帮助的资源。你可以查看关于SimpleTest下伪对象的文档（参见http://simpletest.sf.net/SimpleTest/tutorial_MockObjects.pkg.html）。另外，Marcus Baker在2004年1月版的php|architect写了一篇文章题为Testing Made Easy with Mock Objects的文章。
更多的可以访问 http://www.mockobjects.com/ 和c2的wiki中关于伪对象的页面(http://www.c2.com/cgi/wiki?MockObject)两者都是优秀的入门站点。

下一节：《PHP设计模式介绍》第七章策略模式