程序博客网 > h3c如何查看端口状态

【学习笔记javascript设计模式与开发实践（组合模式）----10】

来源：互联网 发布：h3c如何查看端口状态 编辑：程序博客网 时间：2024/06/04 18:49

第10章 组合模式

在程序设计中，也有一些和“事物是由相似的子事物构成”类似的思想。组合模式就是肜小的子对象来构建更大的对象，而这些小的子对象本身也许是由更小的“孙对象”构成的。

10.1 回顾宏命令

我们在第9章命令模式中讲解过宏命令的结构和作用。宏命令对象包含了一组个体的子命令对象，不管是宏命令对象，还是子命令对象，都有一个execute方法负责执行命令。现在回顾下这段安装在万遥控器上的宏命令代码：

[javascript] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. var closeDoorCommand={  
  2.    execute:function(){  
  3.       console.log('关门');  
  4.    }  
  5. };  
  6. var openPcCommand={  
  7.     execute:function(){  
  8.         console.log('开电脑');  
  9.     }  
  10. };  
  11. var openQQCommand={  
  12.     execute:function(){  
  13.         console.log('登录QQ');  
  14.     }  
  15. };  
  16.    
  17. var MacroCommand=function(){  
  18.    return {  
  19.       commandsList:[],  
  20.       add:function(command){  
  21.          this.commandsList.push(command);  
  22.       },  
  23.       execute:function(){  
  24.           for(vari=0,command;command=this.commandsList[i++];){  
  25.              command.execute();  
  26.           }  
  27.       }  
  28.    }  
  29. };  
  30.    
  31. varmacroCommand=MacroCommand();  
  32. macroCommand.add(closeDoorCommand);  
  33. macroCommand.add(openPcCommand);  
  34. macroCommand.add(openQQCommand);  
  35. macroCommand.execute();  

通过观察这段代码，我们很容易发现，宏命令中包含了一组子命令，它们组成了一个树形结构，这里是一棵非常简单的树。

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

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

10.2 组合模式的用途

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

 

l   表示树形结构。通过回顾上面的例子，我们很容易找到组合模式的一个优点：提供一种遍历树形结构的方案，通过调用组合对象的execute方法，程序会递归调用组合对象下面的叶对象的execute方法，所以我们的万能遥控器只需要一次操作，便可以依次完成关门、打开电脑、登录QQ这几件事。组合模式可以非常方便地描述对象部分—整体层次结构

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

这在实际开发中给客户带来相当大的方便，当我们往万能遥控器里面添加一个命令的时候，并不关心这个命令是宏命令还是普通子命令。这点对于我们不重要，我们只需要确定它是一个命令，并且这个命令拥有可执行的execute方法，那么这个命令就可以被添加进万能遥控器。

当宏命令和普通子命令接收到执行execute方法的请求时，宏命令和普通子命令都会做它们各自认为正确的事情。这些差异是隐藏在客户背后的，在客户看来，这种透明性可以让我们非常自由地扩展这个万能遥控器。

10.3 请求在树中传递的过程

在组合模式中，请示在树中传递过程总是遵循一种逻辑。

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

总而言之，如果子节点是叶对象，叶对象自身会处理这个请求，而如果子节点还是组合对象，请求会继续往下传递。叶对象下面不会再有其他子节点，一个叶对象就是树的这条枝叶的尽头，组合对象下面可能还会有子节点。请求从上到下没着树进行传递，直到树的尽头。

10.4 更强大的宏命令

目前的万能遥控器，包含了关门、开电脑、登录QQ这3个命令。现在我们需要一个“超级万能遥控器”可以控制家里所有的电器，这个遥控器拥有以下功能：

n   打开空调

n   打开电视和音响

n   关门、开电脑、登录QQ

首先在节点中放置一个按钮button来表示这个超级万能遥控器，超级万能遥控器上安装了一个宏命令，当执行宏命令时，会依次遍历执行它所包含的子命令：

