树形结构不论在生活中或者是开发中都是一种非常常见的结构,一个容器对象(如文件夹)下可以存放多种不同的叶子对象或者容器对象,容器对象与叶子对象之间属性差别可能非常大。
由于容器对象和叶子对象在功能上的区别,在使用这些对象的代码中必须有区别地对待容器对象和叶子对象,而实际上大多数情况下我们希望一致地处理它们,因为对于这些对象的区别对待将会使得程序非常复杂。
组合模式为解决此类问题而诞生,它可以让叶子对象和容器对象的使用具有一致性。
组合多个对象形成树形结构以表示具有 “整体—部分” 关系的层次结构。组合模式对单个对象(即叶子对象)和组合对象(即容器对象)的使用具有一致性,组合模式又可以称为 “整体—部分”(Part-Whole) 模式,它是一种对象结构型模式。
由于在软件开发中存在大量的树形结构,因此组合模式是一种使用频率较高的结构型设计模式,
在XML解析、组织结构树处理、文件系统设计等领域,组合模式都得到了广泛应用。
组合模式的关键是定义了一个抽象构件类,它既可以代表叶子,又可以代表容器,而客户端针对该抽象构件类进行编程,无须知道它到底表示的是叶子还是容器,可以对其进行统一处理。同时容器对象与抽象构件类之间还建立一个聚合关联关系,在容器对象中既可以包含叶子,也可以包含容器,以此实现递归组合,形成一个树形结构。
典型的抽象构件角色代码:
1 public abstract class Component
2 {
3 public abstract void add(Component c);
4 public abstract void remove(Component c);
5 public abstract Component getChild(int i);
6 public abstract void operation();
7 }
典型的叶子构件角色代码:
1 public class Leaf extends Component
2 {
3 public void add(Component c)
4 { //异常处理或错误提示 }
5
6 public void remove(Component c)
7 { //异常处理或错误提示 }
8
9 public Component getChild(int i)
10 { //异常处理或错误提示 }
11
12 public void operation()
13 {
14 //实现代码
15 }
16 }
典型的容器构件角色代码:
1 public class Composite extends Component
2 {
3 private ArrayList list = new ArrayList();
4
5 public void add(Component c)
6 {
7 list.add(c);
8 }
9
10 public void remove(Component c)
11 {
12 list.remove(c);
13 }
14
15 public Component getChild(int i)
16 {
17 (Component)list.get(i);
18 }
19
20 public void operation()
21 {
22 for(Object obj:list)
23 {
24 ((Component)obj).operation();
25 }
26 }
27 }
在水果盘(Plate)中有一些水果,如苹果(Apple)、香蕉(Banana)、梨子(Pear),当然大水果盘中还可以有小水果盘,现需要对盘中的水果进行遍历(吃),当然如果对一个水果盘执行“吃”方法,实际上就是吃其中的水果。使用组合模式模拟该场景 。
1 //抽象构建
2 public abstract class MyElement
3 {
4 public abstract void eat();
5 }
6
7 //容器构建
8 import java.util.*;
9
10 public class Plate extends MyElement
11 {
12 private ArrayList list=new ArrayList();
13
14 public void add(MyElement element)
15 {
16 list.add(element);
17 }
18
19 public void delete(MyElement element)
20 {
21 list.remove(element);
22 }
23
24 public void eat()
25 {
26 for(Object object:list)
27 {
28 ((MyElement)object).eat(); //递归
29 }
30 }
31 }
32
33 //叶子构建
34 public class Apple extends MyElement
35 {
36 public void eat()
37 {
38 System.out.println("吃苹果!");
39 }
40 }
41
42 //叶子构建
43 public class Banana extends MyElement
44 {
45 public void eat()
46 {
47 System.out.println("吃香蕉!");
48 }
49 }
50
51 //叶子构建
52 public class Pear extends MyElement
53 {
54 public void eat()
55 {
56 System.out.println("吃梨子!");
57 }
58 }
59
60 //客户端
61 public class Client
62 {
63 public static void main(String a[])
64 {
65 MyElement obj1,obj2,obj3,obj4,obj5;
66 Plate plate1,plate2,plate3;
67
68 obj1=new Apple();
69 obj2=new Pear();
70 plate1=new Plate();
71 plate1.add(obj1);
72 plate1.add(obj2);
73
74 obj3=new Banana();
75 obj4=new Banana();
76 plate2=new Plate();
77 plate2.add(obj3);
78 plate2.add(obj4);
79
80 obj5=new Apple();
81 plate3=new Plate();
82 plate3.add(plate1);
83 plate3.add(plate2);
84 plate3.add(obj5);
85
86 plate3.eat();
87 }
88 }
我们来实现一个简单的目录树,有文件夹和文件两种类型,首先需要一个抽象构件类,声明了文件夹类和文件类需要的方法
public abstract class Component {
public String getName() {
throw new UnsupportedOperationException("不支持获取名称操作");
}
public void add(Component component) {
throw new UnsupportedOperationException("不支持添加操作");
}
public void remove(Component component) {
throw new UnsupportedOperationException("不支持删除操作");
}
public void print() {
throw new UnsupportedOperationException("不支持打印操作");
}
public String getContent() {
throw new UnsupportedOperationException("不支持获取内容操作");
}
}
实现一个文件夹类 Folder,继承 Component,定义一个 List<Component>
类型的componentList属性,用来存储该文件夹下的文件和子文件夹,并实现 getName、add、remove、print等方法
public class Folder extends Component {
private String name;
private List<Component> componentList = new ArrayList<Component>();
public Integer level;
public Folder(String name) {
this.name = name;
}
@Override
public String getName() {
return this.name;
}
@Override
public void add(Component component) {
this.componentList.add(component);
}
@Override
public void remove(Component component) {
this.componentList.remove(component);
}
@Override
public void print() {
System.out.println(this.getName());
if (this.level == null) {
this.level = 1;
}
String prefix = "";
for (int i = 0; i < this.level; i++) {
prefix += "\t- ";
}
for (Component component : this.componentList) {
if (component instanceof Folder){
((Folder)component).level = this.level + 1;
}
System.out.print(prefix);
component.print();
}
this.level = null;
}
}
文件类 File,继承Component父类,实现 getName、print、getContent等方法
public class File extends Component {
private String name;
private String content;
public File(String name, String content) {
this.name = name;
this.content = content;
}
@Override
public String getName() {
return this.name;
}
@Override
public void print() {
System.out.println(this.getName());
}
@Override
public String getContent() {
return this.content;
}
}
我们来测试一下
public class Test {
public static void main(String[] args) {
Folder DSFolder = new Folder("设计模式资料");
File note1 = new File("组合模式笔记.md", "组合模式组合多个对象形成树形结构以表示具有 \"整体—部分\" 关系的层次结构");
File note2 = new File("工厂方法模式.md", "工厂方法模式定义一个用于创建对象的接口,让子类决定将哪一个类实例化。");
DSFolder.add(note1);
DSFolder.add(note2);
Folder codeFolder = new Folder("样例代码");
File readme = new File("README.md", "# 设计模式示例代码项目");
Folder srcFolder = new Folder("src");
File code1 = new File("组合模式示例.java", "这是组合模式的示例代码");
srcFolder.add(code1);
codeFolder.add(readme);
codeFolder.add(srcFolder);
DSFolder.add(codeFolder);
DSFolder.print();
}
}
输出结果
设计模式资料
- 组合模式笔记.md
- 工厂方法模式.md
- 样例代码
- - README.md
- - src
- - - 组合模式示例.java
在这里父类 Component
是一个抽象构件类,Folder
类是一个容器构件类,File
是一个叶子构件类,Folder
和 File
继承了 Component
,Folder
与 Component
又是聚合关系
在使用组合模式时,根据抽象构件类的定义形式,我们可将组合模式分为透明组合模式和安全组合模式两种形式。
透明组合模式中,抽象构件角色中声明了所有用于管理成员对象的方法,譬如在示例中 Component 声明了 add、remove 方法,这样做的好处是确保所有的构件类都有相同的接口。透明组合模式也是组合模式的标准形式。
透明组合模式的缺点是不够安全,因为叶子对象和容器对象在本质上是有区别的,叶子对象不可能有下一个层次的对象,即不可能包含成员对象,因此为其提供 add()、remove() 等方法是没有意义的,这在编译阶段不会出错,但在运行阶段如果调用这些方法可能会出错(如果没有提供相应的错误处理代码)
在安全组合模式中,在抽象构件角色中没有声明任何用于管理成员对象的方法,而是在容器构件 Composite 类中声明并实现这些方法
安全组合模式的缺点是不够透明,因为叶子构件和容器构件具有不同的方法,且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义,因此客户端不能完全针对抽象编程,必须有区别地对待叶子构件和容器构件。
在实际应用中 java.awt 和 swing 中的组合模式即为安全组合模式。
1 <?xml version="1.0"?>
2 <books>
3 <book>
4 <author>Carson</author>
5 <price format="dollar">31.95</price>
6 <pubdate>05/01/2001</pubdate>
7 </book>
8 <pubinfo>
9 <publisher>MSPress</publisher>
10 <state>WA</state>
11 </pubinfo>
12 </books>
操作系统中的目录结构是一个树形结构,因此在对文件和文件夹进行操作时可以应用组合模式,例如杀毒软件在查毒或杀毒时,既可以针对一个具体文件,也可以针对一个目录。如果是对目录查毒或杀毒,将递归处理目录中的每一个子目录和文件。
HashMap 提供 putAll 的方法,可以将另一个 Map 对象放入自己的存储空间中,如果有相同的 key 值则会覆盖之前的 key 值所对应的 value 值
public class Test {
public static void main(String[] args) {
Map<String, Integer> map1 = new HashMap<String, Integer>();
map1.put("aa", 1);
map1.put("bb", 2);
map1.put("cc", 3);
System.out.println("map1: " + map1);
Map<String, Integer> map2 = new LinkedMap();
map2.put("cc", 4);
map2.put("dd", 5);
System.out.println("map2: " + map2);
map1.putAll(map2);
System.out.println("map1.putAll(map2): " + map1);
}
}
输出结果
map1: {aa=1, bb=2, cc=3}
map2: {cc=4, dd=5}
map1.putAll(map2): {aa=1, bb=2, cc=4, dd=5}
查看 putAll 源码
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}
putAll 接收的参数为父类 Map 类型,所以 HashMap 是一个容器类,Map 的子类为叶子类,当然如果 Map 的其他子类也实现了 putAll 方法,那么它们都既是容器类,又都是叶子类
MyBatis 的强大特性之一便是它的动态SQL,其通过 if, choose, when, otherwise, trim, where, set, foreach 标签,可组合成非常灵活的SQL语句,从而提高开发人员的效率。
<select id="findActiveBlogLike" resultType="Blog">
SELECT * FROM BLOG WHERE state = ‘ACTIVE’
<if test="title != null">
AND title like #{title}
</if>
<if test="author != null and author.name != null">
AND author_name like #{author.name}
</if>
</select>
Mybatis在处理动态SQL节点时,应用到了组合设计模式,Mybatis会将映射配置文件中定义的动态SQL节点、文本节点等解析成对应的 SqlNode 实现,并形成树形结构。
SQLNode 的类图如下所示:
需要先了解 DynamicContext 类的作用:主要用于记录解析动态SQL语句之后产生的SQL语句片段,可以认为它是一个用于记录动态SQL语句解析结果的容器
抽象构件为 SqlNode 接口,源码如下:
public interface SqlNode {
boolean apply(DynamicContext context);
}
apply 是 SQLNode 接口中定义的唯一方法,该方法会根据用户传入的实参,参数解析该SQLNode所记录的动态SQL节点,并调用 DynamicContext.appendSql() 方法将解析后的SQL片段追加到 DynamicContext.sqlBuilder 中保存,当SQL节点下所有的 SqlNode 完成解析后,我们就可以从 DynamicContext 中获取一条动态生产的、完整的SQL语句
然后来看 MixedSqlNode 类的源码:
public class MixedSqlNode implements SqlNode {
private List<SqlNode> contents;
public MixedSqlNode(List<SqlNode> contents) {
this.contents = contents;
}
@Override
public boolean apply(DynamicContext context) {
for (SqlNode sqlNode : contents) {
sqlNode.apply(context);
}
return true;
}
}
MixedSqlNode 维护了一个 List< SqlNode > 类型的列表,用于存储 SqlNode 对象,apply 方法通过 for循环 遍历 contents 并调用其中对象的 apply 方法,这里跟我们的示例中的 Folder 类中的 print 方法非常类似,很明显 MixedSqlNode 扮演了容器构件角色
对于其他SqlNode子类的功能,稍微概括如下:
综上,SqlNode 接口有多个实现类,每个实现类对应一个动态SQL节点,其中 SqlNode 扮演抽象构件角色,MixedSqlNode 扮演容器构件角色,其它一般是叶子构件角色