[A]. 总结4.对象创建：工厂方法，抽象工厂，原型模式，构建器

声明：本栏目的 [A] 系列的学习笔记，学习对象为 B 站授课视频 C++设计模式（李建忠），参考教材为《设计模式：可复用面向对象软件的基础》。本栏目 [A] 系列文章中的图件和笔记，部份来自上述资源。

从封装变化角度对模式分类！：

• 组件协作
• 单一职责
• 对象创建
  通过“对象创建” 模式绕开new，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
  典型模式
  • 工厂方法 Factory Method
  • 抽象工厂 Abstract Factory
  • 原型模式 Prototype
  • 构建器 Builder
• 对象性能
• 接口隔离
• 状态变化
• 数据结构
• 行为变化
• 领域问题

工厂方法 Factory Method

• 动机：在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。

• 如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合？

• 定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟（目的：解耦，手段：虚函数）到子类。

• 面向接口编程，变量要声明成抽象基类，这样才能更好的应对变化。为什么要面向接口编程，参考依赖倒置原则。不要依赖具体的类，而是依赖抽象类。

• 场景举例：文件分割工具，文件类型有txt文件，二进制文件，图片文件和video文件。如下：

class ISplitter{
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};

class BinarySplitter : public ISplitter{
    ...
};

class TxtSplitter: public ISplitter{
    ...
};

class PictureSplitter: public ISplitter{
    ...
};

class VideoSplitter: public ISplitter{
    ...
};

• 进行文件分割的类，需要指定文件类别（变化），一般做法如下：

class MainForm : public Form
{
	TextBox* txtFilePath;
	TextBox* txtFileNumber;
	ProgressBar* progressBar;

public:
	void Button1_Click(){
		ISplitter * splitter=
            new BinarySplitter();//依赖具体类
        splitter->split();

	}
};

• 以上 MainForm 就依赖具体的类，BinarySplitter，如果要更换成 TxtSplitter 就需要更改 MainForm 里面的代码，这不符合 “对更改封闭，对拓展开放”的原则。那么 MainForm 应该只依赖抽象的基类，工厂方法的实现代码如下：

//具体工厂
class BinarySplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new BinarySplitter();
    }
};

class TxtSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new TxtSplitter();
    }
};

class PictureSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new PictureSplitter();
    }
};

class VideoSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new VideoSplitter();
    }
};

/// MainForm 将具体分割哪个文件类别的变化元素抽离出来，推到未来决定，
///  由 MainForm 的使用者决定。
class MainForm : public Form
{
    SplitterFactory*  factory;//工厂

public:
    MainForm(SplitterFactory*  factory){
        this->factory=factory;
    }
	void Button1_Click(){
		ISplitter * splitter=
            factory->CreateSplitter(); //多态new
        splitter->split();

	}
};

• 以上 MainFrom 依赖的都是抽象类，没有依赖任何具体实现细节。但程序总要依赖容易变化的具体类，设计模式的原则不是消灭变化，变化不可能被消灭，但我们要把变化驱逐到某个局部的区域，关进笼子里，避免变化充斥着整个项目。以上就是将变化赶出MainFrom。

• 结构
  

要点总结：

• Factory Method模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系(new)会导致软件的脆弱。
• Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。
• Factory Method模式解决“单个对象”的需求变化。缺点在于要求创建方法/参数相同。

抽象工厂 Abstract Factory

• 动机：在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。

• 如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

• 定义：提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。

• 场景举例：创建数据访问模块，需要创建数据库的链接对象，命令对象，reader对象，并且要支持 sql，oracle 等不同的数据库 。如下：

//数据库访问有关的基类
class IDBConnection{
    
};
class IDBCommand{
    
};
class IDataReader{
    
};

class IDBFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
    virtual IDBCommand* CreateDBCommand()=0;
    virtual IDataReader* CreateDataReader()=0;
    
};

//支持SQL Server
class SqlConnection: public IDBConnection{
    
};
class SqlCommand: public IDBCommand{
    
};
class SqlDataReader: public IDataReader{
    
};


class SqlDBFactory:public IDBFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
    virtual IDBCommand* CreateDBCommand()=0;
    virtual IDataReader* CreateDataReader()=0;
 
};

//支持Oracle
class OracleConnection: public IDBConnection{
    
};
class OracleCommand: public IDBCommand{
    
};
class OracleDataReader: public IDataReader{
    
};
class OracleDBFactory:public IDBFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
    virtual IDBCommand* CreateDBCommand()=0;
    virtual IDataReader* CreateDataReader()=0;
 
};


class EmployeeDAO{
    IDBFactory* dbFactory;
    
public:
    vector<EmployeeDO> GetEmployees(){
        IDBConnection* connection =
            dbFactory->CreateDBConnection();
        connection->ConnectionString("...");

        IDBCommand* command =
            dbFactory->CreateDBCommand();
        command->CommandText("...");
        command->SetConnection(connection); //关联性

        IDBDataReader* reader = command->ExecuteReader(); //关联性
        while (reader->Read()){

        }
    }
};

