【设计模式】组合模式 Composite Pattern

树形结构是软件行业很常见的一种结构，几乎随处可见,  比如： html 页面中的dom，产品的分类，通常一些应用或网站的菜单，windows form 中的控件继承关系，android中的view继承关系，部门的组织架构，windows 资源管理器 等等都是树形结构。

 

 

 

 

 

 

 

 

 

 

 

 

windows 资源管理

树形结构是很有特点的一种数据结构,  下图是一棵树：

树结构有几个术语：

根节点：最高的节点被称为根节点，上图中的红色节点是根节点。根节点没有父节点。

父节点：如果一个节点的下面链接着其它节点那上层节点被称作该节点的父节点，下层节点被称作父节点的子节点。除了根节点外子节点有且只有一个父节点。上图中的红色和黄色都是父节点。

叶子节点：每一个节点有0个或多个子节点。有0个（没有）子节点的节点称作叶子节点。上图中的绿色节点都是叶子节点。

如果要给树形结构上增加或者删除一些节点该如何处理呢？ 组合模式提供了面向对象优雅的处理这种数据结构的方法。

一、组合模式的定义

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

二、组合模式结构图

组合模式结构图

1、component（抽象构件）：

它可以是接口或抽象类，为叶子构件和容器构件对象声明接口，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，如增加子构件、删除子构件、获取子构件等。

2 、composite（容器构件）：

它在组合结构中表示容器节点对象，容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。

3、leaf（叶子构件）：

它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处理。

三、组合模式的示例代码

public abstract class component
{
    public abstract void operaton(int depth);
    public abstract void add(component component);
    public abstract void remove(component component);
    public abstract component getchild(int i);
}

public class composite : component
{
    private ilist<component> components = new list<component>();
    public override void operaton(int depth)
    {
        console.writeline(new string(' ', depth - 2) + "|");
        console.writeline(new string(' ', depth - 2) + "--" + this.gettype().name + " opration");
        foreach (var component in components)
        {
            component.operaton(depth + 2);
        }
    }

    public override void add(component component)
    {
        components.add(component);
    }

    public override void remove(component component)
    {
        components.remove(component);
    }

    public override component getchild(int i)
    {
        return components[i];
    }
}
public class leaf : component
{
    public override void operaton(int depth)
    {
        console.writeline(new string(' ', depth - 2) + "|");
        console.writeline(new string(' ', depth - 2) + "--" + this.gettype().name + " opration");
    }

    public override void add(component component)
    {
        console.writeline("cannot add to a leaf");
    }

    public override void remove(component component)
    {
        console.writeline("cannot remove from a leaf");
    }

    public override component getchild(int i)
    {
        throw new exception("cannot get a child from a leaf");

    }
}

客户端调用：

static void main(string[] args)
{
    component root = new composite.structure.composite();
    root.add(new leaf());
    root.add(new leaf());
            
    var composite = new composite.structure.composite();
    composite.add(new leaf());
    composite.add(new leaf());
           
    root.add(composite);

    var componsite2 = new composite.structure.composite();
    composite.add(componsite2);

    componsite2.add(new leaf());
    componsite2.add(new leaf());
           
    root.operaton(2);
    console.readkey();
}

  输出结果

四、组合模式实例

现在有一个新闻系统，这个新闻系统里有若干类别，每一个子类里又包含若干分类，理论上是一个无限级的树形结构，同时每个分类上都可能包含具体的新闻。结构如下：

新闻系统分类组织机构图

上图中的白色部分表示分类（category），绿色部分表示新闻（news), 现在要添加新闻的分类，删除新闻，以及将新闻展示出来。下面我们用组合模式来实现这些功能.

通过分析，可以提出构件 newscomponent, news 和category 三个对象，newscomponent相当于组合模式的抽象构建，category相当于 容器构建，news相当于叶子构建。这样我们就可以画出新闻系统核心uml图：

 

新闻系统代码：

public abstract class newscomponent
{
    protected string title;
    public newscomponent(string title)
    {
        this.title = title;
    }
    public abstract void add(newscomponent newscomponent);
    public abstract void remove(newscomponent newscomponent);
    public abstract void display(int depath);
}

public class category : newscomponent
{
    private ilist<newscomponent> categories = new list<newscomponent>();
    public category(string title):base(title)
    {
    }
    public override void add(newscomponent newscomponent)
    {
        categories.add(newscomponent);
    }

    public override void remove(newscomponent newscomponent)
    {
        categories.add(newscomponent);
    }

    public override void display(int depath)
    {
        console.writeline(new string('-', depath) + title);
        foreach (var category in categories)
        {
            category.display(depath+2);
        }
    }
}
public  class news: newscomponent
{
    private string content;
    public news(string title, string content):base(title)
    {
        this.content = content;
    }
    public override void add(newscomponent newscomponent)
    {
        console.writeline("cannot add to a news");
    }

