设计模式从青铜到王者第五篇:创建型模式之简单工厂模式( Simple Factory Pattern )

Posted 2022-07-01 森明帮大于黑虎帮

系列文章目录

---

文章目录

• 系列文章目录
• 前言
• 一、简单工厂模式模式动机
• 二、简单工厂模式模式定义
• 三、简单工厂模式模式结构
• 四、简单工厂模式时序图
• 五、简单工厂模式代码分析
• 六、简单工厂模式模式分析
• 七、简单工厂模式优点
• 八、简单工厂模式缺点
• 九、简单工厂模式适用环境
• 十、简单工厂模式模式应用
• 十一、简单工厂模式总结
• 十二、简单工厂模式进一步分析
• • • 1.简单工厂模式简介
    • 2.简单工厂应用举例
    • 3.简单工厂基本实现流程
    • 4.简单工厂定义
    • 5.简单工厂模式结构
    • 6.简单工厂模式代码实例
    • • 1.定义抽象产品类AbstractProduct，抽象方法不提供实现
      • 2.定义三个具体产品类
      • 3.定义工厂类和工厂方法
      • 4.客户端使用方法示例(main.cpp)
      • 5.运行结果
    • 7.简单工厂模式总结
• 总结

---

前言

---

一、简单工厂模式模式动机

考虑一个简单的软件应用场景，一个软件系统可以提供多个外观不同的按钮（如圆形按钮、矩形按钮、菱形按钮等）， 这些按钮都源自同一个基类，不过在继承基类后不同的子类修改了部分属性从而使得它们可以呈现不同的外观。如果我们希望在使用这些按钮时，不需要知道这些具体按钮类的名字，只需要知道表示该按钮类的一个参数，并提供一个调用方便的方法，把该参数传入方法即可返回一个相应的按钮对象，此时，就可以使用简单工厂模式。

二、简单工厂模式模式定义

简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

三、简单工厂模式模式结构

• 简单工厂模式包含如下角色：
• Factory：工厂角色
  工厂角色负责实现创建所有实例的内部逻辑
• Product：抽象产品角色
  抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口
• ConcreteProduct：具体产品角色
  具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。
  

四、简单工厂模式时序图

五、简单工厂模式代码分析

///
//  Factory.cpp
//  Implementation of the Class Factory
//  Created on:      01-十月-2014 18:41:33
//  Original author: colin
///

#include "Factory.h"
#include "ConcreteProductA.h"
#include "ConcreteProductB.h"
Product* Factory::createProduct(string proname)
	if ( "A" == proname )
	
		return new ConcreteProductA();
	
	else if("B" == proname)
	
		return new ConcreteProductB();
	
	return  NULL;

六、简单工厂模式模式分析

• 将对象的创建和对象本身业务处理分离可以降低系统的耦合度，使得两者修改起来都相对容易。
• 在调用工厂类的工厂方法时，由于工厂方法是静态方法，使用起来很方便，可通过类名直接调用，而且只需要传入一个简单的参数即可，在实际开发中，还可以在调用时将所传入的参数保存在XML等格式的配置文件中，修改参数时无须修改任何源代码。
• 简单工厂模式最大的问题在于工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，这一点与开闭原则是相违背的。
• 简单工厂模式的要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。

七、简单工厂模式优点

• 工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。
• 客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。
• 通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。

八、简单工厂模式缺点

• 由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
• 使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。
• 系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。
  简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。

九、简单工厂模式适用环境

• 在以下情况下可以使用简单工厂模式：
• 工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。
• 客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。

十、简单工厂模式模式应用

• JDK类库中广泛使用了简单工厂模式，如工具类java.text.DateFormat，它用于格式化一个本地日期或者时间。

public final static DateFormat getDateInstance();
public final static DateFormat getDateInstance(int style);
public final static DateFormat getDateInstance(int style,Locale
locale);

• Java加密技术:

获取不同加密算法的密钥生成器:

KeyGenerator keyGen=KeyGenerator.getInstance("DESede");

创建密码器:

Cipher cp=Cipher.getInstance("DESede");

十一、简单工厂模式总结