• 把产品子类进行分组，同组中不同产品由同一个工厂子类的不同方法负责创建，从而减少了工厂子类的数量。这就是抽象工厂模式。

要点总结：

• 如果没有应对“多系列对象构建”的需求变化，则没有必要使用 Abstract Factory 模式，这时候使用简单的工厂完全可以。
• “系列对象”指的是在某一特定系列下的对象之间有相互依赖、或作用的关系。不同系列的对象之间不能相互依赖。
• Abstract Factory 模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。

原型模式 Prototype

• 动机：在软件系统中，经常面临着“某些结构复杂的对象”的创建工作；由于需求的变化，这些对象经常面临着剧烈的变化，但是他们却拥有比较稳定一致的接口。

• 如何应对这种变化？如何向“客户程序（使用这些对象的程序）”隔离出“这些易变对象”，从而使得“依赖这些易变对象的客户程序”不随着需求改变而改变？

• 定义：使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象。（深克隆/深拷贝）

• 场景举例：与工厂方法模式的举例一样，文件分割工具，文件类型有txt文件，二进制文件，图片文件和video文件。原型模式 将 工具类 和创建对象的工厂类合二为一，将之前创建对象的方法改成了克隆方法，即深克隆自己，产生一个新的对象。如下：

//抽象类 *********************************
class ISplitter{
public:
    virtual void split()=0;
    virtual ISplitter* clone()=0; //通过克隆自己来创建对象
    virtual ~ISplitter(){}
};

//具体类  *********************************
class BinarySplitter : public ISplitter{
public:
    virtual ISplitter* clone(){
        return new BinarySplitter(*this);
    }
};

class TxtSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new TxtSplitter(*this);
    }
};

class PictureSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new PictureSplitter(*this);
    }
};

class VideoSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new VideoSplitter(*this);
    }
};

// 客户端使用   *********************************
class MainForm : public Form
{
    ISplitter*  prototype;//原型对象
public:
    MainForm(ISplitter*  prototype){
        this->prototype=prototype;
    }

	void Button1_Click(){
        // 必须使用深克隆后的对象，而不能直接使用 prototype，否则会改变原型状态。
		ISplitter * splitter=
            prototype->clone(); //克隆原型
        splitter->split();
	}
};

• 原型模式使用克隆来创建与原对象状态一模一样的对象，所以创建目标只需实现一次就可以了。
• 什么时候使用工厂方法模式，什么时候使用原型模式不太好界定，一般来说这么界定：如果用工厂方法模式创建对象，比较简单就可以达到目的，那就用工厂方法，如果很复杂，有复杂的中间状态，且想保存这个中间状态，那就用原型模式。

构建器 Builder

• 动机：在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。(想到了模板方法模式)
• 如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？
• 定义：将一个复杂对象的构建与其表示相分离，使得同样的构建过程(稳定)可以创建不同的表示(变化)。
• 场景举例：游戏中建造房子的模块，建造房子有多个步骤，BuildPart1~5，无论是石头房子还是水泥房子都有这5个建造步骤，如下：

class House{
    //....
};

class HouseBuilder {
public:
    House* GetResult(){
        return pHouse;
    }
    virtual ~HouseBuilder(){}
protected:
    House* pHouse;
	virtual void BuildPart1()=0;
    virtual void BuildPart2()=0;
    virtual void BuildPart3()=0;
    virtual void BuildPart4()=0;
    virtual void BuildPart5()=0;
};

class StoneHouse: public House{
    //...
};

class StoneHouseBuilder: public HouseBuilder{
protected:
    virtual void BuildPart1(){
        //pHouse->Part1 = ...;
    }
    virtual void BuildPart2(){
      //...  
    }
    virtual void BuildPart3(){
        //...  
    }
    virtual void BuildPart4(){
        //...  
    }
    virtual void BuildPart5(){
        //...  
    }
};

class HouseDirector{
public:
    HouseBuilder* pHouseBuilder;
    
    HouseDirector(HouseBuilder* pHouseBuilder){
        this->pHouseBuilder=pHouseBuilder;
    }
    
    House* Construct(){
        
        pHouseBuilder->BuildPart1();
        
        for (int i = 0; i < 4; i++){
            pHouseBuilder->BuildPart2();
        }
        
        bool flag=pHouseBuilder->BuildPart3();
        
        if(flag){
            pHouseBuilder->BuildPart4();
        }
        
        pHouseBuilder->BuildPart5();
        
        return pHouseBuilder->GetResult();
    }
};

要点总结：

• Builder 模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。
• 变化点在哪里，封装哪里—— Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。
• 在Builder模式中，要注意不同语言中构造器内调用虚函数的差别（C++ vs. C#) 。