设计模式之--组合模式

912 阅读9分钟

1. 定义

组合模式: 用小的子对象来构建更大的对象,而这些小的子对象本身也许是由更小的“孙对象”构成的。

2. 回顾宏命令

宏命令对象包含了一组具体的子命令对象,不管是宏命令对象,还是子命令对象,都有一个execute方法负责执行命令。

var closeDoorCommand = {
    execute: function(){
        console.lgo('关门')
    }
}

var openPcCommand = {
    execute: function(){
        console.lgo('开电脑')
    }
}

var openQQCommand = {
    execute: function(){
        console.lgo('登录QQ')
    }
}

var MacroCommand = function(){
    return {
        commandsList: [],
        add: function(command){
            this.commandsList.push(command)
        },
        execute: function(){
            for(var i=0, command;command=this.commandsList[i++];) {
                command.execute();
            }
        }
    }
}

var macroCommand = MacroCommand();
macroCommand.add(closeDoorCommand)
macroCommand.add(openPcCommand)
macroCommand.add(openQQCommand)

macroCommand.execute();

宏命令中包含了一组子命令,它们组成了一个树形结构,一颗结构非常简单的树

macroCommand 称为组合对象, closeDoorCommand、openPcCommand、openQQCommand 都是叶对象。在macroCommand的execute方法里,并不执行真正的操作,而是遍历它所包含的叶对象,把真正的execute请求委托给这些叶对象。

macroCommand表现得像一个命令,但它实际上只是一组真正命令的“代理”。并非真正的代理,虽然结构上相似,但macroCommand只负责传递请求给叶对象,它的目的不在于控制对叶对象的访问。

3. 组合模式的用途

组合模式将对象组合成树形结构,以表示“部分-整体”的层次结构。除了用来表示树形结构之外,组合模式的另一个好处是通过对象的多态性表现,使得用户对单个对象和组合对象的使用具有一致性。

  • 表示树形结构。提供了一种遍历树形结构的方案,通过调用组合对象的execute方法,程序会递归调用组合对象下面的叶对象的execute方法。组合模式可以非常方便地描述对象部分-整体层次结构

  • 利用对象多态性统一对待组合对象和单个对象。利用对象的多态性表现,可以使客户端忽略组合对象和单个对象的不同。在组合模式中,客户将统一地使用组合结构中的所有对象,而不需要关心它是组合对象还是单个对象。

4. 请求在树中传递的过程

以宏命令为例,请求从树最顶端的对象往下传递,如果当前处理请求的对象是叶对象(普通子命令),叶对象自身会对请求作出相应的处理;如果当前处理请求的对象是组合对象(宏命令),组合对象则会遍历它属下的子节点,将请求继续传递给这些子节点。

总之,如果子节点是叶对象,叶对象自身会处理这个请求,而如果子节点还是组合对象,请求会继续往下传递。叶对象下面不会再有其他子节点,一个叶对象就是数的这条枝叶的尽头,组合对象下面可能还会有子节点。

请求从上到下沿着树进行传递,直到树的尽头。作为客户,只需要关心树最顶层的组合对象,客户只需要请求这个组合对象,请求便会沿着树往下传递,依次到达所有的叶对象。

如果只是简单地遍历一组子节点,迭代器便能解决。

5. 更强大的宏命令

var MacroCommand = function(){
    return {
        commandsList: [],
        add: function(command){
            this.commandsList.push(command)
        },
        execute: function(){
            for(var i=0, command;command=this.commandsList[i++];) {
                command.execute();
            }
        }
    }
}

var openAcCommand = {
    execute: function(){
        console.log('打开空调')
    }
}

var openTvCommand = {
    execute: function(){
        console.log('打开电视')
    }
}

var openSoundCommand = {
    execute: function(){
        console.log('打开音响')
    }
}

var macroCommand1 = MacroCommand();
macroCommand1.add(openTvCommand);
macroCommand1.add(openSoundCommand);

var closeDoorCommand = {
    execute: function(){
        console.log('关门')
    }
} 

