[设计模式——Factory模式]

        根据关注点分离（Soc），对象的创建应该与对象在特定领内的任务分开。上面讨论的依赖注入模式就是以最直接的方式遵循了这一原则。因为整个对象的创建过程集中在基础元素中，并且对象不必关心这些。

        但是，如果需要在运行时的某个时刻动态创建对象，这个任务可以由对象工厂来接管。

        Factory设计模式基本上相对简单，并且以很多不同的形式和种类出现在代码库中。除了遵循SoC原则外，它还严格遵循信息隐藏原则，因为实例的创建过程被隐藏在其用户之外。

        正如前面说过的那样，Factory模式可以有无数的形式和变体。这里只讨论一个简单的变体。

        简单Factory

        Factory模式最简单的一种实现看起来像下面这样（使用上面的依赖注入（DI）部分用到的Logging示例）:

        可能是最简单的最容易想到的一种对象Factory

#include"LoggingFacility.h"
#include"StandardOutputLogger.h"
//可能是最简单的最容易想到的一种对象Factory

class LoggerFactory
{
public:
	static Logger create() {
		return std::make_shared<StandardOutputLogger>();
	}
};

这个非常简单的Factory模式的用法如下所示：

使用LoggerFactory创建Logger实例

#include"LoggerFactory.h"

//使用LoggerFactory创建Logger实例
int main()
{
	Logger logger = LoggerFactory::create();
	// ...log something...
	return 0;
}

也许你现在会问，为这样一个微不足道的任务浪费一个饿额外的类是否值得。好吧，也许不值得。但如果Factory能够创建各种Logger，并决定它应该是哪种类型，那它就变得更有意义了。例如，我们可以通过读取和处理配置文件内容，或从Windows注册表数据库中读取某个密钥来完成这一操作。我们还可以想象，生成的对象的类型取决于一天中的某个时间点。总之，可能是无限的。重要的是，这一过程应该对客户端类完全透明。所以这里有一个更复杂的LoggerFactory，它读取配置文件（如硬盘文件）内容并根据配置创建特定的Logger:

一个更复杂的Factory模式，用于读取并处理配置文件

#include"LoggingFacility.h"
#include"StandardOutputLogger.h"
//#include"FilesystemLogger.h"
#include<fstream>
#include<string>
#include<string_view>
// 一个更复杂的Factory模式，用于读取和处理配置文件
class LoggerFactory
{
private:
	enum class OutputTarget:int{
		STDOUT,
		FILE
	};
public:
	explicit LoggerFactory(std::string configurationFileName) :
		configurationFileName{ configurationFileName } {}

	Logger create()const {
		const std::string configurationFileContent = readConfigurationFile();
		OutputTarget outputTarget = evaluateConfiguration(configurationFileContent);
		return createLogger(outputTarget);
	}
private:
	std::string readConfigurationFile() const {
		std::ifstream filestream(configurationFileName);
		return std::string(std::istreambuf_iterator<char>(filestream),
			std::istreambuf_iterator<char>());
	}

	OutputTarget evaluateConfiguration(std::string configurationFileContent)const {
		// Evaluate the content of the configuration file...
		return OutputTarget::STDOUT;
	}

	Logger createLogger(OutputTarget outputTarget)const {
		switch (outputTarget)
		{
		case LoggerFactory::OutputTarget::STDOUT:
			//return std::make_shared<FilesystemLogger>();
		case LoggerFactory::OutputTarget::FILE:
		default:
			return std::make_shared<StandardOutputLogger>();
		}
	}
	const std::string configurationFileName;
};

Customer使用LoggerFactory获取具体的Logger 

 Customer在使用Factory模式时“知道”factory类的存在。这种依赖性并不是一个严重的问题，但它再次清楚地表明，使用依赖注入可以最大程度地实现松散耦合 。