二十三种设计模式[8] - 组合模式(Composite Pattern)

前言      

组合模式，类结构模式的一种。在《设计模式 - 可复用的面向对象软件》一书中将之描述为“ 将对象组合成树状结构以表示 “部分-整体” 的层次结构，使得用户对单个对象和组合对象的使用具有一致性 ”。

       工作中我们经常会接触到一个对象中包含0个或多个其它对象，而其它对象依然包含0个或多个其它对象，这种结构我们称之为树状结构。组合模式就是通过递归去帮助我们去管理这类树状结构。

结构

需要角色如下：

• Component(所有节点的抽象)：所有对象（节点）的抽象或接口，用来定义所有节点的行为；
• Leaf(叶节点)：树状结构中的叶节点（没有子节点），继承抽象并实现行为；
• Composite(根节点)：树状结构中的根节点和子树的根节点，叶节点的容器，用来管理子节点；

场景

       最经典的树状结构莫过于操作系统中的文件目录结构。我们都知道在一个文件夹中会包含0个或多个文件，而这些文件中又会包含0个或多个文件。如下。

       在设计它的结构时往往会增加一个文件夹类，并根据文件夹内的文件类型维护相应的List去存储，以此类推。也就是说在文件夹类中，我们会根据不同的类型去创建不同的List，每当文件夹支持新的类型时我们都要去修改这个文件夹类，并不符合开闭原则。而且随着文件夹类支持的类型越多，这个类也将变得越来越复杂。

       使用组合模式使得我们在编码过程中不必过分关注各个文件的类型（只要是一个文件），并通过递归来简化文件夹类的设计。如下。

示例

public interface IFile
{
    IFile Father { set; get; }
    bool IsFolder { get; }
    string ShowMyself();
    IFile GetChild(int index);
    void Add(IFile obj);
    void Remove(IFile obj);
}

public class Txt : IFile
{
    public bool IsFolder => false;
    public string Name { set; get; } = string.Empty;
    public IFile Father { set; get; }

    public Txt(string name)
    {
        this.Name = name;
    }

    public string ShowMyself()
    {
        string spec = string.Empty;
        IFile father = this.Father;
        while (father != null)
        {
            spec += "  ";
            father = father.Father;
        }
        return $"{spec + this.Name}.txt";
    }

    public IFile GetChild(int index)
    {
        throw new NotImplementedException("Sorry,I have not Child");
    }

    public void Add(IFile obj)
    {
        throw new NotImplementedException("Sorry,I have not Child");
    }

    public void Remove(IFile obj)
    {
        throw new NotImplementedException("Sorry,I have not Child");
    }
}

public class Png : IFile
{
    public bool IsFolder => false;
    public string Name { set; get; } = string.Empty;
    public IFile Father { set; get; }

    public Png(string name)
    {
        this.Name = name;
    }

    public string ShowMyself()
    {
        string spec = string.Empty;
        IFile father = this.Father;
        while (father != null)
        {
            spec += "  ";
            father = father.Father;
        }
        return $"{spec + this.Name}.png";
    }

    public IFile GetChild(int index)
    {
        throw new NotImplementedException("Sorry,I have not child");
    }

    public void Add(IFile obj)
    {
        throw new NotImplementedException("Sorry,I have not child");
    }

    public void Remove(IFile obj)
    {
        throw new NotImplementedException("Sorry,I have not child");
    }
}

public class Folder : IFile
{
    public bool IsFolder => true;
    public string Name { set; get; } = string.Empty;
    public IFile Father { set; get; }
    private List<IFile> _childList = new List<IFile>();

    public Folder(string name)
    {
        this.Name = name;
    }

    public string ShowMyself()
    {
        string spec = string.Empty;
        IFile father = this.Father;
        while (father != null)
        {
            spec += "  ";
            father = father.Father;
        }

        string result = spec + this.Name;
        foreach (IFile child in _childList)
        {
            result += Environment.NewLine + child.ShowMyself();
        }

        return result;
    }