var openPcCommand = {
    execute: function(){
        console.log('开电脑')
    }
}

var openQQCommand = {
    execute: function(){
        console.log('登录QQ')
    }
}

var macroCommand2 = MacroCommand();
macroCommand2.add(closeDoorCommand);
macroCommand2.add(openPcCommand);
macroCommand2.add(openQQCommand);

var macroCommand = MacroCommand();
macroCommand.add(openAcCommand)
macroCommand.add(macroCommand1)
macroCommand.add(macroCommand2)

var setCommand = (function(command){
    document.getElementById('button').onclick = function(){
        command.execute();
    }
})(macroCommand)

基本对象可以被组合成更复杂的组合对象,组合对象又可以被组合,这样不断递归下去,这棵树的结构可以支持任意多的复杂度。在树被最终构造完成之后,让整棵树最终运转起来的步骤非常简单,只需要最上层对象的execute方法。每当对最上层的对象进行一次请求时,实际上是在对整个树进行深度优先的搜索,而创建组合对象的程序员并不关心这些内在的细节,往这棵树里面添加一些新的节点对象是非常容易的。

6. 透明性带来的安全问题

组合模式的透明性使得发起请求的客户不用去顾忌树中组合对象和叶对象的区别,但它们在本质上还是有区别的

组合对象可以拥有子节点,叶对象下面就没有子节点,所以也许会发生一些误操作,比如试图往叶对象添加子节点。解决方案通常是给叶对象也增加add方法,并且在调用这个方法时,抛出一个异常来及时提醒客户

var MacroCommand = function(){
    return {
        commandsList: [],
        add: function(command){
            this.commandsList.push(command)
        },
        execute: function(){
            for(var i=0, command;command=this.commandsList[i++];) {
                command.execute();
            }
        }
    }
} 

var openTvCommand = {
    execute: function(){
        console.log('打开电视')
    },
    add: function(){
        throw new Error('叶对象不能添加子节点')
    }
}

7. 组合模式的例子-扫描文件夹

文件夹和文件之间的关系。非常适合用组合模式来描述。文件夹里即可以包含文件,又可以包含其他文件夹,最终组合成一棵树。

// 文件夹Folder 和 文件 File
var Folder = function(name) {
    this.name = name;
    this.files = [];
}

Folder.prototype.add = function(file) {
    this.files.push(file);
}

Folder.prototype.scan = function(){
    console.log('开始扫描文件夹:' + this.name);
    for(var i=0, file, files = this.files; file = files[i++];) {
        file.scan();
    }
}

var File = function(name){
    this.name = name;
}

File.prototype.add = function(){
    throw new Error('文件下面不能再添加文件');
}

File.prototype.scan = function(){
    console.log('开始扫描文件:' + this.name)
}

var folder = new Folder('学习资料');
var folder1 = new Folder('JavaScript');
var folder2 = new Folder('jQuery');

var file1 = new File('JavaScript设计模式与开发实战');
var file2 = new File('精通jQuery');
var file3 = new File('重构与模式');

folder1.add(file1);
folder2.add(file2);

folder.add(folder1)
folder.add(folder2)
folder.add(file3)

同等对待组合对象和叶对象。

改变了树结构,增加了新的数据,却不用修改任何一句原有的代码,符合开放封闭原则的。

8. 注意的地方

    1. 组合模式不是父子关系

组合模式的树形结构容易误以为组合对象和叶对象是父子关系,这是不正确的

组合模式是一种 HAS-A(聚合)的关系,而不是IS-A。组合对象包含一组叶对象。组合对象把请求委托给它所包含的所有叶对象,他们都拥有相同的接口。

    1. 对叶对象操作的一致性

组合模式除了要求组合对象和叶对象拥有相同的接口之外,还有一个必要条件,就是对一组叶对象的操作必须具有一致性

    1. 双向映射关系

给父节点和子节点建立双向映射关系,可以引入中介者模式来管理这些对象

    1. 用职责链模式提高组合模式性能

