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）通过工厂类创建留言服务
php三层结构(下)php实现aop
让我们把注意力集中到中间服务层上来。中间服务层代码比较简单，只是调用数据访问层代码将留言保存到数据库。如代码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），执行流程