Java 组合模式 详解

组合模式详解

一、组合模式概述

组合模式(Composite Pattern)是一种结构型设计模式，它允许你将对象组合成树形结构来表示"部分-整体"的层次结构。组合模式使得客户端对单个对象和组合对象的使用具有一致性。

核心特点

• 统一处理：叶子对象和组合对象具有一致的接口
• 递归结构：组合对象可以包含其他组合对象，形成树形结构
• 透明性：客户端无需知道处理的是单个对象还是组合对象
• 灵活性：可以方便地增加新的组件类型

二、组合模式的结构

主要角色

1. Component：组件抽象类或接口
2. Leaf：叶子节点类
3. Composite：组合节点类

三、组合模式的实现

1. 透明式实现（推荐）

// 组件接口
public interface Component {
    void operation();
    void add(Component component);
    void remove(Component component);
    Component getChild(int index);
}

// 叶子节点
public class Leaf implements Component {
    private String name;
    
    public Leaf(String name) {
        this.name = name;
    }
    
    public void operation() {
        System.out.println("叶子节点 " + name + " 执行操作");
    }
    
    // 叶子节点不支持这些方法
    public void add(Component component) {
        throw new UnsupportedOperationException();
    }
    
    public void remove(Component component) {
        throw new UnsupportedOperationException();
    }
    
    public Component getChild(int index) {
        throw new UnsupportedOperationException();
    }
}

// 组合节点
public class Composite implements Component {
    private List<Component> children = new ArrayList<>();
    private String name;
    
    public Composite(String name) {
        this.name = name;
    }
    
    public void operation() {
        System.out.println("组合节点 " + name + " 执行操作");
        for (Component component : children) {
            component.operation();
        }
    }
    
    public void add(Component component) {
        children.add(component);
    }
    
    public void remove(Component component) {
        children.remove(component);
    }
    
    public Component getChild(int index) {
        return children.get(index);
    }
}

// 使用示例
Component root = new Composite("根节点");
Component branch1 = new Composite("分支1");
Component branch2 = new Composite("分支2");
Component leaf1 = new Leaf("叶子1");
Component leaf2 = new Leaf("叶子2");

root.add(branch1);
root.add(branch2);
branch1.add(leaf1);
branch2.add(leaf2);

root.operation();

2. 安全式实现

// 组件接口（简化版）
public interface Component {
    void operation();
}

// 组合节点接口
public interface Composite extends Component {
    void add(Component component);
    void remove(Component component);
    Component getChild(int index);
}

// 叶子节点实现
public class Leaf implements Component {
    public void operation() {
        System.out.println("叶子节点操作");
    }
}

// 组合节点实现
public class ConcreteComposite implements Composite {
    private List<Component> children = new ArrayList<>();
    
    public void operation() {
        System.out.println("组合节点操作");
        for (Component component : children) {
            component.operation();
        }
    }
    
    public void add(Component component) {
        children.add(component);
    }
    
    public void remove(Component component) {
        children.remove(component);
    }
    
    public Component getChild(int index) {
        return children.get(index);
    }
}

四、组合模式的应用场景

1. 文件系统实现

// 文件系统组件
public abstract class FileSystemComponent {
    protected String name;
    
    public FileSystemComponent(String name) {
        this.name = name;
    }
    
    public abstract void display(int depth);
    public abstract long getSize();
}

// 文件（叶子节点）
public class File extends FileSystemComponent {
    private long size;
    
    public File(String name, long size) {
        super(name);
        this.size = size;
    }
    
    public void display(int depth) {
        System.out.println(StringUtils.repeat("  ", depth) + "- " + name);
    }
    
    public long getSize() {
        return size;
    }
}

// 目录（组合节点）
public class Directory extends FileSystemComponent {
    private List<FileSystemComponent> children = new ArrayList<>();
    
    public Directory(String name) {
        super(name);
    }
    
    public void add(FileSystemComponent component) {
        children.add(component);
    }
    
    public void remove(FileSystemComponent component) {
        children.remove(component);
    }
    
