一. 组合模式
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. 构建建筑者1
AbstractBuilder builder = new BikeBuilder1();
builder.BuildFrame();
builder.BuildSeat();
builder.BuildTire();
//2. 构建自行车
Bike bike = builder.Build();
//3. 输出自行车的信息
bike.GetDetils();
//1. 构建建筑者2
AbstractBuilder builder2 = new BikeBuilder2();
builder2.BuildFrame();
builder2.BuildSeat();
builder2.BuildTire();
//2. 构建自行车
Bike bike2 = builder2.Build();
//3. 输出自行车的信息
bike2.GetDetils();
}
//4. 引入指挥者
{
Console.WriteLine("-------------------下面是 引入指挥者 构建自行车-------------------------");
//指挥者1
BikeDirector dirctor1 = new BikeDirector(new BikeBuilder1());
Bike bike1 = dirctor1.CreateBike();
bike1.GetDetils();
//指挥者2
BikeDirector dirctor2 = new BikeDirector(new BikeBuilder2());
Bike bike2 = dirctor2.CreateBike();
bike2.GetDetils();
}
运行效果：
4. 适用场景分析
建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。
A. 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。
B. 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。
原文链接：https://www.cnblogs.com/yaopengfei/p/13462519.html
![[Linux]-Ansible](https://img-blog.csdnimg.cn/0e79673580104bad8d3ac0e160008d9a.png#pic_center)
