寂然解读设计模式 - 组合模式_开课吧设计模式寂然-CSDN博客

本文链接：https://blog.csdn.net/weixin_44808014/article/details/112284512

I walk very slowly, but I never walk backwards

设计模式 - 组合模式

寂然

大家好，我是寂然，本节课，我们来聊设计模式中的组合模式，老规矩，首先我们先通过一个案例需求来引入

案例演示 - 院校展示

在一个页面中展示出学校的院系组成

一个学校会有多个学院，一个学院有会多个专业

编写程序，完成需求

解决方案一：一般实现

如果用最容易想到的方式，会做成继承关系，我们定义一个学校，学校下面有各个学院子类，而每个学院有各个专业，来展示页面，这样实际上是站在组织大小的角度来进行分层的，类图如下所示

但是大家考虑，学校和学院之间，真的是一个继承关系吗 ? 实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个专业，因此这种方案，不能很好实现的管理的操作，比如对学院专业的添加，删除，遍历等

其实更合适的一种方式是学校包含学院，学院包含专业，应该是一种组合关系，我们可以换一种思路，把学校、学院、专业都看做是组织结构，他们之间没有继承的关系，而是一个树形结构，可以更好的实现管理操作，其实这种思路就是组合模式，下面，我们一起来看下组合模式的基本介绍

基本介绍

组合模式（Composite Pattern），又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示 “整体-部分” 的层次关系

组合模式依据树形结构来组合对象，用来表示部分以及整体层次

组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象

原理类图

下面，我们一起来看下组合模式的原理类图，并梳理下组合模式中的角色

组合模式角色

Component：这是组合模式中的对象声明接口，在适当情况下，实现所有类共有的接口默认行为，用于访问和管理 Component子部件，Component 可以是抽象类或者接口
Leaf : 在组合中表示叶子节点，叶子节点没有子节点，是最末端的存放数据的结构
Composite：非叶子节点，用于存储子部件，在 Component 接口中实现子部件的相关操作，比如增加(add)，删除 (remove)

组合模式解决的问题

组合模式解决这样的场景，当我们的要处理的对象可以生成一颗树形结构，而我们要对树上的节点和叶子进行操作时，组合模式能够提供一致的方式，而不用考虑它是节点还是叶子

解决方案二：组合模式

类图展示

下面，我们使用组合模式解决院校展示问题，首先，我们先来画原理类图来分析思路

代码演示

/**
 * @Classname OrganizationComponent
 * @Created by 寂然
 * @Description I walk very slowly, but I never walk backwards
 */
public abstract class OrganizationComponent {

 private String name;

 private String desc; //描述

 public void add(OrganizationComponent component){

 //默认实现 抛出一个不支持操作的异常
 throw new UnsupportedOperationException();

 }

 public void remove(OrganizationComponent component){

 //默认实现 抛出一个不支持操作的异常
 throw new UnsupportedOperationException();

 }

 //构造器
 public OrganizationComponent(String name, String desc) {
 this.name = name;
 this.desc = desc;
 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public String getDesc() {
 return desc;
 }

 public void setDesc(String desc) {
 this.desc = desc;
 }

 //展示方法，做成抽象的
 public abstract void show();
}

/**
 * @Classname School
 * @Created by 寂然
 * @Description School也就是Composite ,可以管理College
 */
public class School extends OrganizationComponent {

 //构造器
 public School(String name, String desc) {
 super(name, desc);
 }

 //组合的是学院
 List<OrganizationComponent> componentList = new ArrayList<>();

 //重写add方法
 @Override
 public void add(OrganizationComponent component) {
 componentList.add(component);
 }

 //重写remove方法
 @Override
 public void remove(OrganizationComponent component) {
 componentList.remove(component);
 }

 @Override
 public String getName() {
 return super.getName();
 }

 @Override
 public String getDesc() {
 return super.getDesc();
 }

 @Override
 public void show() {

 System.out.println("--- " + getName() + "---");
 //遍历 componentList
 for (OrganizationComponent organizationComponent : componentList) {

 organizationComponent.show();
 }

 }
}

/**
 * @Classname College
 * @Created by 寂然
 * @Description I walk very slowly, but I never walk backwards
 */
public class College extends OrganizationComponent {

 public College(String name, String desc) {
 super(name, desc);
 }

 //组合的专业
 List<OrganizationComponent> componentList = new ArrayList<>();

 //重写add方法
 @Override
 public void add(OrganizationComponent component) {

 //将来实际业务中，Collage和School的添加方法不相同，都有各自的业务逻辑
 componentList.add(component);
 }

 //重写remove方法
 @Override
 public void remove(OrganizationComponent component) {
 componentList.remove(component);
 }

 @Override
 public String getName() {
 return super.getName();
 }

 @Override
 public String getDesc() {
 return super.getDesc();
 }

 @Override
 public void show() {

 System.out.println("--- " + getName() + "---");
 //遍历 componentList
 for (OrganizationComponent organizationComponent : componentList) {

 organizationComponent.show();
 }

 }
}

/**
 * @Classname Major
 * @Created by 寂然
 * @Description 专业
 */
public class Major extends OrganizationComponent{

