Java设计模式之组合模式（透明组合模式，安全组合模式）

一、概述

组合多个对象形成树形结构以表示具有部分-整体关系的层次结构，可以让客户端统一对待单个对象和组合对象。

组合模式关注那些包含叶子构件和容器构件的结构以及它们的组织形式，在叶子构件中不包含成员变量，而容器构件中可以包含成员对象，这些对象通过递归组合可构成一个树形结构。

二、结构与实现

1. 结构：

（1）Component（抽象构件）：

可以是接口或抽象类，为叶子构件及容器构件提供共有行为的声明。抽象构件中定义了访问及管理它的子构件的方法，如：新增、删除、获取子构件。

（2）Leaf（叶子构件）：

实现抽象构件中定义的行为。无子节点。

（3）Composite（容器构件）：实现抽象构件中定义的行为，包括那些访问及管理子构件的方法。容器节点包含子节点，可以是子节点，也可以是容器节点。

2. 实现

（1）Component：

public abstract class Component{
	//定义了访问及管理它的子构件的方法
	public abstract void add(Component c);
	public abstract void remove(Component c);
	public abstract Component getChild(int i);
	//业务方法
	public abstract void operation();
} 

（2）Leaf：

public class Leaf extends Component{
	public void add(Component c){ //异常处理或错误提示}
	public void remove(Component c){ //异常处理或错误提示}
	public Component getChild(int i){ return null}
	public void operation(){//具体业务实现}
}

（3）Composite：

public class Composite extends Component{
	private ArrayList<Component> list =new ArrayList<Component>();
	public void add(Component c){	
	list.add(c);
	}
	public void remove(Component c){	
	list.remove(c);
	}
	public Component getChild(int i){	
		return (Component)list.get(i)
	}
	public void operation(){
		//容器构件具体业务方法的实现，将递归调用成员构件的业务方法
		for(Object obj:list){
			((Component)obj).operation();
		}
	}
}

三、应用实例

1. 分析：

Folder充当容器构件类，ImageFile和TextFile充当叶子构件类，再抽出一个AbstractFile作为抽象构件类。

2. 类图：
   

3. 代码实现：

abstract class AbstractFile{
	public abstract void add(AbstractFile file);
	public abstract void remove(AbstractFile file);
	public abstract AbstractFile getChild(int i);
	public abstract killViris();
]

//ImageFile
class ImageFile extends AbstractFile{
    private String name;
    public ImageFile(String name) {
        this.name = name;
    }
    @Override
    public void add(AbstractFile file) {
        System.out.println("不支持此方法...");
    }
    @Override
    public void remove(AbstractFile file) {
        System.out.println("不支持此方法...");
    }
    @Override
    public AbstractFile getChild(int i) {
        System.out.println("不支持此方法...");
        return null;
    }
    @Override
    public void killVirus() {
        System.out.println("对图片文件"+name+"进行查杀中...");
    }
}

//TextFile
class TextFile extends AbstractFile{
    private String name;
    public TextFile(String name) {
        this.name = name;
    }
    //add，remove，getChild方法同上，此处省略
    @Override
    public void killVirus() {
        System.out.println("对文本文件"+name+"进行查杀中...");
    }
}

//Folder
class Folder extends AbstractFile{
    private String name;
    public Folder(String name) {
        this.name = name;
    }
    private ArrayList<AbstractFile> list=new ArrayList<>();
    @Override
    public void add(AbstractFile file) {
        list.add(file);
    }
    @Override
    public void remove(AbstractFile file) {
        list.remove(file);
    }
    @Override
    public AbstractFile getChild(int i) {
        AbstractFile file = list.get(i);
        return file;
    }
    //递归进行查杀
    @Override
    public void killVirus() {
        System.out.println("对文件夹"+name+"内进行查杀...");
        for (AbstractFile obj : list) {
            obj.killVirus();
        }
    }
}

public class client {
    public static void main(String[] args) {
        //创建文件夹
        Folder folder1=new Folder("Java资料");
        Folder folder2=new Folder("图片资料");
        Folder folder3=new Folder("文本资料");

        //创建图像及文本文件
        ImageFile file1=new ImageFile("思维导图.jpg");
        ImageFile file2=new ImageFile("类图.png");
        TextFile file3=new TextFile("Java基础.doc");
        TextFile file4=new TextFile("Java进阶.txt");

        //将图像及文本添加进文件夹
        folder2.add(file1);
        folder2.add(file2);
        folder3.add(file3);
        folder3.add(file4);
		//将两个文件夹添加进父文件夹
        folder1.add(folder2);
        folder1.add(folder3);
		
		//递归进行查杀
        folder1.killVirus();
    }
}

4. 测试运行
   

四、扩展

组合模式根据抽象构件类的定义形式又可以分为透明组合模式和安全组合模式。

如上，例三的应用案例就是透明组合模式。
透明组合模式结构图：

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

安全组合模式结构图：

抽象构件中没有声明任何用于管理成员对象的方法，对于叶子对象，客户端不可能调用到这些方法，所以这种做法是安全的。而安全组合模式的缺点就是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别地对待叶子构件和容器构件。

五、总结

1. 特点

组合模式用于组合多个对象形成树形结构以表示具有部分-整体关系地层次结构。包含抽象构件类，叶子构件类，容器构件类。

2. 适用场景

（1）在具有整体和部分地层次结构中希望通过一种方式忽略整体与部分的差异，客户端可以一致地对待它们。
（2）需要处理一个树形结构，能够分离出叶子对象和容器对象，而且它们的类型不固定，需要增加一些新的类型。