设计模式-组合模式和建筑者模式详解

一. 组合模式

1. 背景

在现实生活中，存在很多“部分-整体”的关系，例如，大学中的部门与学院、总公司中的部门与分公司、学习用品中的书与书包、生活用品中的衣月艮与衣柜以及厨房中的锅碗瓢盆等。在软件开发中也是这样，例如，文件系统中的文件与文件夹、窗体程序中的简单控件与容器控件等。对这些简单对象与复合对象的处理，如果用组合模式来实现会很方便。

2. 定义和特点

(1). 定义：有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。

(2). 优点：

　　A. 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；

　　B. 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；

(3). 缺点

　　A. 设计较复杂，客户端需要花更多时间理清类之间的层次关系；

　　B. 不容易限制容器中的构件；

　　C. 不容易用继承的方法来增加构件的新功能；

3. 具体实现

(1). 模式结构

　 可以自身嵌套结构。

(2). 使用场景

　 存储上下级关系，CEO→技术主管→员工；CEO→销售主管→员工。

(3). 代码实操

上下级自身嵌套代码：

     /// <summary>/// 员工类/// </summary>public class Employee{private string name;private string dept;private int salary;//代表下级子类private List<Employee> subordinates;//构造函数public Employee(string name, string dept, int sal){this.name = name;this.dept = dept;this.salary = sal;subordinates = new List<Employee>();}public void add(Employee e){subordinates.Add(e);}public void remove(Employee e){subordinates.Remove(e);}public List<Employee> getSubordinates(){return subordinates;}public string toString(){return ("Employee :[ Name : " + name+ ", dept : " + dept + ", salary :"+ salary + " ]");}}