    public void display(int depth) {
        System.out.println(StringUtils.repeat("  ", depth) + "+ " + name);
        for (FileSystemComponent component : children) {
            component.display(depth + 1);
        }
    }
    
    public long getSize() {
        long totalSize = 0;
        for (FileSystemComponent component : children) {
            totalSize += component.getSize();
        }
        return totalSize;
    }
}

2. 菜单系统实现

// 菜单组件
public abstract class MenuComponent {
    public void add(MenuComponent component) {
        throw new UnsupportedOperationException();
    }
    
    public void remove(MenuComponent component) {
        throw new UnsupportedOperationException();
    }
    
    public MenuComponent getChild(int i) {
        throw new UnsupportedOperationException();
    }
    
    public String getName() {
        throw new UnsupportedOperationException();
    }
    
    public String getDescription() {
        throw new UnsupportedOperationException();
    }
    
    public double getPrice() {
        throw new UnsupportedOperationException();
    }
    
    public void print() {
        throw new UnsupportedOperationException();
    }
}

// 菜单项（叶子节点）
public class MenuItem extends MenuComponent {
    private String name;
    private String description;
    private double price;
    
    public MenuItem(String name, String description, double price) {
        this.name = name;
        this.description = description;
        this.price = price;
    }
    
    public String getName() {
        return name;
    }
    
    public String getDescription() {
        return description;
    }
    
    public double getPrice() {
        return price;
    }
    
    public void print() {
        System.out.println("  " + getName() + ", " + getPrice());
        System.out.println("    -- " + getDescription());
    }
}

// 菜单（组合节点）
public class Menu extends MenuComponent {
    private List<MenuComponent> menuComponents = new ArrayList<>();
    private String name;
    private String description;
    
    public Menu(String name, String description) {
        this.name = name;
        this.description = description;
    }
    
    public void add(MenuComponent component) {
        menuComponents.add(component);
    }
    
    public void remove(MenuComponent component) {
        menuComponents.remove(component);
    }
    
    public MenuComponent getChild(int i) {
        return menuComponents.get(i);
    }
    
    public String getName() {
        return name;
    }
    
    public String getDescription() {
        return description;
    }
    
    public void print() {
        System.out.println("\n" + getName() + ", " + getDescription());
        System.out.println("---------------------");
        
        for (MenuComponent component : menuComponents) {
            component.print();
        }
    }
}

五、组合模式的变体

1. 带父节点引用的实现

public abstract class Component {
    protected Component parent;
    
    public void setParent(Component parent) {
        this.parent = parent;
    }
    
    public Component getParent() {
        return parent;
    }
    
    // 其他方法...
}

2. 支持遍历的实现

public interface IterableComponent extends Component, Iterable<Component> {
}

public class Composite implements IterableComponent {
    // ...其他代码
    
    public Iterator<Component> iterator() {
        return children.iterator();
    }
}

六、组合模式的优缺点

优点

1. 简化客户端代码：统一处理叶子对象和组合对象
2. 易于扩展：新增组件类型不影响现有结构
3. 灵活的结构：可以构建复杂的树形结构
4. 符合开闭原则：无需修改现有代码即可新增组件

缺点

1. 设计抽象较难：需要合理设计组件接口
2. 类型检查问题：可能需要运行时类型检查
3. 限制性较强：要求所有组件遵循同一接口

七、最佳实践

1. 合理设计组件接口：平衡透明性和安全性
2. 考虑缓存优化：对频繁访问的操作结果进行缓存
3. 实现遍历功能：为组合结构提供迭代器
4. 文档化结构：明确组件之间的关系和约束
5. 异常处理：对不支持的操作提供清晰的错误提示

八、总结

组合模式是处理树形结构的有效方案，特别适用于：

• 表示对象的部分-整体层次结构
• 希望客户端忽略组合对象与单个对象的不同
• 需要处理递归或嵌套结构的场景

在实际开发中，组合模式常见于：

• 文件/目录系统
• GUI组件系统
• 组织结构表示
• 菜单系统
• XML/JSON文档处理

正确使用组合模式可以简化复杂结构的处理，但需要注意不要过度使用，在确实存在树形结构需求时才采用此模式。