设计模式之Composite（组合）模式

1、出现原因

1、在面向对象系统中，我们常会遇到一类具有“容器”特征的对象——即它们在充当对象的同时，又是其他对象的容器。

如何将“客户代码与复杂的对象容器结构”解耦（将这种组合容器对象设计成树形结构，从而可以对下面所有的容器都可以通过最上层 的根对象 实现 统一 的调用，进而客户端就不在乎 其内部是怎么实现的，耦合 降低了）？让对象容器自己来实现自身的复杂结构，从而使得客户代码就像处理简单对象一样来处理复杂的对象容器？

2、意图

将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。(通过 树根对象的 执行方法，从而调用 他下面的所有的子节点)

3、结构图

4、代码演示 

业务实现：

     /// <summary>
     /// 抽象的统一 入口
     /// </summary>
     public abstract class AbsCompany
     {
         protected string Name { set; get; }

         public AbsCompany(string str)
         {
             this.Name = str;
         }

         public abstract void Add(AbsCompany item);

         public abstract void Remove(AbsCompany item);

         public abstract void Show();

         public abstract void DoDuty();

         //增加子节点的 方式可以 设置 父节点属性
         public AbsCompany Father { set; get; }

     }

     /// <summary>
     /// 叶子节点1
     /// </summary>
     public class HRPart : AbsCompany
     {
         public HRPart(string name)
             : base(name)
         {
         }
         //叶子节点不能实现 增删节点操作
         public override void Add(AbsCompany item)
         {
             throw new InvalidOperationException("叶子节点不允许操作");
         }

         public override void Remove(AbsCompany item)
         {
             throw new InvalidOperationException("叶子节点不允许操作");
         }

         public override void Show()
         {
             Console.WriteLine("人力资源部："+base.Name);
         }

         public override void DoDuty()
         {
             Console.WriteLine(base.Name+"：致力于招募人才");
         }
     }

     /// <summary>
     /// 叶子节点2
     /// </summary>
     public class MoneyPart : AbsCompany
     {
         public MoneyPart(string name)
             : base(name)
         {
         }

         //叶子节点不能实现 增删节点的操作
         public override void Add(AbsCompany item)
         {
             throw new InvalidOperationException("叶子节点不允许操作");
         }

         public override void Remove(AbsCompany item)
         {
             throw new InvalidOperationException("叶子节点不允许操作");
         }

         public override void Show()
         {
             Console.WriteLine("财务部分："+base.Name);
         }

         public override void DoDuty()
         {
             Console.WriteLine(base.Name+"：致力于管理好公司的财务");
         }
     }

     /// <summary>
     /// 树形节点（Composite）
     /// </summary>
     public class Company : AbsCompany
     {
         public Company(string name)
             : base(name)
         {
         }

         //对应 上级节点是 聚合关系
         private List<AbsCompany> items = new List<AbsCompany>();

         public override void Add(AbsCompany item)
         {
             items.Add(item);

             //父节点方式：增加子节点
             item.Father = this;
         }

         public override void Remove(AbsCompany item)
         {
             items.Remove(item);

             //父节点 方式 ：删除子节点：
             item.Father = null;//此节点没有父节点了，因此它的父节点下面就没有这个子节点了
         }
         /// <summary>
         /// 实现了加载  次节点下面的所有节点：递归
         /// （**）调用的顺序：当 调用到一个子节点，会将他的下面 子节点全都调用完成之后，才调用他的兄弟节点
         /// </summary>
         /// <param name="item"></param>
         public override void Show()
         {
             //先显示自己
             Console.WriteLine("公司名称："+base.Name);

             //显示下面所有的子节点的 名称
             foreach (var item in items)
             {
                 item.Show();
             }

             //注意：要是使用 父节点的方式 实现树形组合：这个时候递归遍历下面所有的子节点的方式就不能执行了
         }

         public override void DoDuty()
         {
             //先执行自己的职责
             Console.WriteLine(base.Name+"：致力于管理好整个公司");

             //在执行 他的节点下面的所有的节点的 所有的职责
             foreach (var item in items)
             {
                 item.DoDuty();
             }

         }
     }

