php学习交流博客

好好写代码,好好痛她

PHP三层结构





我们以一个简单的留言板代码为例,先来看一个最简单的三层结构代码,如代码1所示:

 

// 代码 1
//
外观层类
class LWordHomePage {
// 添加留言
public function append($newLWord) {
// 调用中间服务层
$serv = new LWordServiceCore();
$serv->append($newLWord);
}
};

// 中间服务层
class LWordServiceCore {
// 添加留言
public function append($newLWord) {
// 调用数据访问层
$dbTask = new LWordDBTask();
$dbTask->append($newLWord);
}
};

// 数据访问层
class LWordDBTask {
// 添加留言
public function append($newLWord) {
// 数据层代码(省略)
}
};

 

 执行时序图,如图1所示:

 

(图1),简单三层结构时序图

 

从代码和时序图中可以直观看出三层结构的调用顺序。但实际开发中这种简单三层结构并不能满足需求!我们先从外观层与中间服务层这两层的代码开始讨论。在外观层LWordHomePage类中直接使用new关键字创建并调用中间服务类LWordServiceCore属于一种硬编码的方式。在实际项目开发过程中,外观层和中间服务层可能会由不同的人员来开发,即一个功能模块由多个人共同完成。而外观层LWordHomePage类的开发进度是不可能等到LWordServiceCore类完全开发完成之后才开始(换句话来说就是,外观层不可能等到中间服务层完全开发完成之后才开始),这样的协作效率非常低!为了使项目可以由多人同时开发,所以我们要切割代码设计。我们可以组织一个临时的中间服务类来满足外观层的开发进度。等到中间服务层完全开发完成之后,替换一下就可以了……如图2所示:

 

 

(图2),外观层在不同的服务间切换

 

显然,要实现这样的需求,在外观层中直接使用new关键字创建和调用LWordServiceCore类是非常不灵活的!这很难做到灵活的随意的切换!!我们可以创建TempService类充当中间服务层的临时实现。我们还需要分析一下TempService和LWordServiceCore这两个类,它们都具备相同的append函数用于添加留言,只不过一个是临时的而另外一个是真实的。既然TempService和LWordServiceCore这两个类都有公共函数,那么就应该可以有一个公共的父类。考虑到对这个公共的上级类没有别的成员和属性,所以将这个公共的上级类定义为接口,即ILWordService!UML类图如图3所示:


 

(图3)定义和实现ILWordService接口

 

在LWordHomePage类中并不直接创建TempService或者LWordServiceCore类对象,创建过程会交给一个工厂类MyServiceFactory(简单工厂模式)。这样一来,外观层中的LWordHomePage类只需要知道ILWordService接口即可,外观层代码并不关心具体的中间服务代码是什么,这样就极好的实现了外观层与具体服务代码的分离。

 

这相当于什么呢?就好比两个硬件工程师,一个是制造计算机显卡的,一个是制造计算机主板的。制造显卡的工程师可以把显卡插到到一块测试电路中,来测试显卡是否可以正常工作?同样,制造主板的工程师也可以把主板插入到另一块测试电路中,来测试主板是否可以正常工作?等到这两位工程师都各自完成工作之后,将他俩的工作成果对接在一起就可以了。这是一种并行开发方式,几乎可以省掉一半的时间。从软件工程的角度来讲,我们在设计接口代码的时候也应该考虑是否需要支持多人同时开发,从而提高生产效率。

 

依照UML类图(如图3所示),我们修改PHP代码如代码2所示:

 

// 代码2, 通过工厂创建留言服务并调用
// 外观层类
class LWordHomePage {
// 添加留言
public function append($newLWord) {
// 调用中间服务
$serv = MyServiceFactory::create();
// 注意此时是操作 ILWordService 接口, 而非 LWordService 类
$serv->append($newLWord
);
}
};

// 留言服务接口
interface ILWordService {
public function append($newLWord);
};

// 服务工厂类
class MyServiceFactory {
// 创建留言服务
public static function create() {
if (1) {
// 返回中间服务层
return new LWordServiceCore();
}
else {
// 返回临时实现
return new
TempService();
}
}
}


// 临时服务类
class TempService implements ILWordService {
// 添加留言
public function append($newLWord) {
// 临时代码(省略)
}
};

