composite模式

场景： （1）父部门->子部门->子部门 （2）我们要对部门树，删除一个父部门以及其下所有的子部门

1.常规

  1. package com.example.demo.pattern.composite;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. /**
  6.  * @author chenchao
  7.  * @date 2021/11/9
  8.  */
  9. public class WithoutCompositePatternDemo {
  11.     public static void main(String[] args) {
  12.         Department leafDept1 = new Department("叶子部门1"); 
  13.         Department leafDept2 = new Department("叶子部门2");
  14.         Department leafDept3 = new Department("叶子部门3"); 
  16.         Department subDept1 = new Department("子部门1");
  17.         subDept1.getChildren().add(leafDept1);
  18.         subDept1.getChildren().add(leafDept2);
  20.         Department subDept2 = new Department("子部门2"); 
  21.         subDept2.getChildren().add(leafDept3);
  23.         Department parentDept = new Department("父部门");
  24.         parentDept.getChildren().add(subDept1);
  25.         parentDept.getChildren().add(subDept2);
  27.         for(Department subDept : parentDept.getChildren()) {
  28.             if(subDept.getChildren().size() > 0) {
  29.                 for(Department leafDept : subDept.getChildren()) {
  30.                     leafDept.remove();
  31.                 }
  32.             }
  33.             subDept.remove();
  34.         }
  35.         parentDept.remove();
  37.         // 问题：对层级数据的操作，很恶心，很不方便，需要手工编写大量的屎一样的代码
  38.         // 平时，屎一样代码的典型特征，四五个，六七个，for if else，嵌套，嵌套的非常深，1年后，团队里没人看得懂你写的代码
  39.     }
  41.     public static class Department {
  43.         private String name;
  44.         private List<Department> children = new ArrayList<Department>();
  46.         public Department(String name) {
  47.             super();
  48.             this.name = name;
  49.         }
  51.         public String getName() {
  52.             return name;
  53.         }
  54.         public void setName(String name) {
  55.             this.name = name;
  56.         }
  57.         public List<Department> getChildren() {
  58.             return children;
  59.         }
  60.         public void setChildren(List<Department> children) {
  61.             this.children = children;
  62.         }
  64.         public void remove() {
  65.             System.out.println("删除部门【" + name + "】");  
  66.         }
  68.     }
  70. }

2.组合模式

  1. package com.example.demo.pattern.composite;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. /**
  6.  * @author chenchao
  7.  * @date 2021/11/9
  8.  */
  9. public class CompositePatternDemo {
  11.     public static void main(String[] args) {
  12.         Department leafDept1 = new Department("叶子部门1"); 
  13.         Department leafDept2 = new Department("叶子部门2");
  14.         Department leafDept3 = new Department("叶子部门3"); 
  16.         Department subDept1 = new Department("子部门1");
  17.         subDept1.getChildren().add(leafDept1);
  18.         subDept1.getChildren().add(leafDept2);
  20.         Department subDept2 = new Department("子部门2"); 
  21.         subDept2.getChildren().add(leafDept3);
  23.         Department parentDept = new Department("父部门");
  24.         parentDept.getChildren().add(subDept1);
  25.         parentDept.getChildren().add(subDept2);
  27.         parentDept.remove();
  29.         // 组合模式的第一要义，就是将树形结构的数据，用一个类，或者少数一两个类，就可以拼装成一棵树的形状
  30.         // 组合模式的第二要义，就是直接对一个父级的数据执行某个操作，这个操作会直接递归调用所有下层的子数据的相关操作
  31.         // 通过这个树形结构自己递归自己的方式，就将对一棵树的操作，完美的执行了
  32.         // 好处，就是对树形数据的操作，不需要调用方组织复杂的屎一样的if for的代码，去执行
  33.         // 外部要操作一颗树，直接对树的父级节点，调用一个操作，这颗树自己就递归着把事儿给干完了
  35.         // 我跟大家这么说，武侠小说
  36.         // 比较low的那种练武的人，就是只会照搬招式，一板一眼的跟着练
  37.         // 然后真正的顶尖高手，到了最后，理解了武侠秘籍的思想，都是无招胜有招
  39.         // 设计模式，重点，是思想，理解了思想，随便招式你怎么出，只要能将思想运用到实际业务场景中
  40.         // 避免写出屎一样的代码，你就成功了
  41.         // 如果你照搬设计模式去写，反而增加代码的复杂度
  42.     }
  44.     public static class Department {
  46.         private String name;
  47.         private List<Department> children = new ArrayList<Department>();
  49.         public Department(String name) {
  50.             super();
  51.             this.name = name;
  52.         }
  54.         public String getName() {
  55.             return name;
  56.         }
  57.         public void setName(String name) {
  58.             this.name = name;
  59.         }
  60.         public List<Department> getChildren() {
  61.             return children;
  62.         }
  63.         public void setChildren(List<Department> children) {
  64.             this.children = children;
  65.         }
  67.         public void remove() {
  68.             if(children.size() > 0) {
  69.                 for(Department child : children) {
  70.                     child.remove();
  71.                 }
  72.             }
  73.             System.out.println("删除部门【" + name + "】");  
  74.         }
  76.     }
  78. }

3.说明

组合模式非常适用于有较多父子层级关系的那种场景，比如部门树的递归删除，或者是文件树的递归删除之类的场景。这个还是比较好模拟的，我们会在电商系统的权限那块给大家演示，比如删除一个父权限，就要级联递归删除所有的子权限，这个时候可以对组合模式做一点变种，自动从根权限开始，递归查询所有层级的子权限，然后一直到叶子节点的权限，从叶子节点开始删除