JavaScript设计模式之组合模式
一个公司，可能分为很多个事业部，然后事业部又分为不同的部门。每个部门可能又分为不同的方向，每个方向又由不同的项目组组成。在程序设计中，也有一些和“事物是由相似的子事物构成”类似的思想。组合模式就是用小的子对象来构建更大的对象，而这些小的子对象本身也许是由更小的“孙对象”构成的。
回顾在《命令模式》中讲到的宏命令实现视频上传流程管理。
const uploadVideo = {
upload() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('upload');
resolve('finished')
}, 3000);
});
},
decode() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('decode');
resolve('finished')
}, 3000);
});
},
approve() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('approve');
resolve('finished')
}, 3000);
});
},
publish() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('publish');
resolve('finished');
}, 3000);
});
}
}
const makeCommand = (receiver, action) => {
return {
excute: receiver[action]
};
}
const setCommand = (command) => command.excute();
const uploadCommand = makeCommand(uploadVideo, 'upload');
const decodeCommand = makeCommand(uploadVideo, 'decode');
const approveCommand = makeCommand(uploadVideo, 'approve');
const publishCommand = makeCommand(uploadVideo, 'publish');
const commandList = [uploadCommand ,decodeCommand,approveCommand,publishCommand];
// 宏命令
class MacroCommand {
constructor(cmdList){
this.cmdList=cmdList;
}
// 压栈
add(cmd){
this.cmdList.push(cmd);
}
// 出栈
del(){
this.cmdList.pop();
}
// 运行宏命令
async excute(i){
if(i<this.cmdList.length){
let ret=await setCommand(this.cmdList[i]);
if(ret=='finished'){
return this.excute(i+1);
}
}
return true;
}
}
const mc=new MacroCommand(commandList);
mc.excute(0)宏命令都包括了一组子命令队列cmdList和自己的excute执行方法。mc表现的很像一个命令，甚至也可以作为命令使用。在结构上，称之为组合对象，诸如上传、转码审核等，都是它的叶对象。在mc.excute()方法中，并不会实际执行子命令。它只负责遍历迭代。而把真正执行的事情委托给了 makeCommand，让它去"代理"自己执行子命令的excute方法。本身并不负责任何业务逻辑。
组合模式的优势
首先，组合模式层次清晰地表述了命令之间的树形结构关系，以电饭煲煮饭为例：
组合模式提供了一种遍历树形结构的方案，通过调用组合对象的execute方法，程序会递归调用组合对象下面的叶对象的execute方法，所以我们的只要点击一个按钮只需要一次操作，便能依次完成多件事情。组合模式可以非常方便地描述对象部分整体层次结构。
其次，编程者可以充分利用对象多态的优点。一视同仁地处理不同的宏命令。而不需去关心业务上的东西。
"自然选择，前进四！" —— 章北海
《三体》中海军出身的章北海，在冬眠几个世纪后，能够以海军术语指导最新技术星际飞船"自然选择号"行动，并不是一件多么难以想象的事情——只要有组合命令。
请求在树的传递过程
在一个组合模式的命令体系中，请求总是递归进行的。从顶层节点开始遍历。
客户只要请求顶层的组合对象(比如"前进四")，请求就会沿着树的左叉遍历传递。
为了说明这个问题，我们继续来复杂化视频上传的问题，假如视频的审核需要做更多的区分，包括"运营方（operator）审核"和"广电总局（SARFT）审核"。那么审核(approve)既是一个叶对象，也是一个宏命令。
// 审核流程
const approve={
operator() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('operator approved');
resolve('finished')
}, 1000);
});
},
sarft(){
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('SARFT approved');
resolve('finished')
}, 2000);
});
}
}
// 普通上传
const uploadVideo = {
upload() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('upload');
resolve('finished')
}, 1000);
});
},
decode() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('decode');
resolve('finished')
}, 1000);
});
},
approve,
publish() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('publish');
resolve('finished');
}, 1000);
});
}
}
const makeCommand = (receiver, action) => {
if(receiver[action]){
return {
excute: receiver[action]
};
}else{
return receiver;
}
}
class MacroCommand {
constructor(cmdList){
this.cmdList=cmdList;
}
// 运行宏命令
async excute(i){
i=i?i:0;
if(i<this.cmdList.length){
let ret=await setCommand(this.cmdList[i]);
if(ret=='finished'){
await this.excute(i+1);
}
}
return 'finished';
}
}
const setCommand = async (command) => await command.excute(0);
const operatorCommand =makeCommand(uploadVideo.approve,'operator');
const sarftCommand = makeCommand(uploadVideo.approve, 'sarft');
const approveCmdList=[operatorCommand,sarftCommand];
const approveCommand= makeCommand(new MacroCommand(approveCmdList));
const uploadCommand = makeCommand(uploadVideo, 'upload');
const decodeCommand = makeCommand(uploadVideo, 'decode');
const publishCommand = makeCommand(uploadVideo, 'publish');
const commandList = [uploadCommand ,decodeCommand,approveCommand,publishCommand];
const mc=new MacroCommand(commandList);
mc.excute(0)执行顺序为 上传-解码-运营商审核-广电总局审核：
简化流程
但是生成命令的方法还是有些麻烦。该过程暴露了太多细节。考虑定义一个生成命令的方法，彻底撕离业务逻辑：
class MacroCommand {
constructor(cmdList){
this.cmdList=this.makeCmdList(cmdList);
}
makeCommand(receiver, action){
if(receiver[action]){
return {
excute: receiver[action]
};
}else{
return receiver;
}
}
makeCmdList(obj){
return Object.keys(obj).map((key,index)=>{
let ret=null;
switch (typeof obj[key]) {
case 'function':
ret=this.makeCommand(obj,key);
break;
case 'object':
ret =new MacroCommand(obj[key])
default:
break;
}
return ret;
});
}
async setCommand(command){
return await command.excute(0)
}
// 运行宏命令
async excute(i){
i=i?i:0;
if(i<this.cmdList.length){
let ret=await this.setCommand(this.cmdList[i]);
if(ret=='finished'){
await this.excute(i+1);
}
}
return 'finished';
}
}
const mc=new MacroCommand(uploadVideo);
mc.excute() delete uploadVideo.publish;
uploadVideo.aaa=()=>{
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('aaa');
resolve('finished');
}, 1000);
});
}
const mc=new MacroCommand(uploadVideo);
mc.excute()
//upload -> decode -> operator approved -> SARFT approved -> aaa这样，我在定义了方法结构的同时，就定义了执行顺序。
从这个例子中可以看到，基本对象可以被组合成更复杂的组合对象，组合对象又可以被组合，这样不断递归下去，这棵树的结构可以支持任意多的复杂度。在树最终被构造完成之后，让整颗树最终运转起来的步骤非常简单，只需要调用最上层对象的execute方法。每当对最上层的对象进行一次请求时，实际上是在对整个树进行深度优先的搜索，而创建组合对象的程序员并不关心这些内在的细节，往这棵树里面添加一些新的节点对象是非常容易的事情。
注意事项
在使用组合模式的时候，还有以下几个值得我们注意的地方。
- 组合模式不是父子关系（ISA），是一种HASA（聚合）的关系。组合对象包含一组叶对象，但Leaf并不是Composite的子类。组合对象只是把请求委托给它所包含的所有叶对象，它们能够合作的关键是拥有相同的接口。为了方便描述，本章有时候把上下级对象称为父子节点，但大家要知道，它们并非真正意义上的父子关系。
- 对叶对象操作的一致性：组合模式除了要求组合对象和叶对象拥有相同的接口之外，还有一个必要条件，就是对一组叶对象的操作必须具有一致性。
- 双向映射关系发放过节费的通知步骤是从公司到各个部门，再到各个小组，最后到每个员工的邮箱里。这本身是一个组合模式的好例子，但要考虑的一种情况是，也许某些员工属于多个组织架构。比如某位架构师既隶属于开发组，又隶属于架构组，对象之间的关系并不是严格意义上的层次结构，在这种情况下，是不适合使用组合模式的，该架构师很可能会收到两份过节费。这种复合情况下我们必须给父节点和子节点建立双向映射关系，一个简单的方法是给小组和员工对象都增加集合来保存对方的引用。但是这种相互间的引用相当复杂，而且对象之间产生了过多的耦合性，修改或者删除一个对象都变得困难，此时我们可以引入中介者模式来管理这些对象。
- .用职责链模式提高组合模式性能：在组合模式中，如果树的结构比较复杂，节点数量很多，在遍历树的过程中，性能方面也许表现得不够理想。有时候我们确实可以借助一些技巧，在实际操作中避免遍历整棵树，有一种现成的方案是借助职责链。职责链模式一般需要我们手动去设置链条，但在组合模式中，父对象和子对象之间实际上形成了天然的职责链。让请求顺着链条从父对象往子对象传递，或者是反过来从子对象往父对象传递，直到遇到可以处理该请求的对象为止，这也是职责链模式的经典运用场景之一。
适用场景
表示对象的部分整体层次结构。组合模式可以方便地构造一棵树来表示对象的部分整体结构。特别是我们在开发期间不确定这棵树到底存在多少层次的时候。在树的构造最终完成之后，只需要通过请求树的最顶层对象，便能对整棵树做统一的操作。在组合模式中增加和删除树的节点非常方便，并且符合开放封闭原则。
户希望统一对待树中的所有对象。组合模式使客户可以忽略组合对象和叶对象的区别，客户在面对这棵树的时候，不用关心当前正在处理的对象是组合对象还是叶对象，也就不用写一堆if、else语句来分别处理它们。组合对象和叶对象会各自做自己正确的事情，这是组合模式最重要的能力。