// 中间服务层
class LWordServiceCore implements ILWordService {
// 添加留言
public function append($newLWord) {
// 调用数据访问层
$dbTask = new LWordDBTask();
$dbTask->append($newLWord);
}
};

// 数据访问层
class LWordDBTask {
// 添加留言
public function append($newLWord) {
// 数据层代码(省略)
}
};

 

时序图如图4所示:

 

(图4)通过工厂类创建留言服务


————————————————————————————————————————————上线分割线—————————————————————————————————————————————————

 

让我们把注意力集中到中间服务层上来。中间服务层代码比较简单,只是调用数据访问层代码将留言保存到数据库。如代码1所示:

// 代码 1
// 中间服务层

class LWordServiceCore implements ILWordService {
// 添加留言
public function append($newLWord) {
// 调用数据访问层
$dbTask = new LWordDBTask();
$dbTask->append($newLWord);
}
};

 

在看到留言板的演示之后,公司的产品部和市场部或许会提出各种各样的想法和需求。比如他们希望在添加留言之前判断用户的权限!只有注册用户才能留言!我们需要修改代码,如代码2所示:

 

// 代码 2, 增加登录验证
// 中间服务层

class LWordServiceCore implements ILWordService {
// 添加留言
public function append($newLWord) {
if (!($userLogin)) {
// 提示用户登录
}

// 调用数据访问层
$dbTask = new LWordDBTask();
$dbTask->append($newLWord);
}
};

 

市场部又希望在添加留言之前,对留言内容进行检查,如果留言中含有脏话就不保存。我们继续修改代码,如代码3所示:

 

// 代码 3, 增加脏话过滤
// 中间服务层

class LWordServiceCore implements ILWordService {
// 添加留言
public function append($newLWord) {
if (!($userLogin)) {
// 提示用户登录
}

if (stristr($newLWord, "SB")) {
// 含有脏话, 提示留言发送失败
}

// 调用数据访问层
$dbTask = new LWordDBTask();
$dbTask->append($newLWord);
}
};

 

产品部也提出了新需求,他们希望加入积分机制。具体来讲就是在用户每次留言成功以后给用户+5分。我们继续修改代码,如代码4所示:

 

// 代码 4, 加入留言积分机制
// 中间服务层

class LWordServiceCore implements ILWordService {
// 添加留言
public function append($newLWord) {
if (!($userLogin)) {
// 提示用户登录
}

if (stristr($newLWord, "SB")) {
// 含有脏话, 提示留言发送失败
}

// 调用数据访问层
$dbTask = new LWordDBTask();
$dbTask->append($newLWord);

// 给用户加分
$score = getUserScore($userName);
$score = $score + 5;
saveUserScore(
$userName, $score
);
}
};

 

没过多久,产品部又对需求进行细化,他们希望用户积分每积累够1000分以后,就给用户升级。我们继续修改代码,如代码5所示:

 

// 代码 5, 加入用户升级规则
// 中间服务层

class LWordServiceCore implements ILWordService {
// 添加留言
public function append($newLWord) {
if (!($userLogin)) {
// 提示用户登录
}

if (stristr($newLWord, "fuck")) {
// 含有脏话, 提示留言发送失败
}


// 调用数据访问层
$dbTask = new LWordDBTask();
$dbTask->append($newLWord);

// 给用户加分
$score = getUserScore($userName);
$score = $score + 5;
saveUserScore(
$userName, $score);

// 给用户升级
if (($score % 1000) == 0) {
$level = getUserLevel($userName);
$level = $level + 1;
saveUserLevel(
$userName, $level
);
}

}
};

 

随着需求的增多,我们需要不断的修改中间服务层代码。但是你应该不难发现,需求越多中间服务层代码也就越多越庞大!最后会导致即便我们使用三层结构的开发模式,也还是没有有效的降低工程难度!另外就是应需求的变化而修改中间服务代码以后,需要重新测试所有代码,而不是有效的测试新增代码……

 

