---

前言

---

一、“单一职责” 模式

• 通过“对象创建”模式绕开new，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
• 典型模式
  • Factory Method
  • Abstract Factory
  • Prototype
  • Builder

二、Factory Method 工厂方法

1、动机

• 在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。
• 如何应对这种变化？如何绕过常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合？

2、模式定义

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

注："解耦"是解new和后面具体的类的耦合。

3、伪代码示例

原始代码：

class BinarySplitter 
{
public:
    void split() {
        //...
    }
};

MainForm.cpp

//MainForm.cpp
class MainForm : public Form
{
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    ProgressBar* progressBar;
 
public:
    void Button1_Click(){
        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());
        FileSplitter splitter(filePath, number, progressBar);
        splitter.split();
    }
};

未来可能的需求：文本分割，图片分割，那就要新增：

class ISplitter {
public:
    virtual void split() = 0;
    virtual ~ISplitter() { }
}
 
class BinarySplitter : public ISplitter
{
    virtual void split() {
        //...
    }
};
 
//新增
class TxtSplitter : public ISplitter
{
    virtual void split() {
        //...
    }
};
 
class PictureSplitter : public ISplitter
{
    virtual void split() {
        //...
    }
};
 
class VideoSplitter : public ISplitter
{
    virtual void split() {
        //...
    }
};

面向接口编程最简单的表现就是变量是接口类型
MainForm1.cpp

//MainForm1.cpp
class MainForm : public Form
{
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
 
public:
    void Button1_Click(){
        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());
        //ISplitter* splitter 是抽象依赖
        //new BinarySplitter(filePath, number) 是细节依赖，编译时细节依赖， 违背了依赖倒置原则，如何解决呢？
        ISplitter* splitter = new BinarySplitter(filePath, number); //依赖具体类
        splitter.split();
    }
};

”对象创建“ 模式就是要绕开这个new 带来的问题，这是面向接口编程必然要面临的需求，上述代码中的第13行等号左右两边都变成依赖抽象。可以考虑通过一个方法返回对象。
SplitterFactory1.cpp

//SplitterFactory1.cpp
//抽象类
class ISplitter {
public:
    virtual void split() = 0;
    virtual ~ISplitter() { }
}
 
//工厂基类
class SplitterFactory {
public:
    ISplitter* createSplitter() {
        return new BinaryFiltter();
    }
};

MainForm2.cpp

//MainForm2.cpp
class MainForm : public Form
{
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
 
public:
    void Button1_Click(){
        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());
        SplitterFactory factory;
        ISplitter* splitter = factory.createSplitter(); 
        splitter.split();
    }
};

因为 SplitterFactory 编译时依赖了 BinarySplitter，而 MainForm 编译时依赖了 SplitterFactory，所以相当于MainForm 编译时依赖了 BinarySplitter，所以还是没有解决问题。那应该怎么办呢？

虚函数是运行时依赖，所以修改 SplitterFactory.cpp:

SplitterFactory.cpp

//SplitterFactory.cpp
class SplitterFactory {
public:
    virtual ISplitter* createSplitter() = 0;
    virtual ~SplitterFactory() { }
};
 
class ISplitter {
public:
    virtual void split() = 0;
    virtual ~ISplitter() { }
}

MainForm3.cpp

//MainForm3.cpp
class MainForm : public Form
{
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
 
public:
    void Button1_Click(){
        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());
        
        SplitterFactory* factory;
        ISplitter* splitter = factory->createSplitter();  //多态
        
        splitter.split();
    }
};

未来的对象实际是什么类型依赖于 factory，那么 factory 的实际类型是什么呢：
FileSplitter2.cpp

//FileSplitter2.cpp
//具体类
class BinarySplitter : public ISplitter
{
    virtual void split() {
        //...
    }
};
 
class TxtSplitter : public ISplitter
{
    virtual void split() {
        //...
    }
};
 
class PictureSplitter : public ISplitter
{
    virtual void split() {
        //...
    }
};
 
class VideoSplitter : public ISplitter
{
    virtual void split() {
        //...
    }
};
 
//具体工厂
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();
    }
};

MainForm3.cpp

//MainForm3.cpp
class MainForm : public Form
{
    SplitterFactory* factory; //工厂
public:
    MainForm(SplitterFactory* factory) {
        this->factory = factory;
    }
    
    void Button1_Click(){
        ISplitter* splitter = factory->createSplitter();  //多态new
        splitter.split();
    }
};

可以发现，通过这种改善，MainForm 只依赖 SplitterFactory 和 ISplitter 这两个抽象，而没有依赖具体类。不是消灭变化，而是将变化赶到一个局部的地方。

4、结构

【注】：

• Product -> ISplitter (稳定)
• Creator -> SplitterFactory （稳定）
• ConcreteProduct -> XXSplitter （变化）
• ConcreteCreator -> XXSplitterFactory （变化）

---

总结

• Factory Method 模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系（new）会导致软件的脆弱。
• Factory Method 模式通过面向对象【注：多态】的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。【注：“延迟” 对应到代码中就是 MainForm 类中，一开始只要有需求变化，就要修改对应的代码，而改善后 MainForm 中不会因为需求的变化而进行更改，只需要加子类和子类的工厂即可，然后将具体的类传给 MainForm。】
• Factory Method 模式解决“单个对象”的需求变化。缺点在于要求创建方法/参数相同。

---

我的qq：2442391036，欢迎交流！

---