《设计模式的艺术软件开发人员内功修炼之道》读书笔记十一

本文为第11章树形结构的处理——组合模式的读书笔记。

树形结构在软件中随处可见，例如操作系统中的目录结构、应用软件中的菜单、办公系统中的公司组织结构等。如何运用面向对象的方式来处理这种树形结构是组合模式需要解决的问题。组合模式通过一种巧妙的设计方案使得用户可以一致性地处理整个树形结构或者树形结构的一部分，也可以一致性地处理树形结构中的叶子节点（不包含子节点的节点）和容器节点（包含子节点的节点）。

以设计杀毒软件为例，文件夹是容器（Container），而不同类型的各种文件是其成员，也称为叶子（Leaf），一个文件夹也可以作为另一个更大的文件夹的成员，如果现在要对某一个文件夹进行操作，例如查找文件，那么需要对指定的文件夹进行遍历，如果存在子文件夹则打开其子文件夹继续遍历，如果是文件则判断之后返回查找结果。

image.png

public class ImageFile {
    private static final String TAG = "ImageFile";
    private String mName;

    public ImageFile(String name){
        mName = name;
    }

    public void killVirus(){
        Log.d(TAG,"对图像文件 " + mName + " 进行杀毒");
    }
}

public class TextFile {
    private static final String TAG = "TextFile";
    private String mName;

    public TextFile(String name){
        mName = name;
    }

    public void killVirus(){
        Log.d(TAG,"对文本文件 " + mName + " 进行杀毒");
    }
}

public class Folder {
    private static final String TAG = "Folder";
    private String mName;

    private ArrayList<Folder> mFolders = new ArrayList<>();
    private ArrayList<ImageFile> mImageFiles = new ArrayList<>();
    private ArrayList<TextFile> mTextFiles = new ArrayList<>();

    public Folder(String name){
        mName = name;
    }

    public void addFolder(Folder folder){
        mFolders.add(folder);
    }

    public void addImageFile(ImageFile imageFile){
        mImageFiles.add(imageFile);
    }

    public void addTextFile(TextFile textFile){
        mTextFiles.add(textFile);
    }

    public void killVirus(){
        Log.d(TAG,"对文件夹 " + mName + " 进行杀毒");

        for (Folder folder : mFolders){
            folder.killVirus();
        }

        for (ImageFile imageFile : mImageFiles){
            imageFile.killVirus();
        }

        for (TextFile textFile : mTextFiles){
            textFile.killVirus();
        }
    }
}

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    private Folder mFolder1;
    private Folder mFolder2;
    private Folder mFolder3;

    private ImageFile mImageFile1;
    private ImageFile mImageFile2;

    private TextFile mTextFile1;
    private TextFile mTextFile2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mFolder1 = new Folder("Sunny的资料");
        mFolder2 = new Folder("图像文件");
        mFolder3 = new Folder("文本文件");

        mImageFile1 = new ImageFile("a.jpg");
        mImageFile2 = new ImageFile("b.jpg");

        mTextFile1 = new TextFile("c.txt");
        mTextFile2 = new TextFile("d.txt");

        mFolder1.addFolder(mFolder2);
        mFolder1.addFolder(mFolder3);

        mFolder2.addImageFile(mImageFile1);
        mFolder2.addImageFile(mImageFile2);

        mFolder3.addTextFile(mTextFile1);
        mFolder3.addTextFile(mTextFile2);

        mFolder1.killVirus();
     }

}

D/Folder: 对文件夹 Sunny的资料 进行杀毒
D/Folder: 对文件夹 图像文件 进行杀毒
D/ImageFile: 对图像文件 a.jpg 进行杀毒
D/ImageFile: 对图像文件 b.jpg 进行杀毒
D/Folder: 对文件夹 文本文件 进行杀毒
D/TextFile: 对文本文件 c.txt 进行杀毒
D/TextFile: 对文本文件 d.txt 进行杀毒

以上代码可以文件完成杀毒的需求，但是该设计方案存在以下问题：
1.文件夹Folder类的设计和实现都非常复杂，需要定义多个集合存储不同类型的成员，而且需要针对不同的成员提供增加、删除和获取等管理和访问成员的方法，存在大量的冗余代码，系统维护较为困难。
2.由于系统没有提供抽象层，客户代码必须有区别地对待充当容器的文件夹Folder和充当叶子的ImageFile和TextFile，无法统一对他们进行处理
3.系统的灵活性和可扩展性差，如果需要增加新的类型的叶子和容器都需要对原有代码进行修改，例如如果需要在系统中增加一种新型的视频文件VideoFile，则必须修改Folder类的源代码，否则无法在文件夹中添加视频文件。