在组合模式中,如果树的结构比较复杂,节点数量很多,在遍历树的过程中,性能方面可能表现不够理想。可以借助一些技巧,在实际操作中避免遍历整棵树,有一种现成的方案是借助职责链模式。职责链模式一般需要手动去设置链条,但在组合模式中,父对象和子对象之间实际上形成了天然的职责链。让请求顺着链条从父对象往子对象传递,或者是反过来子对象往父对象传递,直到遇到可以处理该请求的对象为止,这也是职责链模式的经典运用场景之一

9.引用父对象

组合对象保存了它下面的子节点的引用,这是组合模式的特点,此时树结构是从上至下的。但有时候我们需要在子节点上保持对父节点的引用,比如组合模式中使用职责链时,有可能需要让请求从子节点往父节点上冒泡传递。当我们删除某个文件的时候,实际上是从这个文件所在的上层文件夹中删除该文件的

改写Folder类和File类,在这两个类的构造函数中,增加this.parent属性,并且在调用add方法的时候,正确设置文件或者文件夹的父节点:

 var Folder = function(name) {
    this.name = name;
    this.parent = null;
    this.files = [];
}

Folder.prototype.add = function(file) {
    this.parent = this;
    this.files.push(file);
}

Folder.prototype.scan = function(){
    console.log('开始扫描文件夹:' + this.name);
    for(var i=0, file, files = this.files; file = files[i++];) {
        file.scan();
    }
}

Folder.prototype.remove = function(){
    if (!this.parent) {
        return;
    }
    for(var files=this.parent.files, l = files.length - 1; l >= 0; l--) {
        var file = files[l];
        if(file === this){
            files.splice(l, 1);
        }
    }
}

在Folder.prototype.remove方法里,首先会判断this.parent,如果this.parent为null, 那么这个文件夹要么是树的根节点,要么是还没有添加到树的游离节点中,这时候没有节点需要从树中移除,暂且让remove直接return,不做任何操作

如果this.parent不为null, 则说明该文件夹有父节点存在,此时遍历父节点中保存的子节点列表,删除想要删除的子节点

var File = function(name){
    this.name = name;
    this.parent = null;
}

File.prototype.add = function(){
    throw new Error('文件下面不能再添加文件');
}

File.prototype.scan = function(){
    console.log('开始扫描文件:' + this.name)
}

 File.prototype.remove = function(){
    if (!this.parent) {
        return;
    }
    for(var files=this.parent.files, l = files.length - 1; l >= 0; l--) {
        var file = files[l];
        if(file === this){
            files.splice(l, 1);
        }
    }
}

10. 何时使用组合模式

组合模式运用得当,可以大大简化客户的代码。适用以下情况

    1. 表示对象的部分-整体层次结构。组合模式可以方便地构造一棵树来表示对象的部分-整体结构。特别是在开发期间不确定这棵树到底存在多少层次的时候。在树的构造最后完成之后,只需要通过请求树的最顶层对象,便能对整棵树做统一的操作。在组合模式中增加和删除树的节点非常方便,并且符合开放-封闭原则
    1. 客户希望统一对待树中的所有对象。组合模式使客户可以忽略组合对象和叶对象的区别,客户在面对这棵树的时候,不用关心当前正在处理的对象是组合对象还是叶对象,也就不用写一堆if、else语句来分别处理它们。组合对象和叶对象各自会做自己正确的事情,这是组合模式最重要的能力

11. 总结

组合模式可以让我们使用树形方式创建对象的结构。可以把相同的操作应用在组合对象和单个对象上。在大多数情况下,我们可以忽略掉组合对象和单个对象之间的差别,从而用一致的方式来处理它们

然而,组合模式并不是完美的,可能会产生一个这样的系统:系统中的每个对象看起来都与其他对象差不多。它们的区别只有在运行的时候才会显现出来,这会使代码难以理解。此外,如果通过组合模式创建了太多的对象,那么这些对象可能会让系统负担不起