• 设计模式（15）组合模式

    一、介绍：

    1、定义：组合多个对象形成树形结构以表示“整体-部分”的关系的层次结构。组合模式对叶子节点和容器节点的处理具有一致性，又称为整体-部分模式。

    2、优缺点：

    优点：

    （1）高层模块调用简单：组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码。

    （2）节点自由增加：更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码。

    缺点：

    （1）在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

    （2）设计较复杂，客户端需要花更多时间理清类之间的层次关系。

    （3）不容易限制容器中的构件。

    3、组成：

    （1）抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。（总的抽象类或接口，定义一些通用的方法，比如新增、删除）。

    （2）树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。

    （3）树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。

    1. // 定义抽象构件
    2. public abstract class Component {
    3.     protected String name;
    4.  
    5.     public Component(String name) {
    6.         this.name = name;
    7.     }
    8.  
    9.     public abstract void add(Component component);
    10.  
    11.     public abstract void remove(Component component);
    12.  
    13.     public abstract void display();
    14. }
    15.  
    16. // 定义叶子构件
    17. public class Leaf extends Component {
    18.     public Leaf(String name) {
    19.         super(name);
    20.     }
    21.  
    22.     @Override
    23.     public void add(Component component) {
    24.         System.out.println("Cannot add to a leaf");
    25.     }
    26.  
    27.     @Override
    28.     public void remove(Component component) {
    29.         System.out.println("Cannot remove from a leaf");
    30.     }
    31.  
    32.     @Override
    33.     public void display() {
    34.         System.out.println("Leaf: " + name);
    35.     }
    36. }
    37.  
    38. // 定义容器构件
    39. public class Composite extends Component {
    40.     private List children = new ArrayList<>();
    41.  
    42.     public Composite(String name) {
    43.         super(name);
    44.     }
    45.  
    46.     @Override
    47.     public void add(Component component) {
    48.         children.add(component);
    49.     }
    50.  
    51.     @Override
    52.     public void remove(Component component) {
    53.         children.remove(component);
    54.     }
    55.  
    56.     @Override
    57.     public void display() {
    58.         System.out.println("Composite: " + name);
    59.         for (Component component : children) {
    60.             component.display();
    61.         }
    62.     }
    63. }
    64.  
    65. // 客户端代码
    66. public class Client {
    67.     public static void main(String[] args) {
    68.         Component root = new Composite("root");
    69.         Component leaf1 = new Leaf("leaf1");
    70.         Component leaf2 = new Leaf("leaf2");
    71.         Component composite1 = new Composite("composite1");
    72.         Component leaf3 = new Leaf("leaf3");
    73.         Component composite2 = new Composite("composite2");
    74.  
    75.         root.add(leaf1);
    76.         root.add(leaf2);
    77.         root.add(composite1);
    78.         composite1.add(leaf3);
    79.         composite1.add(composite2);
    80.  
    81.         root.display();
    82.     }
    83. }

    4、应用场景：部分、整体场景，如树形菜单，文件、文件夹的管理。

    二、demo：

    1、菜单：

    （1）数据库model

    1. public class MenuDTO {
    2.     private String menuName;
    3.     private String menuCode;
    4.     private String parentMenuCode;
    5.     public MenuDTO(String menuName,String menuCode,String parentMenuCode){
    6.         this.menuCode = menuCode;
    7.         this.menuName = menuName;
    8.         this.parentMenuCode = parentMenuCode;
    9.     }
    10.  
    11.    /**省略所有set、get芳芳*/
    12. }

     抽象构件Component

    1. public abstract class MenuComponent extends MenuDTO {
    2.  
    3.     MenuComponent(String menuName, String menuCode,String parentMenuCode) {
    4.         super(menuName, menuCode,parentMenuCode);
    5.     }
    6.  
    7.     void addMenu(MenuComponent component){}
    8.  
    9.     void removeMenu(MenuComponent component){}
    10. }

    （2）树枝构件（Composite）： 

    1. public class MenuVO extends MenuComponent {
    2.  
    3.     private List<MenuComponent> children = new ArrayList<>();
    4.  
    5.     MenuVO(String menuName, String menuCode,String parentMenuCode) {
    6.         super(menuName, menuCode,parentMenuCode);
    7.     }
    8.  
    9.     @Override
    10.     void addMenu(MenuComponent component) {
    11.         children.add(component);
    12.     }
    13.  
    14.     @Override
    15.     void removeMenu(MenuComponent component) {
    16.     }
    17. }

    （3）树叶

    1. public class MenuLeaf extends MenuComponent {
    2.     MenuLeaf(String menuName, String menuCode,String parentMenuCode) {
    3.         super(menuName, menuCode,parentMenuCode);
    4.     }
    5.  
    6.     @Override
    7.     void addMenu(MenuComponent component) {
    8.         super.addMenu(component);
    9.     }
    10.  
    11.     @Override
    12.     void removeMenu(MenuComponent component) {
    13.         super.removeMenu(component);
    14.     }
    15. }

     客户端：

    1. public class Test {
    2.     public static void main(String args[]) {
    3.         MenuComponent menuVOS = listMenus();
    4.         System.out.println(menuVOS);
    5.     }
    6.  
    7.     public static MenuComponent listMenus(){
    8.         //模拟数据库查询，查询所有一级菜单(menu_type = 1)、二级菜单(menu_type = 2)
    9.         List<MenuDTO> firstMenus = new ArrayList<>();
    10.         MenuDTO menuDTO = new MenuDTO("菜单1","cd1","root");
    11.         firstMenus.add(menuDTO);
    12.         menuDTO = new MenuDTO("菜单2","cd2","root");
    13.         firstMenus.add(menuDTO);
    14.         menuDTO = new MenuDTO("菜单3","cd3","root");
    15.         firstMenus.add(menuDTO);
    16.  
    17.         List<MenuDTO> secondMenus = new ArrayList<>();
    18.         menuDTO = new MenuDTO("菜单1-1","cd1-1","cd1");
    19.         secondMenus.add(menuDTO);
    20.         menuDTO = new MenuDTO("菜单1-2","cd1-2","cd1");
    21.         secondMenus.add(menuDTO);
    22.         menuDTO = new MenuDTO("菜单2-1","cd2-1","cd2");
    23.         secondMenus.add(menuDTO);
    24.         Map<String, List<MenuDTO>> childMenuMap = secondMenus.stream().collect(Collectors.groupingBy(MenuDTO::getParentMenuCode));
    25.         /**实现
    26.          * 根节点
    27.          * 菜单1  菜单2 菜单3
    28.          *菜单1-1 菜单1-2 菜单2-1
    29.          * */
    30.         //1、定义根节点
    31.         MenuComponent root = new MenuVO("根节点","root",null);
    32.         //2、处理菜单层级
    33.         for(MenuDTO  firstMenu : firstMenus){
    34.             //二级菜单
    35.             MenuComponent firstMenuVO = new MenuVO(firstMenu.getMenuName(),firstMenu.getMenuCode(),firstMenu.getParentMenuCode());
    36.             //三级菜单
    37.             List<MenuDTO> secondMenuVOs = childMenuMap.get(firstMenu.getMenuCode());
    38.             if(!CollectionUtils.isEmpty(secondMenuVOs)){
    39.                 for(MenuDTO secondMenu : secondMenuVOs){
    40.                     MenuComponent secondMenuVO = new MenuVO(secondMenu.getMenuName(),secondMenu.getMenuCode(),secondMenu.getParentMenuCode());
    41.                     firstMenuVO.addMenu(secondMenuVO);
    42.                 }
    43.             }
    44.             root.addMenu(firstMenuVO);
    45.         }
    46.         return root;
    47.     }
    48. }

    运行main方法 

    2、文件夹：

    （1）抽象构件Component

    1. public abstract class FileComponent {
    2.     //文件名称
    3.     protected String name;
    4.     //文件的层级 1 一级目录 2 二级目录 ...
    5.     protected Integer level;
    6.     //文件的类型 1 文件夹 2文件
    7.     protected Integer type;
    8.     //添加子文件/文件夹
    9.     public abstract void add(FileComponent fileComponent);
    10.     //移除子文件/文件夹
    11.     public abstract void remove(FileComponent fileComponent);
    12.     //获取指定的子文件/文件夹
    13.     public abstract FileComponent getChild(int index);
    14.     //打印子 子文件/子文件夹 名称的方法
    15.     public abstract void print();
    16. }

    （2）树枝构件（Composite）

    1. public class FileFolder extends FileComponent{
    2.     //文件夹可以有多个子文件夹或者子文件
    3.     private  List<FileComponent> fileComponentList;
    4.     
    5.     public FileFolder(String name, Integer level, Integer type) {
    6.         this.name = name;
    7.         this.level = level;
    8.         this.type = type;
    9.         this.fileComponentList = new ArrayList<>();
    10.     }
    11.     @Override
    12.     public void add(FileComponent fileComponent) {
    13.         fileComponentList.add(fileComponent);
    14.     }
    15.     @Override
    16.     public void remove(FileComponent fileComponent) {
    17.         fileComponentList.remove(fileComponent);
    18.     }
    19.     @Override
    20.     public FileComponent getChild(int index) {
    21.         return fileComponentList.get(index);
    22.     }
    23.     @Override
    24.     public void print() {
    25.         //打印菜单名称
    26.         for (int i = 0; i < level; i++) {
    27.             System.out.print("\t");
    28.         }
    29.         System.out.println(name);
    30.         //打印子菜单或者子菜单项名称
    31.         for (FileComponent component : fileComponentList) {
    32.             component.print();
    33.         }
    34.     }
    35. }

    （3）树叶构件（Leaf）

    1. public class FileItem extends FileComponent{
    2.     public FileItem(String name, Integer level, Integer type) {
    3.         this.name = name;
    4.         this.level = level;
    5.         this.type = type;
    6.     }
    7.     @Override
    8.     public void add(FileComponent fileComponent) {
    9.  
    10.     }
    11.     @Override
    12.     public void remove(FileComponent fileComponent) {
    13.  
    14.     }
    15.     @Override
    16.     public FileComponent getChild(int index) {
    17.         return null;
    18.     }
    19.     @Override
    20.     public void print() {
    21.         //打印文件的名称
    22.         for (int i = 0; i < level; i++) {
    23.             System.out.print("\t");
    24.         }
    25.         System.out.println(name);
    26.     }
    27. }

    客户端：

    1. public class Test {
    2.     public static void main(String[] args) {
    3.         //定义根目录
    4.         FileComponent rootComponent = new FileFolder("我是根目录",1,1);
    5.         //定义二级文件夹
    6.         FileComponent secondLevelComponent = new FileFolder("我是二级目录",2,1);
    7.         //定义文件
    8.         FileComponent file = new FileItem("我是文件",3,2);
    9.         //向根目录添加二级目录
    10.         rootComponent.add(secondLevelComponent);
    11.         //向二级目录添加文件
    12.         secondLevelComponent.add(file);
    13.         //打印
    14.         rootComponent.print();
    15.     }
    16. }

  • 相关阅读:
    项目实战：设置静态资源放行
    蓝桥等考Python组别九级004
    移动互联网时代，如何撬开流量的密码？
    nginx 配置防盗链(了解)
    将cookie字符串转成editthiscookie插件的json格式
    @Autowired与@Resource区别
    HttpClient / Http客户端
    百度收录提交工具-免费主动提交百度快速收录软件
    源码分享-HTML文档解析---GoLang实现
    【STM32】入门（十一）：初识uCOS-III
  • 原文地址：https://blog.csdn.net/w_t_y_y/article/details/134027193