对于以上问题，可以通过组合模式去解决（虽然组合模式也会带来新的问题）。

组合模式概述：

对于树形结构，当容器对象（例如文件夹）的某一个方法被调用时，将遍历整个树形结构，寻找也包含整个方法的成员对象（可以是容器对象，也可以是叶子对象）并调用执行，牵一而动百，其中使用了递归调用的机制来对整个结构进行处理。由于容器对象和叶子对象在功能上的区别，在使用这些对象的代码中必须有区别地对待容器对象和叶子对象，而实际上大多数情况下希望一致地处理它们，因为对于这种对象的区别对待将会使程序非常复杂。组合模式为解决此类问题而诞生，它可以让叶子对象和容器对象的使用具有一致性。

组合模式定义

组合多个对象形成树形结构以表示具有“整体——部分”关系的层次结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性，组合模式又可以称为“整体——部分”模式，它是一种对象结构型模式。

在组合模式中引入了抽象构建类Component,它是所有容器类和叶子类的公共父类，客户端针对Component进行编程。
组合模式结构图所示。

image.png

在组合模式中包含以下3个角色。
1.Component（抽象构件）：它可以是接口或抽象类，为叶子构件和容器构件对象声明结构，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，例如增加子构件、删除子构件、获取子构件等。
2.Leaf( 叶子构件）：它在组合模式结构中表示叶子节点对象。叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过捕获异常等方式进行处理。
3.Composite( 容器构件）：它在组合模式结构中表示容器节点对象。容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用千存储子节点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。

组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。同时容器对象与抽象构件类之间还建立一个聚合关联关系，在容器对象中既可以包含叶子，也可以包含容器，以此实现递归组合，形成一个树形结构。

对于组合模式中的抽象构件角色，其典型代码如下。

public abstract class Component {
    public abstract void add(Component component);
    public abstract void remove(Component component);
    public abstract Component getChild(int i);
    public abstract void operation();
}

一般将抽象构件类设计为接口或抽象类，将所有子类共有方法的声明和实现放在抽象构件类中。对客户端而言，将针对抽象构件编程，而无需关心其具体子类是容器构件还是叶子构件。

叶子构件典型代码如下。由于叶子构件不能再包含子构件，因此在叶子构件中实现子构件管理和访问方法时需要提供异常处理或错误提示。当然，这无疑会给叶子构件的实现带来麻烦。

public class Leaf extends Component {
    @Override
    public void add(Component component) {
        //异常处理或错误提示
    }

    @Override
    public void remove(Component component) {
        //异常处理或错误提示
    }

    @Override
    public Component getChild(int i) {
        //异常处理或错误提示
        return null;
    }

    @Override
    public void operation() {
        //叶子构件具体业务方法的实现
    }
}

容器构件其典型代码如下。

 public class Composite extends Component {
    private ArrayList<Component> mComponents = new ArrayList<>();

    @Override
    public void add(Component component) {
        mComponents.add(component);
    }

    @Override
    public void remove(Component component) {
        mComponents.remove(component);
    }

    @Override
    public Component getChild(int i) {
        return mComponents.get(i);
    }

    @Override
    public void operation() {
        //容器构件具体业务方法的实现
        //递归调用成员构件的业务方法
        for (Component component : mComponents){
            component.operation();
        }
    }
}

在容器构件中实现了在抽象构件中声明的所以方法，既包括业务方法，也包括用于访问和管理成员子构件的方法，例如add()、remove()和getChild()等方法。需要注意的是在实现具体业务方法时，由于容器构件充当的是容器角色，包含成员构件，因此它将调用其成员构件的业务方法。在组合模式结构中，由于容器构件中仍然可以包含容器构件，因此在对容器构件进行处理时需要使用递归算法，即在容器构件的operation()方法中递归调用其成员构件的operation()方法。

如果使用组合模式来进行杀毒软件的框架设计，基本结构如图所示。

image.png

AbstractFile充当抽象构件类，Folder充当容器构架类，ImageFile和TextFile和VideoFile充当叶子构件类。
具体代码如下。

public abstract class AbstractFile {
    public abstract void add(AbstractFile abstractFile);
    public abstract void remove(AbstractFile abstractFile);
    public abstract  AbstractFile getChild(int i);
    public abstract void killVirus();
}

public class ImageFile extends AbstractFile{
    private static final String TAG = "ImageFile";
    private String mName;

    public ImageFile(String name){
        mName = name;
    }

    @Override
    public void add(AbstractFile abstractFile) {
        Log.d(TAG,"对不起，不支持该方法");
    }

    @Override
    public void remove(AbstractFile abstractFile) {
        Log.d(TAG,"对不起，不支持该方法");
    }

    @Override
    public AbstractFile getChild(int i) {
        Log.d(TAG,"对不起，不支持该方法");
        return null;
    }

    @Override
    public void killVirus(){
        Log.d(TAG,"对图像文件 " + mName + " 进行杀毒");
    }
    
}

public class TextFile extends AbstractFile{
    private static final String TAG = "TextFile";
    private String mName;

    public TextFile(String name){
        mName = name;
    }

    @Override
    public void add(AbstractFile abstractFile) {
        Log.d(TAG,"对不起，不支持该方法");
    }

    @Override
    public void remove(AbstractFile abstractFile) {
        Log.d(TAG,"对不起，不支持该方法");
    }

    @Override
    public AbstractFile getChild(int i) {
        Log.d(TAG,"对不起，不支持该方法");
        return null;
    }

    @Override
    public void killVirus(){
        Log.d(TAG,"对文本文件 " + mName + " 进行杀毒");
    }
    
}

public class VideoFile extends AbstractFile {
    private static final String TAG = "VideoFile";
    private String mName;

    public VideoFile(String name){
        mName = name;
    }

    @Override
    public void add(AbstractFile abstractFile) {
        Log.d(TAG,"对不起，不支持该方法");
    }

    @Override
    public void remove(AbstractFile abstractFile) {
        Log.d(TAG,"对不起，不支持该方法");
    }

    @Override
    public AbstractFile getChild(int i) {
        Log.d(TAG,"对不起，不支持该方法");
        return null;
    }

    @Override
    public void killVirus() {
        Log.d(TAG,"对视频文件 " + mName + " 进行杀毒");
    }
    
}

public class Folder extends AbstractFile{
    private static final String TAG = "Folder";
    private String mName;

    private ArrayList<AbstractFile> mAbstractFiles = new ArrayList<>();

    public Folder(String name){
        mName = name;
    }

    @Override
    public void add(AbstractFile abstractFile) {
        mAbstractFiles.add(abstractFile);
    }

    @Override
    public void remove(AbstractFile abstractFile) {
        mAbstractFiles.remove(abstractFile);
    }

    @Override
    public AbstractFile getChild(int i) {
        return mAbstractFiles.get(i);
    }

    public void killVirus(){
        Log.d(TAG,"对文件夹 " + mName + " 进行杀毒");
        for (AbstractFile abstractFile : mAbstractFiles){
            abstractFile.killVirus();
        }
    }
    
}

书上的例子是针对抽象构件编程，全部定义为AbstractFile。

image.png

但是我个人习惯声明的时候使用具体的类去声明，这样做差异在哪里呢？这里我没有相通，继续往后看。

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    private Folder mFolder1;
    private Folder mFolder2;
    private Folder mFolder3;
    private Folder mFolder4;

    private ImageFile mImageFile1;
    private ImageFile mImageFile2;

    private TextFile mTextFile1;
    private TextFile mTextFile2;

    private VideoFile mVideoFile1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mFolder1 = new Folder("Sunny的资料");
        mFolder2 = new Folder("图像文件");
        mFolder3 = new Folder("文本文件");
        mFolder4 = new Folder("视频文件");

        mImageFile1 = new ImageFile("a.jpg");
        mImageFile2 = new ImageFile("b.jpg");

        mTextFile1 = new TextFile("c.txt");
        mTextFile2 = new TextFile("d.txt");

        mVideoFile1 = new VideoFile("e.mp4");

        mFolder1.add(mFolder2);
        mFolder1.add(mFolder3);
        mFolder1.add(mFolder4);

        mFolder2.add(mImageFile1);
        mFolder2.add(mImageFile2);

        mFolder3.add(mTextFile1);
        mFolder3.add(mTextFile2);

        mFolder4.add(mVideoFile1);

        mFolder1.killVirus();
     }

}