    public IFile GetChild(int index)
    {
        if(index >= this._childList.Count)
        {
            throw new Exception("越界");
        }

        return this._childList[index];
    }

    public void Add(IFile obj)
    {
        IFile father = this;
        while(father != null)
        {
            if(object.ReferenceEquals(obj, father))
            {
                throw new Exception("循环引用");
            }

            father = father.Father;
        }

        if(this._childList.Exists(t=> object.ReferenceEquals(t, obj)))
        {
            throw new Exception("子节点已存在");
        }

        obj.Father = this;
        this._childList.Add(obj);
    }

    public void Remove(IFile obj)
    {
        if(obj.Father == null
            || !this._childList.Exists(t=> object.ReferenceEquals(t, obj)))
        {
            throw new Exception("未找到子节点");
        }

        obj.Father = null;
        this._childList.Remove(obj);
    }
}

static void Main(string[] args)
{
    IFile folder = new Folder("我的文档");
    IFile txtFileA = new Txt("新建文本文档A");
    IFile pngFileA = new Png("QQ截图A");
    IFile folderA = new Folder("新建文件夹A");

    if (folder.IsFolder)
    {
        folder.Add(txtFileA);
        folder.Add(pngFileA);
        folder.Add(folderA);
    }

    IFile txtFileB = new Txt("新建文本文档B");
    IFile pngFileB = new Png("QQ截图B");

    if (folderA.IsFolder)
    {
        folderA.Add(txtFileB);
        folderA.Add(pngFileB);
    }
    
    Console.WriteLine(folder.ShowMyself());
    Console.ReadKey();
}

       在示例中，IFile接口定义了IFile类型的属性（在C#里，接口中可以定义属性）用来存储父节点，方便结构的向上操作。函数IsFolder用来标识当前对象是否是一个Composite。ShowMyself函数表示各个节点的基本操作，在Composite角色（Folder类）中一般递归调用子节点的ShowMyself函数。Add、Remove以及GetChild函数用来管理子节点。

       注意：管理子节点的操作函数是在组合模式中比较有争议的一个点。我们不难看出，对于叶节点（类Txt、Png）来说管理子节点的操作是没有意义的（因为它们没有子节点）。在IFile接口中声明这些操作能够保证节点的一致性以及结构的透明性，但会使调用者做一些无意义的操作（比如调用Txt类的Add函数）。而在Composite角色中定义这些操作虽然能够避免调用者的无意义操作，但会使节点的透明性和一致性降低。

       由于组合模式更加强调各个节点的一致性以及通明性，这里更加推荐在接口中定义那些管理子节点的函数。

       为了减少叶节点重复的实现这些对它无意义的子节点管理函数，可以使用适配器模式 (Adapter)对IFile接口做一个适配，为函数提供一个缺省的实现并使所有叶节点继承这个适配器。或者将IFile声明为一个抽象类并为函数提供缺省的实现。

总结

       在组合模式中，通过定义节点的公共接口提高结构的一致性以及透明性，并通过递归来简化类的设计。在我们对结构进行扩展时，只需要增加接口的实现类而无需对现有代码进行改动，符合开闭原则。但在使用的过程中，我们很难实现对各个节点的约束，并且递归的使用使得我们需要花费更多的时间去理解它的层次关系。递归的使用也使得我们需要更加谨慎的处理结构的深度，以免造成内存溢出。

 

       以上，就是我对组合模式的理解，希望对你有所帮助。

       示例源码：https://gitee.com/wxingChen/DesignPatternsPractice

       系列汇总：https://www.cnblogs.com/wxingchen/p/10031592.html

       本文著作权归本人所有，如需转载请标明本文链接（https://www.cnblogs.com/wxingchen/p/10078594.html）

转载于:https://www.cnblogs.com/wxingchen/p/10078594.html