设计模式之组合模式

组合模式

定义：又名部分整体模式，是用于把一组相似的对象当作一个单一的对象，组合模式依据属性结构来组合对象，用来表示部分以及整体层次，这种类型的设计模式属于结构型模式。他创建了对象组的树形结构

组合模式主要角色如下所示：

抽象根节点角色：定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性

树枝节点：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构

叶子节点：叶子节点，其下无分支，是系统层次遍历的最小单位。

---

案例实现

在访问一些管理系统时，经常可以看到类似的菜单，一个菜单可以包含菜单项（菜单项是指不在包含其他内容的菜单条目），也可以包含带有其他菜单项的菜单，因此使用组合模式来描述菜单很恰当，我们的需求是针对一个菜单，打印其包含的所有菜单以及菜单项名称。

案例类图

代码实现：

定义抽象根节点，抽取菜单以及菜单菜单项的共同功能

public abstract class MenuComponent {
//菜单名称
protected String name;

//菜单级别
protected  Integer level;

public MenuComponent(String name,Integer level){
  this.name=name;
  this.level=level;
}

/**
   * 添加子菜单
   */
  public void add(MenuComponent menuComponent){
      throw new UnsupportedOperationException("菜单项不支持使用添加功能");
  }

  /**
   * 根索引移除子菜单
   * @param index 菜单索引
   */
  public void remove(int index){
      throw new UnsupportedOperationException("菜单项不支持使用删除功能");
  }

  /**
   * 获取当前菜单或菜单项名称
   * @return 返回名称
   */
  public String getName(){
      return this.name;
  }

  /**
   * 根据索引获取子菜单
   * @param index 子菜单索引
   * @return 子菜单
   */
  public MenuComponent getChild(int index){
      throw new UnsupportedOperationException("菜单项不支持使用返回子菜单功能");
  }

  /**
   * 如果是菜单项则打印所有菜子菜单及其菜单项名称，如果是菜单项则打印当前菜单项名称
   */
  public abstract void print();
}

定义树枝节点，Menu类，重写父类中定义的添加，删除，获取子菜单功能

public class Menu extends MenuComponent{
  //用于存储该菜单下的子菜单或者菜单项
  private final List<MenuComponent> menuComponentList=new ArrayList<>();

  public Menu(String name,Integer level){
      super(name, level);
  }

  @Override
  public void add(MenuComponent menuComponent) {
      this.menuComponentList.add(menuComponent);
  }

  @Override
  public void remove(int index) {
      this.menuComponentList.remove(index);
  }

  @Override
  public MenuComponent getChild(int index) {
      return menuComponentList.get(index);
  }

  @Override
  public void print() {
      for(int i=1;i<level;i++){
          System.out.print("--");
      }
      System.out.println(this.getName());
      //递归遍历打印该菜单下的所有子项
      for(MenuComponent menuComponent:menuComponentList){
          menuComponent.print();
      }
  }
}

当以叶子节点，MenuItem,因为是叶子节点所有最基本的单元，所以不存在添加和删除功能

public class MenuItem extends MenuComponent{

  public MenuItem(String name, Integer level) {
      super(name, level);
  }

  @Override
  public void print() {
      for(int i=1;i<level;i++){
          System.out.print("--");
      }
      System.out.println(super.getName());
  }
}

测试类测试组合模式

public class Test {
  public static void main(String[] args) {
      Menu menu1=new Menu("菜单管理",2);
      MenuItem menu1Item2=new MenuItem("展开菜单",3);
      MenuItem menu1Item3=new MenuItem("编辑菜单",3);
      MenuItem menu1Item4=new MenuItem("删除菜单",3);
      MenuItem menu1Item5=new MenuItem("新增菜单",3);
      MenuItem menu1Item1=new MenuItem("页面访问",3);
      menu1.add(menu1Item1);
      menu1.add(menu1Item2);
      menu1.add(menu1Item3);
      menu1.add(menu1Item4);
      menu1.add(menu1Item5);

      Menu menu2=new Menu("权限管理",2);
      MenuItem menu2Item1=new MenuItem("页面访问",3);
      MenuItem menu2Item2=new MenuItem("展开菜单",3);
      menu2.add(menu2Item1);
      menu2.add(menu2Item2);

      Menu menu3=new Menu("角色管理",2);
      MenuItem menu3Item1=new MenuItem("页面访问",3);
      MenuItem menu3Item2=new MenuItem("新增角色",3);
      MenuItem menu3Item3=new MenuItem("修改角色",3);
      menu3.add(menu3Item1);
      menu3.add(menu3Item2);
      menu3.add(menu3Item3);

      Menu menu=new Menu("系统管理",1);
      menu.add(menu1);
      menu.add(menu2);
      menu.add(menu3);

      menu.print();

      System.out.println("====================");
      Menu childMenu= (Menu) menu.getChild(1);
      childMenu.print();
  }
}

---

组合模式分类

在使用组合模式时，根据抽象构件类的定义形式，我们可以将组合模式分为透明组合模式和安全组合模式两种形式。

透明组合模式

透明组合模式中，抽象根节点角色中生命了所有用于管理成员对象的方法，比如在案例中MenuComponent声明了add，rmove，getChild方法，这样做的好处是确保了所有构建类都有相同的接口，透明组合模式也是组合模式的标准形式

透明组合模式的缺点是不够安全，因为叶子对象和容器对象本质上是有区别的，叶子对象不可能有下一层的对象，即不包含成员对象，因此为其提供add，remove，getChild方法是没有意义的，这样在编译阶段不会出错，但在运行阶段如果调用这些方法可能会出错

安全组合模式

在安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点Menu类中声明并实现这些方法，安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中哪些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别的对待叶子构件和容器构件

---

组合模式优点

组合模式可以清除的定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制

客户端可以一致的使用一个组合结构或其中的单个对象，不必关心处理的是单个对象还是整个结构，简化了客户端代码

在组合模式中增加新的树枝节点或叶子节点都很方便，无须对现有类库进行任何修改，符合开闭原则

组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子节点和树枝节点的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单

---

使用场景

组合模式正是应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方，比如：文件目录显示，多级目录呈现等树形结构数据的操作。