[html] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <html>  
  2.  <body>  
  3.     <button  id=’button’>按我</button>  
  4.  </body>  
  5.   <script>  
  6.         
  7.    
  8. var MacroCommand = function(){  
  9.       return {  
  10.         commandsList:[],  
  11.         add:function(command){  
  12.           this.commandsList.push(command);  
  13.         },  
  14.         execute:function(){  
  15.             for(var i=0,command;command = this.commandsList[i++]){  
  16.              command.execute();  
  17.             }  
  18.         }  
  19.       }  
  20. };  
  21.    
  22. var openAcCommand = {  
  23.     execute:function(){  
  24.        console.log('打开空调')  
  25.     }  
  26. };  
  27.    
  28. //*******************  
  29. var openTvCommand={  
  30.    execute:function(){  
  31.       console.log('打开电视');  
  32.    }  
  33. }  
  34.    
  35. var openSoundCommand={  
  36.     execute:function(){  
  37.         console.log('打开音响');  
  38.     }  
  39. };  
  40.    
  41. var macroCommand1 = MacroCommand();  
  42. macroCommand1.add(openTvCommand);  
  43. macroCommand1.add(openSoundCommand);  
  44.    
  45. //**************关门、打开电脑和打登录QQ命令  
  46. var closeDoorCommand = {  
  47.     execute:function(){  
  48.        console.log('关门');  
  49.     }  
  50. };  
  51.    
  52. var openPcCommand = {  
  53.     execute:function(){  
  54.       console.log('开电脑');  
  55.     }  
  56. }  
  57.    
  58. var openQQCommand = {  
  59.    execute:function(){  
  60.       console.log('登录QQ');  
  61.    }  
  62. };  
  63.    
  64. var macroCommand2 = new MacroCommand();  
  65. macroCommand2.add(closeDoorCommand);  
  66. macroCommand2.add(openPcCommand);  
  67. macroCommand2.add(openQQCommand);  
  68.    
  69. //***********把所有命令组成一个超级命令  
  70. var macroCommand = new MacroCommand();  
  71. macroCommand.add(openAcCommand);  
  72. macroCommand.add(macroCommand1);  
  73. macroCommand.add(macroCommand2);  
  74. //**最后给遥控器绑定超级命令  
  75. var setCommand = (function(command){  
  76.   document.getElementById('button').onclick = function(){  
  77.       command.execute();  
  78.    }  
  79. })(macroCommand);  
  80.   </script>  
  81. </html>  

从这个例子中可以看到，基本对象可以被组合成更复杂的组合对象，组合对象又可以被组合，这样不断递归下去，这棵树的结构可以支持任意多的复杂度。在树最终被构造完成之后，让整颗树最终运转起来的步骤非常简单，只需要调用最上层对象的execute方法。而创建组合对象的程序员并不关心这些内在的细节，往这棵树里添加一些新的节点对象是非常容易的事情。

10.5 抽象类在组合模式中的作用

前端说到，组合模式最大的优点在于可以致地对待组合对象和基本对象。客户不需要知道当前处理的是宏命令还是普通命令，只要它是一个命令，并且有execute方法，这个命令就可以被添加到树中。

这种透明性带来的便利，在静态类型语言中体现得尤为明显。比如在Java中，实现组合模式的关键是Composite类和Leaf类都必须继承自一个Compenent抽象类既代表组合对象，又代表叶子对象，它也能够保证组合对象和叶对象拥有同样的名字的方法，从而可以对同一消息都做出反馈。组合对象和叶对象的具体类型被隐藏在Compenent抽象类身后。

针对Compenent抽象类来编写程序，客户操作的始终是Compenent对象，而不用去区分到底是组合对象还是叶对象。所以我们往同一个对象里的add方法，即可以添加组合对象，也可以添加叶对象如下:

 

java代码：

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. public abstract class Component {  
  2.   public  void add(Compenent child){}  
  3.   public  void remove(Compenent child){}  
  4. }  
  5.    
  6. public class  Composite  extends Component {  
  7.    public void add(Componentchild){};  
  8.    public voidremove(Component child){};  
  9. }  
  10.    
  11. public class Leaf extends Component{  
  12.   public void add(Component child){  
  13.    throw new UnsupportedOperationException() //叶子节点不能添加子节点  
  14.   }  
  15.   public void remove(Component child){}  
  16.   }  
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. }  
  2.    
  3. public class client(){  
  4.   public static void main(String args[]){  
  5.     Component root = new Composite();  
  6.     Component c1 = new Composite();  
  7.    
  8.     Component c2 = new Composite();  
  9.     Component leaf1 = new Leaf();  
  10.     Component leaf12= new Leaf();  
  11.     root.add(c1);  
  12.     root.add(c2);  
  13.     c1.add(leaf1);  
  14.     c2.add(leaf2);  
  15.    
  16.   }  
  17. }  

然而在JavaScript这种动态类型语言中，对象的多态性是与生俱来的，也没有编译器检查变量的类型，所以我们通常不会去模拟一个“怪异”的抽象类，javascript中实现组合模式的难点在于要保证组合对象和叶子对象拥有相同的方法，这通常需要用鸭子类型的思想对它们进行接口检查。

在js中实现组合模式，看起来缺乏一些严谨性，我们的代码算不上安全，但能更快速和自由地开发，这既是javascript的缺点，也是它的优点。

10.6 透明性带来的安全问题

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

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

