前言
一、“单一职责” 模式
- 通过“对象创建”模式绕开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,欢迎交流!