PHP结构型设计模式(下)

1,004 阅读11分钟

续上一篇:PHP结构型设计模式(上)


PHP设计模式(九)—桥接模式(Bridge Pattern)

桥接模式 (Bridge Pattern):将抽象与实现解耦,使得两者可以独立的变化

(一)为什么需要桥接模式

1,如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性,避免在两个层次之间建立静态的继承联系,通过桥接模式可以使它们在抽象层建立一个关联关系。

2,抽象化角色和实现化角色可以以继承的方式独立扩展而互不影响,在程序运行时可以动态将一个抽象化子类的对象和一个实现化子类的对象进行组合,即系统需要对抽象化角色和实现化角色进行动态耦合。

3,虽然在系统中使用继承是没有问题的,但是由于抽象化角色和具体化角色需要独立变化,设计要求需要独立管理这两者。对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统,桥接模式尤为适用。

(二)桥接模式UML图

Bridge Pattern

  • Abstraction为抽象化角色,主要职责是定义该角色的行为,同时保存一个对实现化角色的引用。
  • Implementor为实现化角色,它是一个接口或抽象类。在PHP中一般是抽象类。

有点不知所云吧。我学的时候也是。老规矩,来个实例吧。

(三)简单实例

如果我现在是小米公司的雷布斯,小米公司旗下有小米mix和小米note手机,现在有一个底层的语音输出软件,由于小米mix的全面屏设计没有开孔使用了骨传导,所以和小米note有些不同。那么我们要如何来设计这个输出功能呢?

传统的做法就应该是,一个抽象手机品牌,mix和note手机品牌继承抽象手机品牌。然后有一个mix品牌的输出软件继承自mix品牌。如果这时候有一个redmi的牌子的输出软件就应继承自redmi品牌,redmi继承抽象手机品牌。

如果除了这个语音输出软件,我们还有其它的软件呢,一个手机有很多软件,那么这种继承,如果画出继承链的话,那一个品牌下得有多少子类?

如果我们使用桥接模式的话,就可以把这个软件的具体实现与抽象品牌分离出来,这样也能是我们动态增减实现化角色时更为方便。

<?php
//抽象化角色
abstract class MiPhone{
    protected $_audio;      //存放音频软件对象
    abstract function output();
    public function __construct(Audio $audio){
        $this->_audio = $audio;
    }
}
//具体手机
class Mix extends MiPhone{
    //语音输出功能
    public function output(){
        $this->_audio->output();
    }
}
class Note extends MiPhone{
    public function output(){
        $this->_audio->output();
    }
}
//实现化角色 功能实现者
abstract class Audio{
    abstract function output();
}
//具体音频实现者 -骨传导音频输出
class Osteophony extends Audio{
    public function output(){
        echo "骨传导输出的声音-----哈哈".PHP_EOL;
    }
}
//普通音频输出---声筒输出
class Cylinder extends Audio{
    public function output(){
        echo "声筒输出的声音-----呵呵".PHP_EOL;
    }
}

//让小米mix和小米note输出声音
$mix = new Mix(new Osteophony);
$mix->output();
$note = new Note(new Cylinder);
$note->output();

这样写的好处是把抽象化角色手机和实现化角色手机的具体功能音频输出 分离了出来。如果现在最新的小米note系列也要用上骨传导输出,那么我们只需实例化时传入的声筒音频类改为骨传导音频类。如果我们还有一个扬声器输出,小米mix和小米note都有这个功能。我们只需要再添加一个扬声器输出类继承Audio类,然后谁使用就保存这个实例在属性中。没有桥接模式的话,我们可是要写两个,一个是小米mix的扬声器输出,一个是小米note。

如果扬声器输出对小米mix和小米note不一样,那么我们确实需要写两个扬声器输出类。使用桥接模式,依然比原来直接继承好,就是因为有一天扬声器技术驱动更新了,我们要更新扬声器不用修改手机类代码,而只需传入一个更新的扬声器类。


PHP设计模式(十)—组合模式(Composite Pattern)

组合模式 (Composite Pattern):将对象组合成树形结构以表示“部分整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。组合模式也叫合成模式,有时候又叫做部分-整体模式。

(一)为什么需要组合模式

1,使我们在树型结构的问题中,模糊了简单元素和复杂元素的概念,客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

2,组合模式让你可以优化处理递归或分级数据结构。

(二)组合模式UML图

Composite Pattern

  • Component是组合中的对象声明接口,在适当的情况下,实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。
  • Leaf 在组合中表示叶子结点对象,叶子结点没有子结点。

  • Composite定义有枝节点行为,用来存储子部件,在Component接口中实现与子部件有关操作,如增加(add)和删除(remove)等。