最后log如下所示。

D/Folder: 对文件夹 Sunny的资料 进行杀毒
D/Folder: 对文件夹 图像文件 进行杀毒
D/ImageFile: 对图像文件 a.jpg 进行杀毒
D/ImageFile: 对图像文件 b.jpg 进行杀毒
D/Folder: 对文件夹 文本文件 进行杀毒
D/TextFile: 对文本文件 c.txt 进行杀毒
D/TextFile: 对文本文件 d.txt 进行杀毒
D/Folder: 对文件夹 视频文件 进行杀毒
D/VideoFile: 对视频文件 e.mp4 进行杀毒

透明组合模式与安全组合模式

通过引入组合模式，软件具有良好的可扩展性，在增加新的文件类型时，无须修改现有类库代码，只需要增加一个新的文件类作为AbstractFile类的子类即可，但是由于在AbstractFile中声明了大量用于管理和访问成员类构件的方法，例如add()、remove()等方法，就不得不在新增的文件类中实现这些方法，提供对应的错误提示和异常处理。为了简化代码，有以下两种解决方案。
解决方案一： 将叶子构件的add()、remove()等方法的实现代码移至AbstractFile中。

public abstract class AbstractFile {
    private static final String TAG = "AbstractFile";

    public void add(AbstractFile abstractFile) {
        Log.d(TAG,"对不起，不支持该方法");
    }