Composite模式

客户端调用代码：

             //都是通过AbsCompany，后面创建的过程 可以通过 反射进行创建。所以客户 就可以直接 通过树形节点的 最顶层节点 就行创建下面一系列的节点，不用关心具体的实现  （耦合 大大降低）
             AbsCompany HeadCompany = new Company("阿里巴巴");
             AbsCompany hr1 = new HRPart("总公司人力资源部");
             AbsCompany money1 = new MoneyPart("总公司财务部");
             AbsCompany company1 = new Company("上海分公司");
             AbsCompany company2 = new Company("北京办事处");
             AbsCompany hr2 = new HRPart("上海分公司人力资源部");
             AbsCompany money2 = new MoneyPart("上海分公司财务部");
             AbsCompany hr3 = new HRPart("北京人力资源部");
             AbsCompany money3 = new MoneyPart("北京财务部门");
             AbsCompany company3 = new Company("深圳办事处");
             AbsCompany hr4 = new HRPart("深圳人力资源部");
             AbsCompany money4 = new MoneyPart("深圳财务部");
             HeadCompany.Add(company1);
             HeadCompany.Add(hr1);
             HeadCompany.Add(money1);
             company1.Add(hr2);
             company1.Add(money2);
             company1.Add(company2);
             company1.Add(company3);
             company2.Add(hr3);
             company2.Add(money3);
             company3.Add(hr4);
             company3.Add(money4);
             HeadCompany.Show();
             HeadCompany.DoDuty();

客户端调用代码

每个对象的创建可以通过反射的方式进行创建

5、实现Composite模式两种方式

透明方式和安全模式

7、适用性

两个或者多个类有相似的形式，或者共同代表某个完整的概念，（所有的类都有几乎相同的成员，并且叶子节点可以含有多个）外界的用户也希望他们合而为一(通过一个抽象的基类和接口 就可以 指向所有的类，用户不用关心具体的实现)，就可以把这几个类“组合”起来，成为一个新的类，用户只需要调用这个新的类就可以了。

8、总结

1、Composite模式采用树形结构来实现普遍存在的对象容器，从而将“一对多”的关系转化为“一对一”的关系，使得客户代码可以一致地处理对象和对象容器，无需关心处理的是单个的对象，还是组合的对象容器。（因为这些对象都有几乎相同的结构，所以可以通过抽象基类或接口 进行 调用）

2、将“客户代码与复杂的对象容器结构”解耦(因为所有的类含有 几乎相同的 结构，所以可以通过抽象基类或 接口进行调用，所以用户 只需直接 调用，不许关心 其内部是怎么实现的，耦合大大降低)是Composite模式的核心思想，解耦之后，客户代码将与纯粹的抽象接口——而非对象容器的内部实现结构——发生依赖关系，从而更能“应对变化”。（客户端和抽象接口发生依赖关系）

3、Composite模式中，是将“Add和Remove等和对象容器相关的方法”定义在“表示抽象对象的Component类”中，还是将其定义在“表示对象容器的Composite类”中，是一个关乎“透明性”和“安全性”的两难问题，需要仔细权衡。这里有可能违背面向对象的“单一职责原则”(基于透明性：则违背；基于安全性：则遵守)，但是对于这种特殊结构，这又是必须付出的代价。

4、Composite模式在具体实现中，可以让父对象中的子对象反向追溯；如果父对象有频繁的遍历需求，可使用缓存技巧来改善效率。

5、Composite模式一般都 和 Builder 模式组合起来使用（Builder模式：http://www.cnblogs.com/xiaoxiaogogo/p/3572618.html）,每个对象的创建通过Builder模式进行创建（将表示和创建隔离，达到解耦的目的）