    public override void remove(newscomponent newscomponent)
    {
        console.writeline("cannot remove from a news");
    }

    public override void display(int depath)
    {
        console.writeline(new string('-', depath) + this.title + "[content]:" + this.content);
    }
}

客户端调用：

static void main(string[] args)
{
    newscomponent newscomponent = new category("新闻");
    newscomponent.add(new category("政治新闻"));
    newscomponent.add(new news("【政治头条】-美国大选 特朗普生出将于将在北京时间明日凌晨3：45宣誓就职美国总统", "..."));
    newscomponent.add(new category("政治风云"));

    var a = new category("娱乐新闻");
    a.add(new news("【娱乐头条】-由王安全执导的<<*风云>>将于今天0点在各大影院全面上映", "...."));
    a.add(new category("娱乐八卦"));
    newscomponent.add(a);

    var b = new category("财经新闻");
    b.add(new news("【财经头条】-由于受土耳其货币危机的影响，美国及欧洲股市全线跌幅超1%", "..."));
            
    var c = new category("股市风云");
    b.add(c);

    c.add(new category("欧洲股市"));
    c.add(new category("美股风云"));
    c.add(new category("日韩股市"));
    newscomponent.add(b);

    var d = new category("体育新闻");
    var e = new category("篮球");
    d.add(e);
    var f=new category("nba");
    var g= new category("cba");
    e.add(g);
    e.add(f);
            
    newscomponent.add(d);           
 
    newscomponent.display(1);
    console.readkey();
}

输出结果：

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

在上面的实例中我们发现，component构件类中出现了add，remove方法，但是在叶子节点类（leaf）中不得不去实现，但是叶子节点是不需要这些方法的，看起来有些鸡肋。虽然客户端实现了无差别调用，虽然可以针对抽象编程，但是一旦调用到了叶子节点的这些方法，软件可能会出现异常或者无意义的调用。那么我们有什么方法来改变呢？

可以将这些方法从component中移到composite 中，这样就可以避免这种情况。只在component中定义composite和leaf公用的方法。

那么组合模式的结构图就变成这样：

这时图中的各个角色没有变化，仅仅是在component去掉了一些抽象方法，在调用的时就不能用抽象构建component来声明了，要用具体的composite来声明，这样在客户端调用时就需要区别对待composite和leaf了，不能针对抽象component构件编程了。

1、component2（抽象构件）：

它可以是接口或抽象类，为叶子构件和容器构件对象声明接口，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，如增加子构件、删除子构件、获取子构件等。

2 、composite2（容器构件）：

它在组合结构中表示容器节点对象，容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。

3、leaf2（叶子构件）：

它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处理。

在组合模式中根据抽象构建定义的形式, 可以将组合模式更称 安全组合模式和透明组合模式。

安全组合模式：

安全组合模式只在抽象构件类中定义叶子节点（leaf）和容器节点（composite）都共有的方法，将容器方法移至容器节点中， 它的一般结构如下图：

安全组合模式uml图

安全模式的好处是，在客户端调用叶子节点时不会出现调用不安全的方法，因为叶子节点没有该方法，抽象构件中也没有该方法。不好的地方是，叶子节点和容器节点的实现出现了差别，不能在客户端统一使用抽象构件（component）来编程了，必须要区别对待叶子节点（leaf）和容器节点（component）。

透明组合模式

透明组合模式是将对容器构件的管理方法都定义在抽象构件（component）中，在叶子节点（leaf）和容器节点（composite）都进行实现，在叶子节点中针对相关的管理方法进行相关异常处理，或者友好提示的处理实现,  一般情况下透明组合模式的uml如下：

 

透明模式uml图

透明模式的好处是可以给客户端调用时提供统一，无差别的对待叶子节点（leaf）和容器节点（composite），并且可以针对抽象构件（component）进行编程。透明模式的缺点是如果调用到叶子节点（leaf) 上的相关方法会导致程序异常。

六、组合模式的优点

1. 组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
2. 客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。
3. 在组合模式中增加新的容器构件和叶子构件都很方便，无须对现有类库进行任何修改，符合“开闭原则”。
4. 组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和容器对象的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。

七、组合模式的缺点

组合模式，控制容器节点的类型不太容易。

八、组合模式的使用场景

1. 在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，客户端可以一致地对待它们。
2. 在一个使用面向对象语言开发的系统中需要处理一个树形结构。
3. 在一个系统中能够分离出叶子对象和容器对象，而且它们的类型不固定，需要增加一些新的类型。

composite模式在平常的开发过程中使用的非常多，因为他提供了一种面向对象的操作树形结构的方法，树形结构在开发中频繁出现。