    public void remove(AbstractFile abstractFile) {
        Log.d(TAG,"对不起，不支持该方法");
    }

    public AbstractFile getChild(int i) {
        Log.d(TAG,"对不起，不支持该方法");
        return null;
    }

    public abstract void killVirus();
}

如果客户端代码针对抽象类AbstractFile编程，在调用文件对象的这些方法时将出现错误提示。如果不希望出现任何错误提示，可以在客户端定义文件对象时不使用抽象层，而直接使用具体叶子构件本身。

image.png

不透明的使用方式：即客户端不能全部针对抽象构建类编程。
前面的疑问得到了解答。原来全部使用抽象构建类声明这种方式叫做透明的使用方式。当使用具体叶子构件类型来定义叶子对象的时候，就是不透明的使用。但是透明地处理的好处又是什么呢？
解决方案二：在抽象构件AbstractFile中不声明任何用于访问和管理成员构件的方法。代码如下：

public abstract class AbstractFile {
    public abstract void killVirus();
}

此时，由于在AbstractFile 中没有声明add() 、remove() 等访问和管理成员的方法，其叶子构件子类无须提供实现；而且无论客户端如何定义叶子构件对象都无法调用到这些方法，不需要做任何错误和异常处理，容器构件再根据需要增加访间和管理成员的方法。但这时候也存在一个问题：客户端不得不使用容器类本身来声明容器构件对象，否则无法访问其中新增的add()、remove() 等方法，如果客户端一致性地对待叶子和容器，将会导致容器构件的新增对客户端不可见，客户端代码对千容器构件无法再使用抽象构件来定义。客户端代码片段如下：

image.png

在使用组合模式时，根据抽象构件类的定义形式，可将组合模式分为透明组合模式和安全组合模式两种形式。

透明组合模式
透明组合模式中，抽象构件Component中声明了所有用于管理成员对象的方法，包括add()、remove()以及getChi ld() 等方法，这样做的好处是确保所有的构件类都有相同的接口。在客户端看来，叶子对象与容器对象所提供的方法是一致的，客户端可以相同地对待所有的对象。透明组合模式也是组合模式的标准形式，虽然上面的解决方案1 在客户端可以有不透明的实现方法，但是由于在抽象构件中包含add()、remove()等方法，因此它还是透明组合模式。透明组合模式的完整结构如图所示。

image.png

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

安全组合模式
安全组合模式中，在抽象构件Component 中没有声明任何用于管理成员对象的方法，
而是在Composite 类中声明并实现这些方法。这种做法是安全的，因为根本不向叶子对象提供这些管理成员对象的方法，对千叶子对象，客户端不可能调用到这些方法，这就是解决方案2 所采用的实现方式。安全组合模式的结构如图所示。

