之前做一个需求，设计一个设置程序，设置程序中包含不同的页面，页面中又有不同的分组，每个分组下面又有不同的项，每个项包含不同的控件。
当用户点击保存的时候，需要将所有的配置，都映射并保存在配置文件中。
之前做的时候，是将每个控件都绑定一个映射项，然后遍历所有的页的组，在遍历组的项，再遍历项的控件调用保存。
伪代码如下：
for(Page page:pages){
if(page.controls()!=null){
for(Group control:page.controls()){
//....
}
}
}
好几层迭代，每层迭代中还需要判断是否包含相关的组
后来，又出现了一个新的需求，因为要和其他程序联动，因此如果用户修改了某个配置，那么应该不等用户点击保存，就应该写到配置文件中，有点类似于VUE的双向绑定。
这个时候面对这臃肿的代码，简直崩溃。
仔细梳理上面的需求可以发现，由于设置程序分为好几个页，同时每个页分为几个组，每个组又有不同项，每个项包含不同的控件。可以类比到每个国家的政治区域划分，就好像每个省包含很多市，每个市又有不同的县。而有些地方又有直辖市。因此，我们可以学习这种管理方式，让每个分支自己管理自己的分组，而作为根节点，我们只用管理根节点所接触到的结构即可。
成功优化后的代码，将会是如下效果：
for(Control page:pages){
page.save();
}
简直不能简单的更多。
以上思想，便是组合模式的雏形。
组合模式将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户可以使用一致的方法操作单个对象和组合对象。
比如上面的代码，我们可以首先定义一个接口：
public interface Control {
//添加节点
void add(Control control);
//删除节点
void remove(Control control);
//设置层级，方便打印
void setLevel(int level);
//保存配置
void save();
}
然后，依次定义Page , Group , Item
//定义page，group，item等相同
public class Page implements Control {
private List<Control> children = new ArrayList<>();
private int level;
@Override
public void save() {
System.out.println("- Page");
for (Control control : children) {
control.save();
}
}
@Override
public void add(Control control) {
control.setLevel(1);
children.add(control);
}
@Override
public void remove(Control control) {
children.remove(control);
}
@Override
public void setLevel(int level) {
this.level=level;
}
}
//其他相同
接下来，可以定义具体的节点，这样的节点在组合模式中称为”叶子节点“
public class Button implements Control {
private int level;
@Override
public void save() {
StringBuilder stringBuilder=new StringBuilder();
for (int i = 0; i < level; i++) {
stringBuilder.append('-').append(" ");
}
System.out.println(stringBuilder+" Button保存成功");
}
@Override
public void add(Control control) {
System.out.println("错误的操作，不支持add()");
}
@Override
public void remove(Control control) {
System.out.println("错误的操作，不支持remove()");
}
@Override
public void setLevel(int level) {
this.level=level;
}
}
public class TextBox implements Control {
private int level;
@Override
public void save() {
StringBuilder stringBuilder=new StringBuilder();
for (int i = 0; i < level; i++) {
stringBuilder.append('-').append(" ");
}
System.out.println(stringBuilder+"TextBox保存成功");
}
@Override
public void add(Control control) {
System.out.println("错误的操作，不支持add()");
}
@Override
public void remove(Control control) {
System.out.println("错误的操作，不支持remove()");
}
@Override
public void setLevel(int level) {
this.level=level;
}
}
到这里，基本就执行完了，可以看到实现Control接口的基本分为两类，分别为叶子类和树枝类，叶子节点作为最终的端点，完成最后的操作，而树枝类负责管理本身的所有叶子节点。
使用方式如下：
public static void main(String[] args) {
Page page=new Page();
Group group=new Group();
Item item =new Item();
Button button=new Button();
TextBox textBox=new TextBox();
page.add(group);
group.add(button);
group.add(item);
item.add(textBox);
page.save();
}
然后我们就能看到打印出来的信息：
- Page
- - Group
- - Button保存成功
- - - Item
- - - TextBox保存成功
可以看到，使用非常方便，并且更加便于维护。
以上示例代码均在：https://github.com/dengchengchao/design-pattern
定义：
组合模式: 组合模式（Composite Pattern）将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户可以使用一致的方法操作单个对象和组合对象。
组合模式属于结构型模式
UML
组合模式如上所示，由于树枝和叶子有着不同的操作，而叶子节点一般不存在添加子节点和删除子节点操作，所有有时候为了避免调用到叶子节点的这个非法操作。也可以单独实现叶子节点，这样的模式被称为安全模式。
应用场景
一般应用在哪些具有层级嵌套的结构中，比如组织机构树的遍历，比如各种控件子控件的管理等等。使用组合模式可以屏蔽用户对层级结构的感知。
比如MyBatis对动态SQL的解析
比如C#中的各个控件都继承自Controls
优点
- 客户端调用简单，客户端只需管理好根节点即可，不必判断组件类型，也不用为不同的组件添加
if-else - 方便维护，使用组合模式可以非常方便的添加扩展层级，并且不用修改原有的代码，符合开闭原则
缺点
- 由于屏蔽了树枝类和叶子类的区别，因此如果某些代码不小心调用了叶子类的非法方法，那只能在运行时才能检测出来。
总结
当代码中存在一些层级的逻辑结构，就非常的适合使用的组合模式来进行设计，这样的设计能使得代码非常简单，同时组合模式又分为透明模式和安全模式，应该按照实际情况选择使用。
