设计模式之Composite

在实际项目中，我们总是会遇到对一组对象进行统一的操作，如果使用常规的做法我们得一个个的对这些对象进行操作。这样的实现有个缺点缺少准确性，因为这些对象可能又含有其他对象，而有些对象又可能是单个对象。那么对我们整体来操作带来困难。所以我们如果能从更加抽象的角度定义出这些对象的公共特性，然后定义即适合对象群和单个对象个体的通用类型的话，我们就可以利用统一的接口来处理单个对象以及对象组合。

下面的代码最能说明Composite模式的意图：

 package test.spring; /** * <p>Class Name: TestCompositePattern</p> * <p>Description: 让用户能够统一的接口处理单个对象以及对象组合</p> * <p>Sample: 该类的典型使用方法和用例</p> * <p>Author: liuming</p> * <p>Date: 2009-2-27</p>CompositePattern * <p>Modified History: 修改记录，格式(Name) (Version) (Date) (Reason & Contents)</p> */ import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class TestCompositePattern { public static void main(String []args){ ContextBase context = new ContextBase(); StringBuffer str = new StringBuffer(); str.append("execute command have "); context.put("Command", str); ChainBase chain = new ChainBase(); ChainBase other = new OtherChain(); // other.addCommand(new CommandD()); other.addCommand(new CommandE()); System.out.println("result lenght:"+other.getCommandLength()); chain.addCommand(new CommandA()); chain.addCommand(new CommandB()); chain.addCommand(new CommandC()); //ChainBase本身就为Command类型 chain.addCommand(other); chain.execute(context); System.out.println("result:"+context.get("Command")); } } //定义组合的公共特性 interface Command { boolean execute(Context context); } //定义责任链接口 interface Chain extends Command{ boolean addCommand(Command command); int getCommandLength(); } class ChainBase implements Chain{ protected Command [] commands = new Command [0]; // public boolean addCommand(Command command) { // TODO Auto-generated method stub if (command == null) { throw new IllegalArgumentException(); } Command[] results = new Command[commands.length + 1]; System.arraycopy(commands, 0, results, 0, commands.length); results[commands.length] = command; commands = results; return false; } @Override public boolean execute(Context context) { // TODO Auto-generated method stub if(context ==null){ throw new IllegalArgumentException(); } boolean flag ; Exception ex =null; int i = 0 ; int n = commands.length; for(i=0;i<n;i++){ try{ //遍历所有的对象组合 flag = commands[i].execute(context); if(flag){ System.out.println("flag is true"); break; } }catch(Exception e){ System.out.println("Exception is run"); ex = e; break; } } return false; } @Override public int getCommandLength() { // TODO Auto-generated method stub return commands.length; } } interface Context extends Map{ } class ContextBase extends HashMap implements Context{ } class CommandA implements Command{ @Override public boolean execute(Context context) { StringBuffer str = (StringBuffer)context.get("Command"); str = str.append("CommandA"); return false; } } class CommandB implements Command{ @Override public boolean execute(Context context) { StringBuffer str = (StringBuffer)context.get("Command"); str = str.append(",CommandB,"); return false; } } class CommandC implements Command{ @Override public boolean execute(Context context) { StringBuffer str = (StringBuffer)context.get("Command"); str = str.append("CommandC"); return false; } } class OtherChain extends ChainBase{ } class CommandD implements Command{ @Override public boolean execute(Context context) { StringBuffer str = (StringBuffer)context.get("Command"); str = str.append(",OtherChain's CommandD"); return false; } } class CommandE implements Command{ @Override public boolean execute(Context context) { StringBuffer str = (StringBuffer)context.get("Command"); str = str.append(",OtherChain's CommandE"); return false; } }

 上述代码的执行类图为：

 

       从类图中我们可以很清楚看到Command 类和Chain类的关系就是组合模式（Composite pattern）[GoF]的例子：Chain不仅由多个Command组成，而且自己也是Command。这使你可以非常简单的将单个命令（Command）替换成由多个命令（Command）组成的链（Chain）。这个由Command对象唯一操作定义的方法代表了一个直接的命令：
  public boolean execute(Context context);

   所以我们在配置文件里面就可以配置出相当灵活的一个处理链流程，如父链嵌套子链，子链在嵌套子链等等。 而所有对Command调用并处理都来自ChainBase这个类的excute()这个方法，它将调用所有在chain链中的Command类，如果其中一个还回得是true，则跳出链结构。

代码程序执行结果为：

result lenght:2
result:execute command have CommandA,CommandB,CommandC,OtherChain's CommandD,OtherChain's CommandE

    从结果看我们发现执行了CommandA,CommandB,CommandC都得到执行，而做为子链的OtherChain和它的command都得到了执行。

  这样我们就用统一的接口处理了单个对象及其对象组合的目标便达到了，这也是Composite模式的精髓所在。

    好了，关于Composite模式介绍到这里，下一篇我将介绍Bridge模式。