image.png

安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构
件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别地对待叶子构件和容器构件。在实际应用中，安全组合模式的使用频率也非常高，在Java AWT 中使用的组合模式就是安全组合模式。

现以一公司组织结构为例，使用组合模式。

image.png

在Sunny 软件公司的内部办公系统(Sunny OA 系统）中，有一个与公司组织结构对应的树形菜单，行政人员可以给各级单位下发通知，这些单位可以是总公司的一个部门，也可以是一个分公司，还可以是分公司的一个部门。用户只需要选择一个根节点即可实现通知的下发操作，而无须关心具体的实现细节。这不正是组合模式的“特长”吗？于是Sunny 公司开发人员绘制了如图11-9 所示结构图。在图11-9 中，“单位”充当了抽象构件角色，”公司”充当了容器构件角色，”研发部”、“财务部”和“人力资源部”充当了叶子构件角色。

image.png

通过与上面的杀毒软件去对比发现，叶子构件与抽象构件类的关系都是继承，容器构件与抽象构件类的关系是聚合。

组合模式总结：

组合模式使用面向对象的思想来实现树形结构的构建与处理，描述了如何将容器对象和叶子对象进行递归组合，实现简单，灵活性好。由于在软件开发中存在大鼠的树形结构，因此组合模式是一种使用频率较高的结构型设计模式， Java SE 中的AWT 和Swing 包的设计就基于组合模式，在这些界面包中为用户提供了大最的容器构件（例如Container) 和成员构件（例如Check box 、Button 和TextComponent 等），其结构如图11-10 所示。

image.png

在图11-10 中， Component 类是抽象构件， Checkbox 、Button 和TextComponent 是叶子构件，而Container 是容器构件。在AWT 中包含的叶子构件还有很多，因为篇幅限制没
有在图中一一列出。在一个容器构件中可以包含叶子构件，也可以继续包含容器构件，这些叶子构件和容器构件一起组成了复杂的GUI(Graphical User Interface, 图形用户界面）。
除此以外，在XML 解析组织结构树处理、文件系统设计等领域，组合模式都得到了广泛应用。

ps：这里类似Android中的View和ViewGroup。
实际上抽象构件类，不一定是一个抽象类。
简单看下源码：
public class View implements Drawable.Callback, KeyEvent.Callback,AccessibilityEventSource{}
public class TextView extends View ...{}

public abstract class ViewGroup extends View implements ViewParent, ViewManager {
    protected ArrayList<View> mDisappearingChildren;
..........
    public void addView(View child) {
        addView(child, -1);
    }
...........
}

public interface ViewManager
{
    public void addView(View view, ViewGroup.LayoutParams params);
    public void updateViewLayout(View view, ViewGroup.LayoutParams params);
    public void removeView(View view);
}

View,TextView以及ViewGroup关系图如下。

image.png

如同上面的文件夹的例子一样，在树形结构中实际的根节点是Folder，这里的根节点ViewGroup，抽象构件类View并不在树形结构中，只是实际可以在编程时使用抽象构建类进行编程（例如声明使用抽象构建类）。另，这里使用的是安全组合模式，抽象构件类View中没有没有声明任何用于管理成员对象的方法，
而是在ViewGroup中声明并实现这些方法（这里是addView等方法）。
参考链接：
Android 组合模式(View与ViewGroup)

组合模式的主要优点如下：
(1) 组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
(2) 客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。
(3) 在组合模式中增加新的容器构件和叶子构件都很方便，无须对现有类库进行任何修改，符合开闭原则。
(4) 组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和容器对象的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。
主要缺点
组合模式的主要缺点是：在增加新构件时很难对容器中的构件类型进行限制。有时候希望一个容器中只能有某些特定类型的对象，例如在某个文件夹中只能包含文本文件，使用组合模式时，不能依赖类型系统来施加这些约束，因为它们都来自于相同的抽象层，在这种情况下，必须通过在运行时进行类型检查来实现，这个实现过程较为复杂。
适用场景
在以下情况下可以考虑使用组合模式：
(1) 在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，客户端可以一致性地对待它们。
(2) 在一个使用面向对象语言开发的系统中需要处理一个树形结构。
(3) 在一个系统中能够分离出叶子对象和容器对象，而且它们的类型不固定，需要增加一些新的类型。