其实让我们仔细分析一下这个留言板代码,我先要提出一个主业务逻辑和次业务逻辑的概念。无论怎样,把留言内容存入到数据库,这是业务逻辑的主干!这个就是主业务逻辑!这部分没有随着需求的增加而修改。至于在存入数据库之前要进行权限校验,要进行内容检查,存入数据库之后要给用户加分,然后给用户升级,这些都是前序工作和扫尾工作,都是次业务逻辑!主业务逻辑几乎是一成不变的,次业务逻辑变化却非常频繁。为了提高代码的可读性和可维护性,我们可以考虑把这些次业务逻辑放到别的地方,尽量不要让它们干扰主业务逻辑。主业务逻辑专心干自己该干的事情好了,至于别的任何事情,主业务逻辑一概都不闻不问!那么我们的代码就可以写成这样,如代码6所示:

 

// 代码 6, 将主业务逻辑和次业务逻辑分开
// 中间服务层

class LWordServiceCore implements ILWordService {
// 添加留言
public function append($newLWord) {
// 添加留言前
beforeAppend($newLWord
);

// 调用数据访问层
$dbTask = new LWordDBTask();
$dbTask->append($newLWord);

// 添加留言后
behindAppend($newLWord
);
}
};

 

我们可以把权限判断代码和留言内容文本过滤代码统统塞进beforeAppend函数,把用户积分代码塞进behindAppend函数,这样就把次业务逻辑从主业务逻辑代码中清理掉了。主业务逻辑知道有个“序曲”函数beforeAppend,有个“尾声”函数behindAppend,但是在序曲和尾声函数中具体都做了什么事情,主业务逻辑并不知道,也不需要知道!当然实际编码工作并不那么简单,我们还要兼顾产品部和市场部更多的需求变化,所以最好能实现一种插件方式来应对这种变化,但是仅仅依靠两个函数beforeAppend和behindAppend是达不到这个目的~

 

想要实现插件方式,可以建立接口!使用接口的好处是可以将定义和实现隔离,另外就是实现多态。我们建立一个留言扩展接口ILWordExtension,该接口有两个函数beforeAppend和behindAppend。权限校验、内容检查、加分这些功能可以看作是实现ILWordExtension接口的三个实现类,主业务逻辑就依次遍历这三个实现类,来完成次业务逻辑。如图1所示:

 

(图1),加入扩展接口

 

CheckPowerExtension扩展类用作用户权限校验,CheckContentExtension扩展类用作留言内容检查,AddScoreExtension扩展类用作给用户加分和升级。示意代码如代码7所示:

 

// 代码 7,加入扩展接口
// 扩展接口

interface ILWordExtension {
// 添加留言前
public function beforeAppend($newLWord);
// 添加留言后
public function behindAppend($newLWord
);
};


// 检查权限
class CheckPowerExtension implements ILWordExtension {
// 添加留言前
public function beforeAppend($newLWord) {
// 在这里判断用户权限
}

// 添加留言后
public function behindAppend($newLWord) {
}
};

// 检查留言文本
class CheckContentExtension implements ILWordExtension {
// 添加留言前
public function beforeAppend($newLWord) {
if (stristr($newLWord, "SB")) {
throw new Exception();
}
}

// 添加留言后
public function behindAppend($newLWord) {
}
};

// 用户积分
class AddScoreExtension implements ILWordExtension {
// 添加留言前
public function beforeAppend($newLWord) {
}

// 添加留言后
public function behindAppend($newLWord) {
// 在这里给用户积分
}
};

// 中间服务层
class LWordServiceCore implements ILWordService {
// 添加留言
public function append($newLWord) {
// 添加留言前
$this->beforeAppend($newLWord
);

// 调用数据访问层
$dbTask = new LWordDBTask();
$dbTask->append($newLWord);

// 添加留言后
$this->behindAppend($newLWord
);
}

// 添加留言前
private function beforeAppend($newLWord) {
// 获取扩展数组
$extArray = $this->getExtArray();

foreach ($extArray as $ext) {
// 遍历每一个扩展, 并调用其 beforeAppend 函数
$ext->beforeAppend($newLWord
);
}

}

// 添加留言后
private function behindAppend($newLWord) {
// 获取扩展数组
$extArray = $this->getExtArray();

foreach ($extArray as $ext) {
// 遍历每一个扩展, 并调用其 behindAppend 函数
$ext->behindAppend($newLWord
);
}

}

// 获取扩展数组,
// 该函数的返回值实际上是 ILWordExtension 接口数组

private function getExtArray() {
return array(
// 检查权限
new CheckPowerExtension(),
// 检查内容
new CheckContentExtension(),
// 加分
new AddScoreExtension(),

);
}

};

 