• 创建型模式对类的实例化过程进行了抽象，能够将对象的创建与对象的使用过程分离。
• 简单工厂模式又称为静态工厂方法模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
• 简单工厂模式包含三个角色：工厂角色负责实现创建所有实例的内部逻辑；抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口；具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。
• 简单工厂模式的要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。
• 简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。
• 简单工厂模式适用情况包括：工厂类负责创建的对象比较少；客户端只知道传入工厂类的参数，对于如何创建对象不关心。

十二、简单工厂模式进一步分析

1.简单工厂模式简介

创建型模式关注对象的创建过程，在软件开发中应用非常广泛。创建型模式描述如何将对象的创建和使用分离，让用户在使用对象过程中无须关心对象的创建细节，从而降低系统耦合度，并且让系统易于修改和扩展。

简单工厂模式是最简单的设计模式之一，其实它并不属于Gof的23种设计模式，但应用也十分频繁，同时也是其余创建模式的基础，因此有必要先学习简单工厂模式。

2.简单工厂应用举例

什么是简单工厂模式呢？举个例子：如上图，一个体育用品生产厂（这即是一个工厂Factory），该工厂可以根据客户需求生产篮球、足球和排球。篮球、足球和排球被成为产品（Product），产品的名称可以被成为参数。客户Jungle需要时可以向工厂提供产品参数，工厂根据产品参数生产对应产品，客户Jungle并不需要关心产品的生产过程细节。

3.简单工厂基本实现流程

• 由上述例子，可以很容易总结出简单工厂的实现流程：
• 设计一个抽象产品类，它包含一些公共方法的实现。
• 从抽象产品类中派生出多个具体产品类，如篮球类、足球类、排球类，具体产品类中实现具体产品生产的相关代码。
• 设计一个工厂类，工厂类中提供一个生产各种产品的工厂方法，该方法根据传入参数（产品名称）创建不同的具体产品类对象。
• 客户只需调用工厂类的工厂方法，并传入具体产品参数，即可得到一个具体产品对象。

4.简单工厂定义

简单工厂模式：定义一个简单工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类

5.简单工厂模式结构

• 从简单工厂模式的定义和例子可以看出，在简单工厂模式中，大体上有3个角色：
• 工厂（Factory）：根据客户提供的具体产品类的参数，创建具体产品实例；
• 抽象产品（AbstractProduct）：具体产品类的基类，包含创建产品的公共方法；
• 具体产品（ConcreteProduct）：抽象产品的派生类，包含具体产s品特有的实现方法，是简单工厂模式的创建目标。 简单工厂模式UML类图如下：
  
  代码结构如下：

//抽象产品类AbstractProduct
class AbstractProduct

public:
	//抽象方法：
;
 
//具体产品类Basketball
class ConcreteProduct :public AbstractProduct

public:
	//具体实现方法
;
 
class Factory

public:
	AbstractProduct createProduct(string productName)
	
		AbstractProduct pro = NULL;
		if (productName == "ProductA")
			pro = new ProductA();
		
		else if (productName == "ProductB")
			pro = new ProductB();
		
		...
	
;

客户端在使用时，只需要创建一个工厂对象，调用工厂对象的createProduct方法，并传入所需要的产品参数，即可得到所需产品实例对象，而无需关心产品的创建细节。

6.简单工厂模式代码实例

考虑有以下一个场景：

Jungle想要进行户外运动，它可以选择打篮球、踢足球或者玩排球。它需要凭票去体育保管室拿，票上写着一个具体球类运动的名字，比如“篮球”。体育保管室负责人根据票上的字提供相应的体育用品。然后Jungle就可以愉快地玩耍了。

我们采用简单工厂模式来实现上述场景。首先，体育保管室是工厂，篮球、足球和排球是具体的产品，而抽象产品可以定义为“运动球类产品SportProduct”.Jungle作为客户只需要提供具体产品名字，工厂就可“生产”出对应产品。

1.定义抽象产品类AbstractProduct，抽象方法不提供实现

//抽象产品类AbstractProduct
class AbstractSportProduct