[javascript] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. var MacroCommand = function(){  
  2.      return {  
  3.        commandsList:[],  
  4.        add:function(command){  
  5.          this.commandsList.push(command);  
  6.        },  
  7.        execute:function(){  
  8.            for(var i= 0,command;command = this.commandsList[i++]){  
  9.               command.execute();  
  10.            }  
  11.        }  
  12.      }  
  13. };  
  14.    
  15.    
  16. //*******************  
  17. var openTvCommand={  
  18.   execute:function(){  
  19.       console.log('打开电视');  
  20.    },  
  21.   add:function(){  
  22.     throw  new Error('叶对象不能添加子节点');  
  23.    }  
  24. }  
  25.    
  26. var macroCommand = MacroCommand();  
  27. macroCommand.add(openTvCommand);  
  28. openTvCommand.add(macroCommand); //throwerror  

 

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

文件和文件夹之间的关系，非常适合用组合模式来描述。文件夹里既可以包含文件，又可以包含其他文件夹，最终可能组合成一棵树，组合模式在文件夹的应用中有以下两层好处。

n   例如，我在同事的移动硬盘里找到一些电子书，我想把它们复制到F盘中的学习资料文件夹。在复制这些电子书的时候，我并不需要考虑这批文件的类型，不管它们是单独的电子书还是被放在了文件夹中。组合模式让Ctrl+V、Ctrl+C成为了一个统一的操作。

n   当我用杀毒软件扫描文件夹时。往往不会关心里面有多少文件和子文件夹，组合模式使得我们只需要操作最外层的文件夹时行扫描。

现在我们来编写代码，首先分别定义好文件夹Folder和文件File这两个类。见如下代码：

[javascript] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. var Folder = function(name){  
  2.    this.name = name;  
  3.    this.files=[];  
  4. }  
  5.    
  6. Folder.prototype.add = function(file){  
  7.   this.files.push(file);  
  8. }  
  9. Folder.prototype.scan = function(){  
  10.    console.log('开始扫描文件夹:'+this.name);  
  11.    for(var i= 0,file,files =this.files;file = files[i++];){  
  12.       file.scan();  
  13.    }  
  14. }  
  15.    
  16. /***** File ******/  
  17. var File = function(name){  
  18.    this.name = name;  
  19. }  
  20. File.prototype.add = function(){  
  21.    throw new Error('文件下面不能再添加文件');  
  22. }  
  23.    
  24. File.prototype.scan = function(){  
  25.   console.log('开始扫描文件:'+this.name);  
  26. }  

接下来创建一些文件和文件夹对象，并且让它们组合成一棵树，这棵树就是我们F盘里的现有文件目录结构。

 

[javascript] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. var folder = new Folder(‘学习资料’);  
  2. var folder1 = new Folder(‘javascript’);  
  3. var folder2 = new Folder(‘jQuery’);  
  4.    
  5. var file1 = new File(‘javascript设计模式与开发实践’);  
  6. var file2 = new File(‘精通jQuery’);  
  7. var file3 = new File(‘重构与模式’);  
  8.    
  9. folder1.add(file1);  
  10. folder2.add(file2);  
  11. folder.add(folder1);  
  12. folder.add(folder2);  
  13. folder.add(file3);  

现在的需求是把移动硬盘里的文件和文件夹都复制到这棵树中，假设我们已经得到了这些文件对象：

var folder3 = new Folder(‘Node.js’);

var file4 = new File(‘深入浅出Node.js’);

var file5 = new File(‘javascript语言精髓与编辑实践’);

接下来把这些文件添加到原有的树中：

folder.add(folder3);

folder.add(file5);

通过这个例子，我们再次看到客户是如何对待组合对象和叶对象。在添加一批文件的操作过程中，客户不用分辩它们到底是文件还是文件夹。新增加的文件和文件夹能够很容易地添加到原来的树结构中，和树中已有的对象一起工作。

10.8 一些值得注意的地方

在使用组合模式的时候，还有以下几个值得我们注意的地方。

1.    组合模式的树型结构容易让人误以为组合对象和叶对象是父子关系，这是不正确的。

组合模式就是一种HAS-A的关系。组合对象包含一组叶对象，但Leaf并不是Composite的子类。组合对象把请求委托给它所包含的所有叶对象，它们能够合作关键是拥有相同的接口。

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

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

比如公司要给全体员工发放元旦的过节费1000块，这个场景可以运用组合模式，但如果公司给今天过生日的员工发送一封生日祝福的邮件，组合模式就没有用武之地了，除非先把今天过生日的员工挑选出来。只用一致的方式对待列表中的每个叶子对象的时候，才适合使用组合模式。

3.    双向映射关系

发放过节费的通知步骤是从公司到各个部门，再到各个小组，最后到每个员工的邮箱里。这本身是一个组合模式的好例子，但要考虑的一种情况是，也许某些员工属于多个组织架构。比如某位架构师既隶属于开发组，又隶属于架构组，对象之间的关系并不是严格意义上的层次结构，在这种情况下，是不适合使用组合模式，该架构师很可能会收到两份过节费。

