掌握设计模式–组合模式

技术分享 1年前 (2025-01-04) 0 999+

关注

组合模式（Composite Pattern）

组合模式（Composite Pattern）是一种结构型设计模式，它用于将对象组织成树形结构，以表示部分-整体的层次结构。通过组合模式，客户端可以统一对待单个对象和组合对象，从而简化了客户端代码的复杂性。

组合模式的核心思想

统一的接口：通过抽象类或接口将单个对象和组合对象统一起来；
递归组合：组合对象中可以包含单个对象或其他组合对象；
透明性：客户端可以一致地调用单个对象和组合对象的方法，而无需区分两者的差异。

组合模式的角色

组件（Component）
定义单个对象和组合对象的公共接口，例如通用操作（add、remove、getChild等）。
叶子节点（Leaf）
表示树形结构中的基本单元，不能再包含其他对象。它实现了组件接口，但不支持添加或移除操作。
组合对象（Composite）
表示树形结构中的复杂单元，可以包含叶子节点或其他组合对象。它实现组件接口，并负责管理其子对象的操作。

示例代码

组合模式解析XML或 HTML 元素结构的代码示例。我们将 XML/HTML 元素看作“部分-整体”结构，其中：

叶子节点(leaf)：表示没有子节点的元素（如 <img> 或 <input>）。
组合节点(Composite)：表示可以包含其他子元素的元素（如 <div> 或 <body>）。

两种节点使用同一种的顶层抽象，属于同一类对象，统称为元素（节点）。

类图

1. 抽象组件

HTML顶层元素抽象类。你也可以定义一个顶层接口，然后在抽象类中实现基础功能。

public abstract class HTMLElement {     protected String name;      public HTMLElement(String name) {         this.name = name;     }      public abstract void render(int level);      public HTMLElement getChild(int index) {         throw new UnsupportedOperationException();     }      // 默认行为：叶子结点禁止新增元素     public void addChild(HTMLElement element) {         throw new UnsupportedOperationException();     }     // 默认行为：叶子结点禁止移除子元素     public void removeChild(HTMLElement element) {         throw new UnsupportedOperationException();     }      // 辅助方法：生成缩进     protected String generateIndent(int level) {         StringBuilder indent = new StringBuilder();         for (int i = 0; i < level * 2; i++) {             indent.append(" "); // 每层缩进2个空格         }         return indent.toString();     } }

2. 组合结点

表示可以包含子元素的HTML标签

public class HTMLComposite extends HTMLElement {     private List<HTMLElement> children = new LinkedList<>();      public HTMLComposite(String name) {         super(name);     }      @Override     public void addChild(HTMLElement element) {         children.add(element);     }      @Override     public void removeChild(HTMLElement element) {         children.remove(element);     }      @Override     public HTMLElement getChild(int index) {         return children.get(index);     }      @Override     public void render(int level) {         System.out.println(generateIndent(level) + "<" + name + ">");         for (HTMLElement child : children) {             child.render(level + 1); // 子节点递归调用         }         System.out.println(generateIndent(level) + "</" + name + ">");     } }

3.叶子节点

表示没有子元素的HTML标签

public class HTMLLeaf extends HTMLElement {     public HTMLLeaf(String name) {         super(name);     }      @Override     public void render(int level) {         System.out.println(generateIndent(level) + "<" + name + " />");     } }

测试

public class CompositePatternHTMLDemo {     public static void main(String[] args) {         // 创建HTML结构         HTMLElement html = new HTMLComposite("html");         HTMLElement body = new HTMLComposite("body");         HTMLElement div = new HTMLComposite("div");         HTMLElement img = new HTMLLeaf("img");         HTMLElement input = new HTMLLeaf("input");         HTMLElement p = new HTMLLeaf("p");           // 组合结构         html.addChild(body);         body.addChild(div);         body.addChild(input);         div.addChild(img);         div.addChild(p);          // 渲染HTML结构         html.render(0);          // 去除某个节点         div.removeChild(p);         html.render(0);     } }

测试结果：

<html>   <body>     <div>       <img />       <p />     </div>     <input />   </body> </html> <html>   <body>     <div>       <img />     </div>     <input />   </body> </html>

从类图或测试类（使用者）中可以看出，使用者直接依赖于具体的类，属于高耦合的一种编程方式。

简单优化（结合其它设计模式）

加入一个工厂类来创建组合节点和叶子结点

类图结构变为

工厂类代码

public class HTMLElementFactory {     private static Map<String, Class<? extends HTMLElement>> elementRegistry = new HashMap<>();      static {         // 注册类         try {             HTMLElementFactory.registerElement("composite", (Class<? extends HTMLElement>) Class.forName("org.example.composite.htmldemo.HTMLComposite"));             HTMLElementFactory.registerElement("leaf", (Class<? extends HTMLElement>) Class.forName("org.example.composite.htmldemo.HTMLLeaf"));         } catch (ClassNotFoundException e) {             throw new RuntimeException(e);         }     }      // 注册类     public static void registerElement(String type, Class<? extends HTMLElement> clazz) {         elementRegistry.put(type, clazz);     }      // 创建实例     public HTMLElement createElement(String type, String name) {         Class<? extends HTMLElement> clazz = elementRegistry.get(type);         if (clazz == null) {             throw new IllegalArgumentException("未知元素类型: " + type);         }         try {             return clazz.getDeclaredConstructor(String.class).newInstance(name);         } catch (Exception e) {             throw new RuntimeException("错误创建元素对象: " + e.getMessage(), e);         }     } }

测试代码

public class CompositePatternHTMLDemo {     public static void main(String[] args) {         // 创建HTML结构 //        HTMLElement html = new HTMLComposite("html"); //        HTMLElement body = new HTMLComposite("body"); //        HTMLElement div = new HTMLComposite("div"); //        HTMLElement img = new HTMLLeaf("img"); //        HTMLElement input = new HTMLLeaf("input"); //        HTMLElement p = new HTMLLeaf("p");          HTMLElementFactory htmlElementFactory = new HTMLElementFactory();         // 创建对象         HTMLElement html = htmlElementFactory.createElement("composite", "html");         HTMLElement body = htmlElementFactory.createElement("composite", "body");         HTMLElement div = htmlElementFactory.createElement("composite", "div");         HTMLElement input = htmlElementFactory.createElement("leaf", "input");         HTMLElement img = htmlElementFactory.createElement("leaf", "img");         HTMLElement p = htmlElementFactory.createElement("leaf", "p");          // 组合结构         html.addChild(body);         body.addChild(div);         body.addChild(input);         div.addChild(img);         div.addChild(p);          // 渲染HTML结构         html.render(0);          // 去除某个节点         div.removeChild(p);         html.render(0);     } }

测试结果和前面的一样。

除了结合工厂模式外，还可以结合其它设计模式。比如，结合迭代器模式来递归遍历组合树。