public:
	AbstractSportProduct()
 
	
	virtual ~AbstractSportProduct();
	//抽象方法：
	// virtual void printName();
	virtual void printName() = 0;
	// virtual void play();
	virtual void play() = 0;
;

2.定义三个具体产品类

//具体产品类Basketball
class Basketball :public AbstractSportProduct

public:
	Basketball()
		printName();
		play();
	
	~Basketball()
	
 
	
	//具体实现方法
	void printName()
		printf("Jungle get Basketball\\n");
	
	void play()
		printf("Jungle play Basketball\\n");
	
;
 
//具体产品类Football
class Football :public AbstractSportProduct

public:
	Football()
		printName();
		play();
	
	~Football()
	
 
	
	//具体实现方法
	void printName()
		printf("Jungle get Football\\n");
	
	void play()
		printf("Jungle play Football\\n");
	
;
 
//具体产品类Volleyball
class Volleyball :public AbstractSportProduct

public:
	Volleyball()
		printName();
		play();
	
	~Volleyball()
	
		
	
	//具体实现方法
	void printName()
		printf("Jungle get Volleyball\\n");
	
	void play()
		printf("Jungle play Volleyball\\n");
	
;

3.定义工厂类和工厂方法

class Factory

public:
	std::shared_ptr<AbstractSportProduct> getSportProduct(string productName)
	
		std::shared_ptr<AbstractSportProduct> pro;
		if (productName == "Basketball")
			pro = std::shared_ptr<AbstractSportProduct>(new Basketball());
		
		else if (productName == "Football")
			pro = std::shared_ptr<AbstractSportProduct>(new Football());
		
		else if (productName == "Volleyball")
			pro = std::shared_ptr<AbstractSportProduct>(new Volleyball());
		
		return pro;
	
;

4.客户端使用方法示例(main.cpp)

#include <iostream>
#include <memory>
#include "SimpleFactory.h"
 
int main()

	printf("简单工厂模式\\n");
	
	//定义工厂类对象
	std::shared_ptr<Factory> fac = std::make_shared<Factory>();
	// std::shared_ptr<AbstractSportProduct> product = std::shared_ptr<AbstractSportProduct>(fac->getSportProduct("Basketball"));
	std::shared_ptr<AbstractSportProduct> product = fac->getSportProduct("Basketball");
	
	fac = std::make_shared<Factory>();
	product = fac->getSportProduct("Football");
	// product = std::shared_ptr<AbstractSportProduct>(fac->getSportProduct("Football"));
 
	fac = std::make_shared<Factory>();
	product = fac->getSportProduct("Volleyball");	
	// product = std::shared_ptr<AbstractSportProduct>(fac->getSportProduct("Volleyball"));	
#ifdef win32
	system("pause");
#endif
	return 0;

5.运行结果

7.简单工厂模式总结

简单工厂模式的优点在于：

• 工厂类提供创建具体产品的方法，并包含一定判断逻辑，客户不必参与产品的创建过程；
• 客户只需要知道对应产品的参数即可，参数一般简单好记，如数字、字符或者字符串等。

当然，简单工厂模式存在明显的不足（想想我们之前介绍的面向对象设计原则？？？）。假设有一天Jungle想玩棒球了，该怎么办呢？你肯定会说，这还不容易吗？再从抽象产品类派生出一个Baseball类，并在工厂类的getSportProduct方法中增加“productName == "Baseball”的条件分支即可。的确如此，但是这明显违背了开闭原则（对扩展开放，对修改关闭），即在扩展功能时修改了既有的代码。另一方面，简单工厂模式所有的判断逻辑都在工厂类中实现，一旦工厂类设计故障，则整个系统都受之影响！

---

总结

以上就是今天要讲的内容，本文详细介绍了设计模式中创建型模式之简单工厂模式( Simple Factory Pattern )介绍和使用，简单工厂模式设计模式的使用，，设计模式提供了大量的方法供我们使用，非常的便捷，我们务必掌握。希望大家多多支持！另外如果上述有任何问题，请懂哥指教，不过没关系，主要是自己能坚持，更希望有一起学习的同学可以帮我指正，但是如果可以请温柔一点跟我讲，爱与和平是永远的主题，爱各位了。加油啊！