如果还有新需求,,我们只要再添加ILWordExtension 实现类并且把它注册到getExtArray函数里即可。程序从此有了条理,并且算是具备了可扩展性。

 

不过先不要忙着高兴,有个问题就在这个可扩展性里。当新的需求被提出之后,我们可以再添加 ILWordExtension 实现类,这个的确正确。但是将这个新类注册到getExtArray函数里,等于说还是要修改主业务逻辑代码。能不能不修改呢?每次有新的需求变化还是要告知主业务逻辑,这样终归不太好。最理想的情况是新的扩展代码加入系统之后,主业务逻辑代码不用修改,因为主业务逻辑根本不知道有新扩展这回事!为此我们还需要优化一下设计方案,如图2所示:

 

(图2),加入扩展家族类

 

对于调用扩展的主程序(也就是中间服务类LWordServiceCore),只让它知道有ILWordExtension(扩展)这件事就可以了,它不需要知道还有CheckPowerExtension(检查权限扩展)、CheckContentExtension(检查内容扩展)和AddScoreExtension(加分扩展)这三个类。对这三个类的调用过程被移动到LWordExtensionFamily (扩展家族类)里去了。

 

LWordExtensionFamily其实就是一个能存放多个ILWordExtension接口实例的容器类,从图2中可以看出这个容器类不仅仅是实现了ILWordExtension接口,而且还聚合多个ILWordExtension接口的实例,所以它很特殊!对于LWordServiceCore类,这个类只知道ILWordExtension接口,但并不知道这个接口存在三个实现类。恰好LWordExtensionFamily类就实现了ILWordExtension接口,这很好的符合了中间服务类的要求,并且这个扩展家族类知道ILWordExtension存在三个实现类,并会一一调用它们, LWordExtensionFamily代码大概如代码8所示:

 

// 代码 8, 扩展家族
// 扩展家族

class LWordExtensionFamily implements ILWordExtension {
// 扩展数组
private $_extensionArray = array();

// 添加扩展
public function addExtension(ILWordExtension $extension) {
$this->_extensionArray []= $extension
;
}


// 添加留言前
public function beforeAppend($newLWord) {
foreach ($this->_extensionArray as $extension) {
$extension->beforeAppend($newLWord
);
}

}

// 添加留言后
public function behindAppend($newLWord) {
foreach ($this->_extensionArray as $extension) {
$extension->behindAppend($newLWord
);
}

}
}

 

通过代码8不难看出LWordExtensionFamily类虽然也实现了ILWordExtension接口,但是它并不做任何实质的操作,而是通过循环语句将调用过程一一传递下去。为了平滑实现扩展到插入的方式,所以最好创建一个工厂类MyExtensionFactory。如代码9所示:

 

// 代码 9
// 自定义扩展工厂

class MyExtensionFactory {
// 创建留言扩展
public static function createLWordExtension() {
$lwef = new LWordExtensionFamily();
// 添加扩展
$lwef->addExtension(new CheckPowerExtension());
$lwef->addExtension(new CheckContentExtension());
$lwef->addExtension(new AddScoreExtension());

return $lwef
;
     // 注意这里返回的是扩展家族类对象,
     // 扩展家族 LWordExtensionFamily 恰好也实现了接口 ILWordExtension,
     // 所以这是符合业务逻辑的要求.
     // 从此, 业务逻辑可以不关心具体的扩展对象, 只要知道扩展家族即可

}
}

 

使用扩展工厂类的好处就是可以随意的添加和移除扩展实例,这就很好的实现了可插入式编程。对于LWordServiceCore类只知道一个ILWordExtension接口,对于LWordExtensionFamily知道需要一一调用每个扩展,但是具体会有多少个扩展是通过MyExtensionFactory给出的。各负其责结构也很清晰。如果我们做一个假设,MyExtensionFactory类的createLWordExtension函数不是通过new关键字这样的硬编码方式来添加扩展列表,而是通过更巧妙的读取配置文件的方式来得到扩展列表,那么是不是更方便更灵活呢?不过这个就不再本文中讨论了。

 

