23种设计模式之Factory模式（一）

最近写大论文实在无聊，所以决定每天闲暇时学习一种设计模式，主要参考：设计模式：可复用面向对象的软件基础一书、设计模式精解-GoF23种设计模式解析附C++实现源码，还有https://blog.csdn.net/u011012932/article/category/6783147的博客（很多图是来自这里）。还是一样，边学边整理，方便日后查看。

第一部分：创建型模式

1. Factory模式

a. 问题

简单工厂模式：

这个实现比较简单，Factory类直接就创建产品，需要指名产品类型，type为A就创建A产品，为B就创建B产品，适用于工厂类负责创建的对象比较少，createProduct中逻辑简单。这种简单的做法存在一些问题：

• 由于工厂类集中了所有产品的创建逻辑（违反了高内聚责任分配原则），职责过重，一旦无法正常工作，整个系统都将受到影响。
• 一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。

Factory模型可以解决这些问题：
1）在父类中并不知道具体要实例化哪一个具体的子类：factory，product两个抽象基类，宝马工厂创建宝马产品，奥迪工厂生产奥迪汽车，我们在factory基类中不知道到底要创建哪个产品，因此，需要将具体化类的工作延迟到子类中。
2）定义创建对象的接口，封装了对象的创建：一个工厂可能有很多产品，将具体化产品的操作进行了封装，具体实现就是，factory中有一个create函数，里面创建不同的产品。
3) 适用于一个类不知道它所创建对象的具体类的时候，或者希望它的子类来指定要创建的对象，或者类将创建对象的职责托付给子类。

具体而言Factory模式适用于：

• 对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。
• 只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程对于使用者来说是透明的。

b. 结构示意图

c. 代码实例

//main.cpp
#include "Factory.h"
#include "Product.h"
#include <iostream> 
using namespace std;

int main(int argc,char* argv[]) {
 	Factory* facA = new ConcreteFactoryA();
	Product* p = facA->CreateProduct("A");         //产品A

	Factory* facB = new ConcreteFactoryB();
	Product* p = facB->CreateProduct("B");       //产品B
	return 0; 
}

**//Factory.h**
#ifndef _FACTORY_H_
 #define _FACTORY_H_
class Product;                                     //类对象，需要声明
class Factory { 
public: 
	virtual ~Factory() = 0;
	virtual Product* CreateProduct() = 0;          //封装了对象的创建
protected: 
	Factory();                                     //接口类，保护构造函数
private:

};

class ConcreteFactoryA:public Factory              //工厂的子类，这里比如工厂A，生产产品：汽车、轮子、等
{ 
public:
	~ConcreteFactoryA();
	ConcreteFactoryA();
	Product* CreateProduct(string ProductID);
protected:
private:
};
#endif //~_FACTORY_H_

**//Factory.cpp**
#include "Factory.h"
#include "Product.h"
#include <iostream> 
using namespace std;
Factory::Factory() {
}
Factory::~Factory() {
}

ConcreteFactoryA::ConcreteFactoryA() { 
	cout<<"BMW car Factory....."<<endl; 
}
ConcreteFactoryA::~ConcreteFactoryA() {

}
Product* ConcreteFactoryA::CreateProduct(string ProductID) { 
	if(ProductID == "A")
		return new ProductA();           //A工厂生产产品A             Problem1： 参数化工厂方法，每个工厂生产的产品不确定
	if(ProductID == "B")
		return new ProductB();          //A工厂生产产品B
	return 0；
}

**// product.h**    // 产品基类接口
#ifndef PRODUCT_H
#define PRODUCT_H
#include <string>
using namespace std;
class Product
{
public:
    virtual ~Product（） = 0;  
 protected:
 	Product();
};
#endif // PRODUCT_H

**// concrete_product.h**
#ifndef CONCRETE_PRODUCT_H
#define CONCRETE_PRODUCT_H
#include "product.h"
//产品A
class ProductA: public Product
{
public:
    ProductA（）{
		cout << "create productA" << endl；
	}
};
// 产品B
class ProductB: public Product
{
public:
    ProductB（）{
		cout << "create productB" << endl；
	}
};
#endif // CONCRETE_PRODUCT_H

上述方法还存在一个问题，如果没有ProductID，要创建一个产品，就需要创建一个工厂子类，可以通过模板解决。

template<typename TheProduct>
class StandardFactory:public factory{
public:
	virtual Product* CreateProduct();
}
template<typename TheProduct>
Product* StandardFactory<TheProduct>::CreateProduct(){
	return new TheProduct;
}

主函数调用：
Factory* facA = newStandardFactory<ProductA>();
Product* p = facA->CreateProduct();         //产品A

一个工厂创建多个产品，factory中加入相应的创建函数

**//Factory.h**
#ifndef _FACTORY_H_
 #define _FACTORY_H_
class Product;                                     //类对象，需要声明
class Factory { 
public: 
	virtual ~Factory() = 0;
	virtual Product* CreateProduct() = 0;          //封装了对象的创建
	virtual allProducts* MakeProducts()const{      //allProducts是一个管理所有产品的类或者结构体
		return new allProducts();
	}
	virtual ProductA* MakeProductA()const{
		return new ProductA();
	}
	virtual ProductB* MakeProductB()const{
		return new ProductB();
	}
	.............基类中virtual定义所有的产品
protected: 
	Factory();                                     //接口类，保护构造函数
private:

};

class ConcreteFactoryA:public Factory              //工厂的子类，这里比如工厂A，生产产品：汽车、轮子、等
{ 
public:
	~ConcreteFactoryA();
	ConcreteFactoryA();
	allProducts* CreateProduct(){
		allProducts* Products = MakeProducts():
		ProductA* A = MakeProductA();
		ProductA* B = MakeProductB();
		Products.add(A);
		Products.add(B);
		return Products;
	}
	virtual ProductA* MakeProductA()const{
		return new ProductA();                  //这么写是方便扩展，也可以是A的子类之类的
	}
	virtual ProductB* MakeProductB()const{
		return new ProductB();
	}
protected:
private:
};
#endif //~_FACTORY_H_

d. 局限性

a) Factory模式对于对象的创建给予开发人员提供了很好的实现策略，但是Factory模式仅仅局限于一类类（就是说Product是一类，有一个共同的基类，或者后面allproducts也是一类），如果我们要为不同类的类提供一个对象创建的接口，那就要用AbstractFactory了。
b) 每增加一个产品，相应的也要增加一个子工厂，加大了额外的开发量。（可以通过模板解决，或者参数化工厂解决）