 public Major(String name, String desc) {
 super(name, desc);
 }

 //本案例中，Major是叶子节点，不会包含其他的，所以不需要add,remove方法

 @Override
 public String getName() {
 return super.getName();

 }

 @Override
 public String getDesc() {
 return super.getDesc();

 }

 @Override
 public void show() {

 System.out.println(getName());
 }
}

/**
 * @Classname Client
 * @Created by 寂然
 * @Description 客户端
 */
public class Client {

 public static void main(String[] args) {

 //范围从大到小创建对象
 OrganizationComponent school = new School("清华大学", "中国顶级学府");

 //创建学院,并添加到学校中
 OrganizationComponent computerCollege = new College("计算机学院", "计算机学院");

 OrganizationComponent infoCollege = new College("信息工程学院", "信息工程学院");

 school.add(computerCollege);

 school.add(infoCollege);

 //创建各个学院下面的系 并加入到学院中
 computerCollege.add(new Major("计算机科学与技术","计算机科学与技术"));

 computerCollege.add(new Major("软件工程","软件工程"));

 computerCollege.add(new Major("网络空间安全","网络空间安全"));

 infoCollege.add(new Major("通信与信息系统","通信与信息系统"));

 infoCollege.add(new Major("信号与信息处理","信号与信息处理"));

 infoCollege.add(new Major("信息网络与复杂系统","信息网络与复杂系统"));

 school.show();
 }
}

假设我不关心整个大学的，我只关心某个学院的情况，只需要调用对应学院的 show() 方法即可，便捷的同时非常灵活，如果我们在其中新增一个层级关系，只需要继承 OrganizationComponent，进行聚合，重写里面的业务方法即可，（add，remove，show），所以我们来聊聊使用组合模式解决案例问题的优点

组合模式优势

组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，屏蔽了对象系统的层次差异性，使用一致的行为控制不同层次
扩展性非常高，可以很方便地增加 树枝节点 和 叶子节点 对象，并对现有类库无侵入，满足“开闭原则”

组合模式缺点

要求较高的抽象性，如果叶子和节点有很多差异性的话，例如很多属性和方法都不一样，不适合使用组合模式，而本案例院校展示，他们很多属性和方法都是共同的，类似一个树形结构

使用场景

处理类似树形结构，具备统一行为时（如操作系统目录结构，公司组织架构等）
想体现对象的部分-整体层次结构，典型的例如文件、文件夹的管理

（文件系统由文件和目录组成，每个文件里装有内容，而每个目录的内容可以有文件和目录，目录就相当于是由单个对象或组合对象组合而成，如果你想要描述的是这样的数据结构，那么你就可以使用组合模式）

HashMap源码刨析

Java的集合类 - HashMap 中就使用到了组合模式，下面我们通过一段测试代码来进行源码分析

public class Test {

 public static void main(String[] args) {

 HashMap<String, String> hashMap = new HashMap<>();

 hashMap.put("第一章","原理");

 HashMap<String, String> map = new HashMap<>();

 map.put("第二节","探索");

 map.put("第三节","出发");

 hashMap.putAll(map);

 System.out.println(hashMap);
 }
}

源码流程分析

首先我们来看 Map ，这是一个接口，其实他类似组合模式中的 Component，为什么这么说，可以看到，里面的put() 方法，和 putAll() 方法，有接口就有实现，接着来看，HashMap 实现了 Map 接口，并且实现了上述方法

 * @since   1.2
 */
public class HashMap<K,V> extends AbstractMap<K,V>
 implements Map<K,V>, Cloneable, Serializable {

 private static final long serialVersionUID = 362498820763181265L;

所以 HashMap 就是一个具体的 Composite，那叶子节点呢？

接着我们来看 HashMap 里面的 Node ,可以看到，Node 是 HashMap 里的一个静态内部类

static class Node<K,V> implements Map.Entry<K,V> {
 final int hash;
 final K key;
 V value;
 Node<K,V> next;

 Node(int hash, K key, V value, Node<K,V> next) {
 this.hash = hash;
 this.key = key;
 this.value = value;
 this.next = next;
 }

其实 Node 就是我们组合模式中的叶子节点，可以看到，Node里面就不再有 put，putAll 等关键方法了，因为他是叶子节点，是最末端的存放数据的结构了，所以只有一些默认方法

我们再来看 HashMap 中目标方法的实现，putVal 接受一个 K 和 V，然后以 Node 的形式放入 HashMap

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 boolean evict) {
 Node<K,V>[] tab; Node<K,V> p; int n, i;
 if ((tab = table) == null || (n = tab.length) == 0)
 n = (tab = resize()).length;
 if ((p = tab[i = (n - 1) & hash]) == null)
 tab[i] = newNode(hash, key, value, null);

大家是否可以大致理解这样一个关系，我们通过类图来进行展示

说明

Map 就是一个抽象的构建，即组合模式中的 Component
HashMap 是组合模式中的非叶子节点，即 Composite ，用于存储子部件，在 Component 接口中实现子部件的相关操作，比如put() , putAll() 等
Node 是组合模式中的叶子节点 leaf，里面没有关键方法的实现，是最末端的存放数据的结构