(三)简单实例

如果我们在做一个OA系统,公司的人事管理该如何设计呢。传统的就是树状结构。经理下面有部门主管,然后是员工。

人事部门图

<?php
class Manager{
    public $name;
    protected $c_nodes = array();//存放子节点,部门经理,普通员工等
    public function __construct($name){
        $this->name = $name;
    }
    //添加部门经理
    public function addGm(GM $gm){
        $this->c_nodes[] = $gm;
    }
    //添加普通员工
    public function addStaff(Staff $staff){
        $this->c_nodes[] = $staff;
    }
    //获取全部子节点
    public function get_C_nodes(){
        return $this->c_nodes;
    }
}

//部门经理 就用general manager 简写 GM
Interface Gm{
    public function add(Staff $staff);
    public function get_c_nodes();
}
//销售经理
class Sgm implements Gm{
    public $name;
    protected $c_nodes = array();
    public function __construct($name){
        $this->name = $name;
    }
    //添加员工
    public function add(Staff $staff){
        $this->c_nodes = $staff;
    }
    //获取子节点
    public function get_C_nodes(){
        return $this->c_nodes;
    }
    //区别于其他经理,销售经理有一个销售方法
    public function sell(){
        echo "安利一下我司的产品";
    }
}
//员工接口
Interface staff{
    public function work();
}
//销售部员工
class Sstaff implements staff{
    public $name;
    public function work(){
        echo '在销售经理带领下,安利全世界';
    }
}
//实例化
$manager = new Manager("总经理");
$sgm = new Sgm("销售经理");
$staff = new Sstaff("何在");
//组装成树
$manager->addGm($sgm);
$sgm->add($staff);

我们想象一下,如果我们的层级非常深,如销售经理下面还有,销售主管,分区经理,分区主管。那怎么办?我们new的时候,就要new很多不同的类。而且如果要加一个任职期限的属性,还得每个类去添加一遍。

我们想做的是,可以把树形结构,当成“部分-整体结构”来处理,通俗地讲,就是把一个树形结构当成一个关系型的结构。例如:数据库存储的一行行的方式。找了张图,清楚些。

省市存储图

上面这张图把中国 -湖南-(长沙)(衡阳)-这个树状图以关系型的层级方式存储于数据库中。对于公司人事,其实我们也是可以用这种方法的。那就是利用组合模式。再去看一眼UML图把和人事管理图吧。我们发现总经理和部门经理还是有很多相同的地方。组合模式主要就是把根节点和所有树枝节点归结到一起去,这样就隐藏了树形的层级。

<?php
//抽象构件
Abstract class Component{
    public $name;
    abstract function doSomething();
    public function __construct($name){
        $this->name = $name;
    }
}
//普通员工  树叶构件 不能添加子节点
class Leaf extends Component{
    public $lever;
    public function doSomething(){
        echo "层级--{$this->lever}--work";
    }
}
//总经理 部门经理 主管等 树枝构件
class Composite extends Component{
    public $c_nodes = array();
    public $lever = 1;
    //添加子节点
    public function add(Component $component){
        $component->lever = $this->lever + 1;
        $this->c_nodes[] = $component;
    }
    public function doSomething(){
        echo "我是层级--{$this->lever}--".PHP_EOL;
    }
}
$manager = new Composite("总经理");
$sgm = new Composite("销售经理");
$staff = new  Leaf("何在");
//组装成树
$manager->add($sgm);
$sgm->add($staff);

这样,我们就把根节点(总经理)和所有树枝节点(部门经理,主管)的树枝结构隐藏了,通过$lever属性来区分。如果对于不同树枝节点有不同的方法,我们也可以在Composite 类中的doSomething()方法中延迟绑定具体的方法实现,使不同层级具有不同能力

   public function doSomething(){
        switch($this->lever){
            case 1:$this->manager();
                break;
            case 2:$this->sell();
        }
    }
    private function manager(){}
    private function sell(){}

当然,当层级太深时,若有多个层级有相同的doSomething能力。这种方法还是可以的。但是当层级太深且不同层级具有不同的doSomething能力时,就会导致一个类中空置了多个不用的private方法,而doSomething只调用一个。

$lever 的另一个功能就是便于递归遍历出所有公司人员

//遍历树 - 函数
function display(Composite $composite){
    $composite->doSomething();
    foreach($composite->c_nodes as $c_node)
         $c_node instanceof Leaf ? $c_node->doSomething() : display($c_node);                   
}
display($manager);