这种复合情况下我们必须给父节点和子节点建立双向映射关系，一个简单的方法是给小组和员工对象都增加集合来保存对方的引用。但是这种相互间的引用相当复杂，而且对象之间产生了过多的耦合性，修改或删除一个对象都变得困难，此时我们可以引入中介者模式来管理这些对象

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

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

10.9 引用父对象

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

现在来改写扫描文件夹的代码，使得在扫描整个文件夹之前，我们可以先移除某一个具体的文件。

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

[javascript] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. var Folder= function(name){  
  2.   this.name = name;  
  3.   this.files = [];  
  4.   this.parent = null;  
  5. }  
  6.    
  7. Folder.prototype.add = function(file){  
  8.  file.parent = this;  
  9.  this.files.push(file);  
  10. }  
  11. Folder.prototype.scan = function(){  
  12.   console.log(‘开始扫描文件夹：’+this.name;  
  13.    for(vari= 0,file,files = this.files;file = files[i++];){  
  14.       file.scan();  
  15.    }  
  16. }  

接下来增加Folder.prototype.remove方法，表示移除该文件夹:

[javascript] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. Folder.prototype.remove = function(){  
  2.   if(!this.parent){  
  3.      return ;  
  4.    }  
  5.   if(var files = this.parent.files,l=files.length-1;l>=0;l--){  
  6.    var file =files[l];  
  7.    if(file===this){  
  8.      files.splice(l,1);  
  9.    }  
  10.  }  
  11. }  

File类的实现基本一致：

[javascript] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. var File = function(name){  
  2.   this.name = name;  
  3.   this.parent = null;  
  4. }  
  5.    
  6. File.prototype.add = function(){  
  7.   throw new Error(‘不能添加在文件下面’);  
  8. }  
  9.    
  10. File.prototype.scan = function(){  
  11.    console.log(‘开始扫描文件：’+this.name);  
  12. }  
  13.    
  14. File.prototype.remove = function(){  
  15.  if(!this.parent){  
  16.     return ; //根结点或为游离节点  
  17.  }  
  18.  for(var files =this.parent.files,l = files.length-1;l>=0;l--){  
  19.    var file = files[l];  
  20.    if(file===this){  
  21.       files.splice(l,1);  
  22.    }  
  23.  }  
  24. }  

测试一下：

[javascript] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. var folder = new Folder(‘学习资料’);  
  2. var folder1 = new Folder(‘javascript’);  
  3. var file1 = new Folder(‘深入浅出Node.js’);  
  4. folder1.add(new Filde(‘javascript设计模式与开发实践’))  
  5. folder.add(folder1);  
  6. folder.add(file1);  
  7. foder1.remove();  
  8. folder.scan();  

10.10 何时使用

表示对象的部分—整体层次结构

客户希望统一对待树中的所有对象

0 0
h3c如何查看端口状态 h3c如何查看端口状态
原创粉丝点击
热门IT博客
kingwear智能手表软件kingwear智能手表软件
qq三国js技能介绍qq三国js技能介绍
淘宝开店实名认证失败
体重测试软件
海康威视网络设置方法
应用单片机转速测量仪
电信光纤网络不稳定
庆鸿慢走丝编程软件
p2p数据报告
idea使用手册java
dwg图纸打印软件
java 地图开发
淘宝秒杀技巧
app的编程语言
淘宝美工素材
json数据格式是什么
mac pro如何创建文件夹
深澜mac客户端下载
手机照片恢复软件推荐
如何修改linux配置文件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 笋焖肉 青椒塞肉的做法 豆干炒肉 肉酥 豆腐炒肉 什么炒肉 花菜炒肉的做法 白萝卜煲汤 家常炒肉 鲜茶树菇炒肉 笋子炒肉的做法 菜心炒肉 鲜菇炒肉 小葱炒肉 菠菜炒肉 油豆腐炒肉的做法 干香菇炒肉 黄焖鸡肉 笋尖炒肉 莴笋干炒肉 小青椒炒肉 蒜炒肉 芋艿炒肉 黄豆酱炒肉 青椒炒肉做法 豆豉炒肉 青豆炒肉的做法 快穿之白唯是小四 焖肉面 快穿飘洒女主的骨灰 焖肉面 焖 三汁焖鱼 三汁焖鱼的做法 焖锅做法 焖锅的做法 三汁焖锅酱料配方 三汁焖锅做法 鲶鱼焖锅 黄记煌三汁焖锅酱料配方明细 和福顺焖锅连锁店 家庭简单焖锅做法 三汁焖锅家常做法

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里