常见设计模式之（二）：工厂模式（一）
文章目录
- 常见设计模式之（二）：工厂模式（一）
- 1 什么是工厂模式（factory pattern）？
- 2 通用工厂模式以及其基于c++实现
- 2.1 通用工厂模式
- 2.2 通用工厂模式的c++实现
- 3 工厂模式的扩展之 简单工厂
- 4 结束语
常见设计模式之（二）：工厂模式（一）
1 什么是工厂模式（factory pattern）？
摘自 java 设计模式官网 中 有关工厂模式的定义：
Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses
翻译过来就是：
定义一个接口，这个接口用来创建对象，但是由子类来决定来实例化哪一个类，工厂模式将类的实例化推迟到子类。
维基百科上描述如下：
In class-based programming, the factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. This is done by creating objects by calling a factory method—either specified in an interface and implemented by child classes, or implemented in a base class and optionally overridden by derived classes—rather than by calling a constructor.
从上述定义和维基百科的定义来看，我们可以得出几个关键的点：
- 工程模式属于创造类的设计方法
- 通过调用工厂方法来创建对象，而不是通过构造函数
- 两种创建方法：一种在接口中指定子类进行实现，另一种是在基类中实现并且可以被子类覆盖。
2 通用工厂模式以及其基于c++实现
2.1 通用工厂模式
在工厂模式中，首先由两个要素，一个是工厂，一个是产品：
- 产品：我们定义一个抽象的产品类AbstractProduct负责定义产品的共性，用来实现事物最抽象的定义，比如说 书 就是一个抽象类，我们可以定义一些书籍共有的特性比如说 给人提供知识，书的价格等等；定义完抽象产品之后就要定义一些具体的产品类ConcreteProduct，而具体的产品类一定会继承抽象书籍的特性，还是以书籍为例，具体书籍的种类比如说 纸质书、电子书 ，这些必须提供给人们知识，并且还有一定的价格。
- 工厂类：AbstractFactory，是一个抽象创建类，是负责创造具体产品工厂的抽象，ConcreteFactory 具体产品工厂，创造具体的产品，可以有许多具体的工厂类，因为制造不同产品本身也需要不同的工厂，就像纸质书和电子书一样，肯定不是同一家工厂。
工厂模式在实际的软件开发工程中应用十分广泛，并且工厂模式的变种也很多，下面是一个比较基础通用的类图：
通用工厂模式的一般类图如下：
2.2 通用工厂模式的c++实现
c++实现代码如下：
AbstractFactory.h
#ifndef ABSTRACT_FACTORY_H
#define ABSTRACT_FACTORY_H
#include
#include
#include "AbstractProduct.h"
class AbstractFactory
{
public:
AbstractFactory()
{
printf("%s %d \n",__FUNCTION__,__LINE__);
}
~AbstractFactory()
{
printf("%s %d \n",__FUNCTION__,__LINE__);
}
virtual AbstractProduct * CreateProducts() = 0;
virtual void DestoryProducts(AbstractProduct * ) = 0;
};
#endif
AbstractProduct.h
#ifndef ABSTRACT_PRODUCT_H
#define ABSTRACT_PRODUCT_H
class AbstractProduct
{
public:
AbstractProduct()
{
printf("%s %d \n",__FUNCTION__,__LINE__);
}
~AbstractProduct()
{
printf("%s %d \n",__FUNCTION__,__LINE__);
}
virtual void get_product_attr(void) = 0;
// 添加一些产品公共的接口
};
#endif
ConcreteFactory.h
#ifndef CONCRETE_FACTORY_H
#define CONCRETE_FACTORY_H
#include "AbstractFactory.h"
#include "AbstractProduct.h"
#include "ConcreteProduct.h"
#include
class ConcreteFactory : public AbstractFactory
{
public:
ConcreteFactory()
{
}
~ConcreteFactory()
{
}
AbstractProduct * CreateProducts()
{
return new ConcreteProduct();
}
void DestoryProducts(AbstractProduct * pcls_handle)
{
delete pcls_handle;
}
};
#endif
ConcreteProduct.h
#ifndef CONCRETE_PRODUCT_H
#define CONCRETE_PRODUCT_H
#include "AbstractProduct.h"
#include
class ConcreteProduct : public AbstractProduct
{
public:
ConcreteProduct()
{
}
~ConcreteProduct()
{
}
void get_product_attr(void)
{
printf("%s %d i am a good product \n",__FUNCTION__,__LINE__);
}
};
#endif
具体的使用情况
FactoryPatternClient.cpp
#include "AbstractFactory.h"
#include "AbstractProduct.h"
#include "ConcreteProduct.h"
#include "ConcreteFactory.h"
int main(void)
{
AbstractFactory * pcls_factory = new ConcreteFactory();
AbstractProduct * pcls_product = pcls_factory->CreateProducts();
pcls_product->get_product_attr();
pcls_factory->DestoryProducts(pcls_product);
delete pcls_factory;
}
编译并运行
make FactoryPatternClient
g++ FactoryPatternClient.cpp -o FactoryPatternClient
root@wan:/wan/class_diagram# ./FactoryPatternClient
AbstractFactory 14
AbstractProduct 9
get_product_attr 21 i am a good product
~AbstractProduct 13
~AbstractFactory 18
3 工厂模式的扩展之 简单工厂
工厂模式的变种非常多，抽象工厂和抽象产品的数量可以根据自己的需要随时进行调整，下面就介绍几种常用的扩展
简单工厂模式是工厂模式的精简版，只有一个工厂，并且不存在抽象工厂类，只有一个具体的工厂类，其他保持不变：
c++ 实现
AbstractProduct.h
#ifndef ABSTRACT_PRODUCT_H
#define ABSTRACT_PRODUCT_H
#include
class AbstractProduct
{
public:
AbstractProduct()
{
printf("%s %d \n",__FUNCTION__,__LINE__);
}
~AbstractProduct()
{
printf("%s %d \n",__FUNCTION__,__LINE__);
}
virtual void get_product_attr(void) = 0;
// 添加一些产品公共的接口
};
#endif
ConcreteProduct.h
#ifndef CONCRETE_PRODUCT_H
#define CONCRETE_PRODUCT_H
#include "AbstractProduct.h"
#include
class ConcreteProductA : public AbstractProduct
{
public:
ConcreteProductA()
{
}
~ConcreteProductA()
{
}
void get_product_attr(void)
{
printf("ConcreteProductA :: %s %d i am a good product \n",__FUNCTION__,__LINE__);
}
};
class ConcreteProductB : public AbstractProduct
{
public:
ConcreteProductB()
{
}
~ConcreteProductB()
{
}
void get_product_attr(void)
{
printf("ConcreteProductB :: %s %d i am a good product \n",__FUNCTION__,__LINE__);
}
};
#endif
SimpleFactory.h
#ifndef CONCRETE_FACTORY_H
#define CONCRETE_FACTORY_H
#include "AbstractProduct.h"
#include "ConcreteProduct.h"
#include
class SimpleFactory
{
public:
SimpleFactory()
{
}
~SimpleFactory()
{
}
static AbstractProduct * CreateProducts(char s8_product_type)
{
AbstractProduct * pcls_temp = NULL;
if('A' == s8_product_type)
{
pcls_temp = new ConcreteProductA();
}
else if('B' == s8_product_type)
{
pcls_temp = new ConcreteProductB();
}
else
{
/* code */
}
return pcls_temp;
}
static void DestoryProducts(AbstractProduct * pcls_handle)
{
if(NULL != pcls_handle)
{
delete pcls_handle;
}
else
{
/* code */
}
}
};
#endif
SimpleFactoryPatternClient.cpp
#include "AbstractProduct.h"
#include "ConcreteProduct.h"
#include "SimpleFactory.h"
int main(void)
{
AbstractProduct * pcls_productA = SimpleFactory::CreateProducts('A');
pcls_productA->get_product_attr();
AbstractProduct * pcls_productB = SimpleFactory::CreateProducts('B');
pcls_productB->get_product_attr();
SimpleFactory::DestoryProducts(pcls_productA);
SimpleFactory::DestoryProducts(pcls_productB);
return 0;
}
4 结束语
工厂模式还有其他一些变种，比如说抽象工厂模式、多个工厂模式，工厂模式和单例的结合等等，本博文篇幅有限，会在接下来的博文中进行详细讲解。