测试代码：

            {// 1、树形机构的场景，使用组合模式Employee CEO = new Employee("张三", "CEO", 30000);Employee headMarketing = new Employee("李四", "技术经理", 20000);Employee headSales = new Employee("王五", "销售经理", 20000);Employee clerk1 = new Employee("赵六", "销售", 10000);Employee clerk2 = new Employee("钱七", "销售", 10000);Employee salesExecutive1 = new Employee("Tony", "技术", 10000);Employee salesExecutive2 = new Employee("Mark", "技术", 10000);CEO.add(headSales);CEO.add(headMarketing);headSales.add(clerk1);headSales.add(clerk2);headMarketing.add(salesExecutive1);headMarketing.add(salesExecutive2);//打印该组织的所有员工Console.WriteLine(CEO.toString());foreach (Employee headEmployee in CEO.getSubordinates()){Console.WriteLine(headEmployee.toString());foreach (Employee employee in headEmployee.getSubordinates()){Console.WriteLine(employee.toString());}}}

运行结果：

4. 适用场景分析

　A. 在需要表示一个对象整体与部分的层次结构的场合。

　B. 要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合。

更多C++后台开发技术点知识内容包括C/C++，Linux，Nginx，ZeroMQ，MySQL，Redis，MongoDB，ZK，流媒体，音视频开发，Linux内核，TCP/IP，协程，DPDK多个高级知识点。

C/C++Linux服务器开发高级架构师/C++后台开发架构师免费学习地址

【文章福利】另外还整理一些C++后台开发架构师 相关学习资料，面试题，教学视频，以及学习路线图，免费分享有需要的可以点击领取

二. 建筑者模式

1. 背景

　在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。例如，计算机是由 OPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的，采购员不可能自己去组装计算机，而是将计算机的配置要求告诉计算机销售公司，计算机销售公司安排技术人员去组装计算机，然后再交给要买计算机的采购员。

　生活中这样的例子很多，如游戏中的不同角色，其性别、个性、能力、脸型、体型、服装、发型等特性都有所差异；还有汽车中的方向盘、发动机、车架、轮胎等部件也多种多样；每封电子邮件的发件人、收件人、主题、内容、附件等内容也各不相同。

　以上所有这些产品都是由多个部件构成的，各个部件可以灵活选择，但其创建步骤都大同小异。这类产品的创建无法用前面介绍的工厂模式描述，只有建造者模式可以很好地描述该类产品的创建。

2. 定义和特点

(1). 定义

　　指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

(2). 优点

　A. 各个具体的建造者相互独立，有利于系统的扩展。

　B. 客户端不必知道产品内部组成的细节，便于控制细节风险。

(3). 缺点

　A. 产品的组成部分必须相同，这限制了其使用范围。

　B. 如果产品的内部变化复杂，该模式会增加很多的建造者类。

(4). 与工厂方法模式的区别

　建造者模式注重零部件的组装过程，而工厂方模式更注重零部件的创建过程，但两者可以结合使用。

3. 具体实现

(1). 模式结构

　建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成。 　

　A. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。

　B. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。

　C. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。

　D. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

PS：如果创建的产品种类只有一种，只需要一个具体建造者，这时可以省略掉抽象建造者，甚至可以省略掉指挥者角色。

结构图如下：

(2). 使用场景

　现在要构建自行车，包括核心组件frame、seat、tire，而每个组件可选的材料有多种，自行车的构建顺序是固定的，比如按照这个顺序：BuidFrame、BuildSeat、BuildTire。这个场景就可以使用建筑者模式。

(3). 代码实操

各种自行车材料代码：

    /// <summary>/// 自行车框架/// </summary>public interface IFrame{void show();}/// <summary>/// 自行车座椅/// </summary>public interface ISeat{void show();}/// <summary>/// 自行车轮胎/// </summary>public interface ITire{void show();}/// <summary>/// 合金自行车框架1/// </summary>public class AlloyFrame1 : IFrame{public void show(){Console.WriteLine("我是合金自行车框架1");}}/// <summary>/// 合金自行车框架2/// </summary>public class AlloyFrame2 : IFrame{public void show(){Console.WriteLine("我是合金自行车框架2");}}/// <summary>/// 真皮座椅1/// </summary>public class DermisSeat1 : ISeat{public void show(){Console.WriteLine("我是真皮座椅1");}}/// <summary>/// 真皮座椅2/// </summary>public class DermisSeat2 : ISeat{public void show(){Console.WriteLine("我是真皮座椅2");}}/// <summary>/// 结实的轮胎1/// </summary>public class SolidTire1 : ITire{public void show(){Console.WriteLine("我是结实的轮胎1");}}/// <summary>/// 结实的轮胎2/// </summary>public class SolidTire2 : ITire{public void show(){Console.WriteLine("我是结实的轮胎2");}}

自行车代码：

 /// <summary>/// 自行车类/// </summary>public class Bike{/// <summary>/// 自行车框架/// </summary>public IFrame frame { set; get; }/// <summary>/// 自行车座椅/// </summary>public ISeat seat { set; get; }/// <summary>/// 自行车 轮胎/// </summary>public ITire tire { set; get; }/// <summary>/// 获取自行车的详情信息/// </summary>public void GetDetils(){Console.WriteLine("自行车的详细信息如下：");frame.show();seat.show();tire.show();}}

抽象建筑者和具体建筑者：

 /// <summary>/// 抽象建筑者类/// 如果只有一个具体的建筑者类，则可以省略该抽象建筑者类的/// </summary>public abstract class AbstractBuilder{public Bike mBike = new Bike();public abstract void BuildFrame();public abstract void BuildSeat();public abstract void BuildTire();/// <summary>/// 返回自行车对象/// </summary>/// <returns></returns>public abstract Bike Build();}/// <summary>/// 自行车建筑者类1/// </summary>public class BikeBuilder1: AbstractBuilder{/// <summary>/// 构建frame/// </summary>public override void BuildFrame(){mBike.frame = new AlloyFrame1();}/// <summary>/// 构建seat/// </summary>public override void BuildSeat(){mBike.seat = new DermisSeat1();}/// <summary>/// 构建tire/// </summary>public override void BuildTire(){mBike.tire = new SolidTire1();}/// <summary>/// 返回直行车对象/// </summary>/// <returns></returns>public override Bike Build(){return mBike;}}/// <summary>/// 自行车建筑者类2/// </summary>public class BikeBuilder2 : AbstractBuilder{/// <summary>/// 构建frame/// </summary>public override void BuildFrame(){mBike.frame = new AlloyFrame2();}/// <summary>/// 构建seat/// </summary>public override void BuildSeat(){mBike.seat = new DermisSeat2();}/// <summary>/// 构建tire/// </summary>public override void BuildTire(){mBike.tire = new SolidTire2();}/// <summary>/// 返回直行车对象/// </summary>/// <returns></returns>public override Bike Build(){return mBike;}}

指挥者：

  /// <summary>/// 指挥者/// 调用建造者中的方法完成复杂对象的创建/// 如果只有一个建筑者的话,可以省略该指挥者的角色/// </summary>public class BikeDirector{private AbstractBuilder _builder;public BikeDirector(AbstractBuilder builder){this._builder = builder;}/// <summary>/// Bike的构建和组装/// </summary>/// <returns></returns>public Bike CreateBike(){_builder.BuildFrame();_builder.BuildSeat();_builder.BuildTire();return _builder.Build();}}

测试代码：

                //1.普通模式{Console.WriteLine("-------------------下面是普通模式构建自行车-------------------------");//1. 构建自行车Bike b = new Bike();b.frame = new AlloyFrame1();b.seat = new DermisSeat2();b.tire = new SolidTire1();//2. 输出自行车信息b.GetDetils();}//2. 使用建筑者模式{Console.WriteLine("-------------------下面是使用建筑者模式构建自行车-------------------------");//1. 构建建筑者BikeBuilder1 builder = new BikeBuilder1();builder.BuildFrame();builder.BuildSeat();builder.BuildTire();//2. 构建自行车Bike bike = builder.Build();//3. 输出自行车的信息bike.GetDetils();}//3. 引入抽象建筑者父类{Console.WriteLine("-------------------下面是 引入抽象建筑者父类 构建自行车-------------------------");//1. 构建建筑者1AbstractBuilder builder = new BikeBuilder1();builder.BuildFrame();builder.BuildSeat();builder.BuildTire();//2. 构建自行车Bike bike = builder.Build();//3. 输出自行车的信息bike.GetDetils();//1. 构建建筑者2AbstractBuilder builder2 = new BikeBuilder2();builder2.BuildFrame();builder2.BuildSeat();builder2.BuildTire();//2. 构建自行车Bike bike2 = builder2.Build();//3. 输出自行车的信息bike2.GetDetils();}//4. 引入指挥者{Console.WriteLine("-------------------下面是 引入指挥者 构建自行车-------------------------");//指挥者1BikeDirector dirctor1 = new BikeDirector(new BikeBuilder1());Bike bike1 = dirctor1.CreateBike();bike1.GetDetils();//指挥者2BikeDirector dirctor2 = new BikeDirector(new BikeBuilder2());Bike bike2 = dirctor2.CreateBike();bike2.GetDetils();}

运行效果：

4. 适用场景分析

　建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。

　A. 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。

　B. 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

原文链接：https://www.cnblogs.com/yaopengfei/p/13462519.html