当然这种遍历方法只能前序遍历,即从根节点总经理向下找,没法从任何一个员工向上找出他的上级。如果,你想实现后序遍历,可以在Component类中添加一个parent属性,并在composite 的add方法中设置子节点的parent属性。

组合模式也分为透明模式和安全模式,上面的例子是安全模式。透明模式是把composite的方法也放到抽象类component中。

有许多关于分级数据结构的例子,使得组合模式非常有用武之地。关于分级数据结构的一个普遍性的例子是你每次使用电脑时所遇到的:文件系统。文件系统由目录和文件组成。每个目录都可以装内容。目录的内容可以是文件,也可以是目录。按照这种方式,计算机的文件系统就是以递归结构来组织的。如果你想要描述这样的数据结构,那么你可以使用组合模式Composite。


PHP设计模式(十一)—享元模式 (Flyweight Pattern)

享元模式 (Flyweight Pattern): 池技术的重要实现方式, 运用共享技术有效的支持大量的细粒度对象,用于减少创建对象的数量,以减少内存占用和提高性能。

(一)为什么需要享元模式

1,在有大量对象时,有可能会造成内存溢出,我们把其中共同的部分抽象出来,如果有相同的业务请求,直接返回在内存中已有的对象,避免重新创建。

2,系统有大量相似对象。

3,需要缓冲池的场景。

(二)享元模式UML图

Flyweight Pattern

(三)简单实例

这里引用《设计模式之禅》的例子,就是如果有一个报考信息系统,每个考生进来就实例化一个对象,传入他要报考的考点。由于考生分为30个考点,所以其实我们没有必要不停的实例化对象并释放,我们完全可以做一个缓冲池,若缓冲池中没有与这个考生相同考点的对象,则实例化一个,使用完不需要释放。下一个相同考点的考生进来后,只需复用这个对象。

<?php
//抽象享元对象
abstract class Flyweight{
    //考点
    public $address;
    //享元角色必修设置考点
    public function __construct($address){
        $this->address = $address;
    }
}
//具体享元角色  考生类
class ConcreteFlyweight extends Flyweight{
    //报考动作
    public function register(){
        echo "我的报考点是:{$this->address}".PHP_EOL;
    }
    //退出
    public function quit(){
        unset($this);
    }
}
//享元工厂 缓冲池
class FlyweightFactor{
    static private $students = array();
    static public function getStudent($address){
        $students =self::$students;
        //判断该键值是否存在
        if(array_key_exists($address,$students)){
            echo "缓冲池有考点为{$address},从池中直接取".PHP_EOL;   
        }else{
            echo "缓冲池没有,创建了考点为{$address}的对象并放到池中".PHP_EOL;
            self::$students[$address] = new ConcreteFlyweight($address);
        }
        return self::$students[$address];
    }
}

//实例化学生对象
$student_1 = FlyweightFactor::getStudent('广州');
//报考
$student_1 ->register();
// 退出
$student_1->quit();
//第二个学生进来
$student_2 = FlyweightFactor::getStudent('东莞');
//报考
$student_2 ->register();
// 退出
$student_2->quit();
//第三个学生进来
$student_3 = FlyweightFactor::getStudent('广州');
//报考
$student_3 ->register();
// 退出
$student_3->quit();

这里我们可以看到,当第三个学生进来时,由于和第一个学生的报考地点一致,所以只需从缓冲池取出。

ps:虽然ConcreteFlyweight的quit方法unset了$this,但是由于在FlyweightFactor中的students还存放着这个对象,所以unset只释放了变量$student_1,并没有完全删除这个对象,这就是student_3进来还能从缓冲池取得对象的原因

享元模式在PHP中可能比较少遇,但在Java中常常有这种情况。就是代码产生了大量的对象,虽然使用完有释放,但是由于垃圾回收需要一定时间,导致内存被耗尽。PHP经常应用web编程,脚本执行时间很短(30秒)。所以很少遇见这种情况,甚至我们使用完变量,连unset()函数都不用调用,就等着脚步执行结束后,自动释放。但是如果你试过在cli模式下运行PHP脚本,做一些socket通信,发送邮件等长耗时或是多连接任务时,就难免会遇到这种情况。


上一篇PHP结构型设计模式(上)

感谢阅读,由于笔者也是初学设计模式,能力有限,文章不可避免地有失偏颇
后续更新 PHP设计模式-行为型设计模式 介绍,欢迎大家评论指正


我最近的学习总结:


欢迎大家关注我的微信公众号 火风鼎