共计 5357 个字符,预计需要花费 14 分钟才能阅读完成。
工厂模式(Factory Design Pattern)分类:简单工厂、工厂方法 和抽象工厂。
之所以将某个代码块剥离出来,独立为函数或者类,原因是这个代码块的逻辑过于复杂,剥离之后能让代码 更加清晰,更加可读、可维护。
- 应用场景:
- 什么时候该用工厂模式?
- 相对于直接 new 来创建对象,用工厂模式来创建究竟有什么好处呢?
1. 简单工厂
Code 如下:
public class RuleConfigSource {public RuleConfig load(String ruleConfigFilePath)
{String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
IRuleConfigParser parser = RuleConfigParserFactory.createParser(ruleConfigFileExtension);
if (parser == null) {
throw new InvalidRuleConfigException("Rule config file format is not supported:" + ruleConfigFilePath);
}
String configText = "";
// 从 ruleConfigFilePath 文件中读取配置文本到 configText 中
RuleConfig ruleConfig = parser.parse(configText);
return ruleConfig;
}
private String getFileExtension(String filePath) {
//... 解析文件名获取扩展名,比如 rule.json,返回 json
return "json";
}
}
public class RuleConfigParserFactory {public static IRuleConfigParser createParser(String configFormat)
{
IRuleConfigParser parser = null;
if ("json".equalsIgnoreCase(configFormat)) {parser = new JsonRuleConfigParser();
} else if ("xml".equalsIgnoreCase(configFormat)) {parser = new XmlRuleConfigParser();
} else if ("yaml".equalsIgnoreCase(configFormat)) {parser = new YamlRuleConfigParser();
} else if ("properties".equalsIgnoreCase(configFormat)) {parser = new PropertiesRuleConfigParser();
}
return parser;
}
}
2. 工厂方法(Factory Method)
如果我们非得要将 if 分支逻辑去掉,那该怎么办呢?比较经典处理方法就是利用多态。
实际上,这就是工厂方法模式的典型代码实现。这样当我们新增一种 parser 的时候,只需要新增一个实现了 IRuleConfigParserFactory 接口的 Factory 类即可 。所以, 工厂方法模式比起简单工厂模式更加符合开闭原则。
public class RuleConfigSource {public RuleConfig load(String ruleConfigFilePath) {String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
IRuleConfigParserFactory parserFactory = RuleConfigParserFactoryMap.getParserFactory(ruleConfigFileExtension);
if (parserFactory == null) {throw new InvalidRuleConfigException("Rule config file format is not supported:" + ruleConfigFilePath);
}
IRuleConfigParser parser = parserFactory.createParser();
String configText = "";
// 从 ruleConfigFilePath 文件中读取配置文本到 configText 中
RuleConfig ruleConfig = parser.parse(configText);
return ruleConfig;
}
private String getFileExtension(String filePath) {
//... 解析文件名获取扩展名,比如 rule.json,返回 json
return "json";
}
}
// 因为工厂类只包含方法,不包含成员变量,完全可以复用,// 不需要每次都创建新的工厂类对象,所以,简单工厂模式的第二种实现思路更加合适。public class RuleConfigParserFactoryMap { // 工厂的工厂
private static final Map<String, IRuleConfigParserFactory> cachedFactories = new HashMap<>();
static {cachedFactories.put("json", new JsonRuleConfigParserFactory());
cachedFactories.put("xml", new XmlRuleConfigParserFactory());
cachedFactories.put("yaml", new YamlRuleConfigParserFactory());
cachedFactories.put("properties", new PropertiesRuleConfigParserFactory());
}
public static IRuleConfigParserFactory getParserFactory(String type) {if (type == null || type.isEmpty()) {return null;}
IRuleConfigParserFactory parserFactory = cachedFactories.get(type.toLowerCase());
return parserFactory;
}
}
3. 抽象工厂(Abstract Factory)
3.1 示例 1
在简单工厂和工厂方法中,类只有一种分类方式。比如,在规则配置解析那个例子中,解析器类只会根据配置文件格式(Json、Xml、Yaml……)来分类。但是,如果类有两种分类方式,比如,我们既可以按照配置文件格式来分类,也可以按照解析的对象(Rule 规则配置还是 System 系统配置)来分类,那就会对应下面这 8 个 parser 类。
针对这种特殊的场景,如果还是继续用工厂方法来实现的话,我们要针对每个 parser 都编写一个工厂类,也就是要编写 8 个工厂类。如果我们未来还需要增加针对业务配置的解析器(比如 IBizConfigParser),那就要再对应地增加 4 个工厂类。而我们知道,过多的类也会让系统难维护。这个问题该怎么解决呢?
抽象工厂就是针对这种非常特殊的场景而诞生的。我 们可以让一个工厂负责创建多个不同类型的对象(IRuleConfigParser、ISystemConfigParser 等),而不是只创建一种 parser 对象。这样就可以有效地减少工厂类的个数。具体的代码实现如下所示:
public interface IConfigParserFactory {IRuleConfigParser createRuleParser();
ISystemConfigParser createSystemParser();
// 此处可以扩展新的 parser 类型,比如 IBizConfigParser
}
public class JsonConfigParserFactory implements IConfigParserFactory {
@Override
public IRuleConfigParser createRuleParser() {return new JsonRuleConfigParser();
}
@Override
public ISystemConfigParser createSystemParser() {return new JsonSystemConfigParser();
}
}
public class XmlConfigParserFactory implements IConfigParserFactory {
@Override
public IRuleConfigParser createRuleParser() {return new XmlRuleConfigParser();
}
@Override
public ISystemConfigParser createSystemParser() {return new XmlSystemConfigParser();
}
}
// 省略 YamlConfigParserFactory 和 PropertiesConfigParserFactory 代码
3.2 示例 2
https://blog.csdn.net/konglon…
抽象工厂模式,提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类.
举个例子吧,就拿键盘和鼠标来说吧 ,键盘和鼠标就是一些列的类。而键盘鼠标又有微软的和联想的区别。 所以有了微软的工厂和联想的工厂。键盘和鼠标具体的创建由工厂来负责,而具体创建微软的还是联想的则由客户端来指定,而客户端根本不用知道鼠标和键盘这些类。此例的示例代码如下:
// AbstractFactoryModel.h 文件
#pragma once
#include <iostream>
// 1 --- 键盘
// 键盘
class KeyBoard
{
public:
virtual void show() = 0;};
// 微软的键盘
class KeyBoardMicro : public KeyBoard
{
public:
void show()
{std::cout << "微软的键盘" << std::endl;}
};
// 联想的键盘
class KeyBoardLenovo : public KeyBoard
{
public:
void show()
{std::cout << "联想的键盘" << std::endl;}
};
// 2 --- 鼠标
// 鼠标
class Mouse
{
public:
virtual void show() = 0;};
class MouseMicro : public Mouse
{
public:
void show()
{std::cout << "微软的鼠标" << std::endl;}
};
class MouseLenovo : public Mouse
{
public:
void show()
{std::cout << "联想的鼠标" << std::endl;}
};
// 3 --- 工厂
// 工厂
class Factory
{
public:
virtual KeyBoard * createKeyBoard() = 0;
virtual Mouse * createMouse() = 0;};
// 微软的工厂
class FactoryMicro : public Factory
{
public:
KeyBoard * createKeyBoard()
{return new KeyBoardMicro();
}
Mouse * createMouse()
{return new MouseMicro();
}
};
// 联想的工厂
class FactoryLenovo : public Factory
{
public:
KeyBoard * createKeyBoard()
{return new KeyBoardLenovo();
}
Mouse * createMouse()
{return new MouseLenovo();
}
};
测试代码如下:
#include <iostream>
#include "AbstractFactoryModel.h"
int main()
{
using namespace std;
// 抽象工厂模式
Factory * p = new FactoryMicro();
KeyBoard * pKeyBoard = p->createKeyBoard();
Mouse * pMouse = p->createMouse();
pKeyBoard->show();
pMouse->show();
delete pMouse;
delete pKeyBoard;
delete p;
p = new FactoryLenovo();
pKeyBoard = p->createKeyBoard();
pMouse = p->createMouse();
pKeyBoard->show();
pMouse->show();
delete pMouse;
delete pKeyBoard;
delete p;
getchar();
return 0;
}