中间服务层通过工厂类取得一个ILWordExtension接口的具体实例,然后调用其beforeAppend和behindAppend方法。当然中间服务并不知道工厂类返回的其实是一个含有多个ILWordExtension实例的容器(因为这个容器也实现了ILWordExtension接口),所以中间服务也就不知道扩展是被一一调用的。完整代码如代码10所示:

 

// 代码 10, 完整代码
// 扩展接口

interface ILWordExtension {
// 添加留言前
public function beforeAppend($newLWord);
// 添加留言后
public function behindAppend($newLWord);
};

// 检查权限
class CheckPowerExtension implements ILWordExtension {
// 添加留言前
public function beforeAppend($newLWord) {
// 在这里判断用户权限
}

// 添加留言后
public function behindAppend($newLWord) {
}
};

// 检查留言文本
class CheckContentExtension implements ILWordExtension {
// 添加留言前
public function beforeAppend($newLWord) {
if (stristr($newLWord, "fuck"))
throw new Exception();
}

// 添加留言后
public function behindAppend($newLWord) {
}
};

// 用户积分
class AddScoreExtension implements ILWordExtension {
// 添加留言前
public function beforeAppend($newLWord) {
}

// 添加留言后
public function behindAppend($newLWord) {
// 在这里给用户积分
}
};

// 扩展家族
class LWordExtensionFamily implements ILWordExtension {
// 扩展数组
private $_extensionArray = array();

// 添加扩展
public function addExtension(ILWordExtension $extension) {
$this->_extensionArray []= $extension;
}

// 添加留言前
public function beforeAppend($newLWord) {
foreach ($this->_extensionArray as $extension) {
$extension->beforeAppend($newLWord);
}
}

// 添加留言后
public function behindAppend($newLWord) {
foreach ($this->_extensionArray as $extension) {
$extension->behindAppend($newLWord);
}
}
}

// 自定义扩展工厂
class MyExtensionFactory {
// 创建留言扩展
public static function createLWordExtension() {
$lwef = new LWordExtensionFamily();
// 添加扩展
$lwef->addExtension(new CheckPowerExtension());
$lwef->addExtension(new CheckLWordExtension());
$lwef->addExtension(new AddScoreExtension());

return $lwef;
}
}

// 中间服务层
class LWordServiceCore implements ILWordService {
// 添加留言
public function append($newLWord) {
// 获取扩展
$ext = MyExtensionFactory::createLWordExtension();

$ext->beforeAppend($newLWord
);

// 调用数据访问层
$dbTask = new LWordDBTask();
$dbTask->append($newLWord);

$ext->behindAppend($newLWord);
}
};

 

从代码10中可以看出虽然CheckPowerExtension、CheckContentExtension、AddScoreExtension以及LWordExtensionFamily都实现了ILWordExtension接口,但是它们的beforeAppend和behindAppend函数过程却完全不同!特别是LWordExtensionFamily扩展家族类,它并没有实质的业务逻辑处理过程,而是将调用依次传递给每一个扩展。beforeAppend和behindAppend函数在具体类中的不同实现,这是面向对象程序设计中的很典型的特性:多态!

 

将次业务逻辑分散到各个扩展中,这种做法已经非常近似AOP(Aspect OrientedProgramming,面向切面编程)的编程方式。权限校验、内容检查和积分可以看作是不同的切面,这些切面和主业务逻辑交叉在一起,但又不会影响到主业务逻……这样做的好处就是扩展代码不会干扰主业务逻辑,我们也可以针对某一个扩展进行编码和单元测试,然后通过MyExtensionFactory工厂类把扩展插入到业务流程中。完整的执行过程如图3所示:

 

(图3),执行流程

 

 

转载自:http://www.cnblogs.com/afritxia2008/


posted on 2010-11-11 17:21 王吉刚 阅读(489) 评论(0)  编辑 收藏 引用 网摘 所属分类: php学习转载区


只有注册用户登录后才能发表评论。
网站导航: