当前位置：首页 > news >正文

工厂方法模式：从理论到实战指南

news 2025/11/7 8:59:05

作为C++工程师，我们在项目中常遇到这样的问题：随着业务扩展，需要支持多种同类功能（如不同格式的数据解析、多平台的接口实现），直接用new创建对象会导致代码耦合严重、if-else冗余，后续扩展和维护成本激增。而工厂方法模式，正是解决这类“对象创建混乱”问题的核心设计模式之一。

本文将从理论本质出发，结合C++项目的工程实践，通过“数据解析器”场景完整落地工厂方法模式，最后梳理实际开发中的应用边界，帮助你真正掌握其核心价值。

一、理论基础：工厂方法模式到底是什么？

1.1 核心定义

工厂方法模式（Factory Method Pattern）是创建型设计模式的经典实现，其核心思想是：定义一个创建对象的接口（抽象工厂），让子类（具体工厂）决定实例化哪一个产品类，将对象的创建逻辑延迟到子类中。

简单来说：父类只规定“要创建什么类型的对象”，子类负责“具体创建哪个对象”，通过多态性屏蔽具体产品的创建细节。

1.2 四大核心角色

工厂方法模式的结构由4个关键角色构成，每个角色在C++中有明确的实现形式：

抽象产品（Product）：纯虚类，定义产品的统一接口（如数据解析器的parse方法），是所有具体产品的基类。
具体产品（ConcreteProduct）：继承抽象产品，实现具体业务逻辑（如JSON解析器、XML解析器），是实际被创建的对象。
抽象工厂（Factory）：纯虚类，声明创建产品的工厂方法（返回抽象产品指针），统一创建接口。
具体工厂（ConcreteFactory）：继承抽象工厂，实现工厂方法，返回具体产品实例，封装具体产品的创建和初始化逻辑。

1.3 解决的核心问题

对比“直接new对象”的传统写法，工厂方法模式的核心价值的在于：

解耦创建与使用：业务代码只需依赖抽象产品和抽象工厂，无需知道具体产品的实现细节（如JSON解析器如何初始化）。
支持开闭原则：新增产品时，只需新增“具体产品+具体工厂”，无需修改现有业务代码，避免牵一发而动全身。
消除冗余判断：用“多态”替代if-else/switch判断产品类型，代码结构更清晰、维护成本更低。
统一创建逻辑：对象的初始化（如加载配置、依赖注入）集中在工厂类中，避免创建逻辑散落在业务代码各处。

1.4 与“简单工厂模式”的区别

很多人会混淆两者，核心差异在于“谁来决定创建哪种产品”：

简单工厂模式：由一个“万能工厂类”通过if-else判断创建产品，新增产品需修改工厂类，违反开闭原则。
工厂方法模式：由多个“具体工厂类”分别创建对应产品（一个工厂对应一个产品），新增产品只需新增工厂，符合开闭原则。

简单说，工厂方法模式是对简单工厂模式的“抽象升级”，用多态解决了扩展性问题，更适合复杂项目。

二、工程结构：C++项目如何组织代码？

C++项目注重“头文件与源文件分离”“模块划分清晰”，工厂方法模式的代码组织需遵循这一规范。以下是以“数据解析器”为场景的C++工厂方法模式实现，涵盖JSON、XML、YAML三种格式的解析器，完整体现工厂方法模式的“抽象-具体”分层设计和扩展特性：

2.1 目录结构设计

data_parser_demo/
├── include/
│   ├── parser/
│   │   ├── IDataParser.h       // 抽象产品：数据解析器接口
│   │   ├── JsonParser.h        // 具体产品：JSON解析器
│   │   ├── XmlParser.h         // 具体产品：XML解析器
│   │   └── YamlParser.h        // 具体产品：YAML解析器
│   └── factory/
│       ├── IParserFactory.h    // 抽象工厂：解析器工厂接口
│       ├── JsonParserFactory.h // 具体工厂：JSON解析器工厂
│       ├── XmlParserFactory.h  // 具体工厂：XML解析器工厂
│       └── YamlParserFactory.h // 具体工厂：YAML解析器工厂
├── src/
│   ├── parser/                 // 具体产品实现
│   └── factory/                // 具体工厂实现
└── main.cpp                    // 测试代码

2.2 核心代码实现

1. 抽象产品：数据解析器接口（IDataParser.h）

// include/parser/IDataParser.h
#ifndef I_DATA_PARSER_H
#define I_DATA_PARSER_H#include <string>
#include <map>// 抽象产品：所有数据解析器的统一接口
class IDataParser {
public:virtual ~IDataParser() = default; // 基类虚析构，确保派生类析构正确调用// 核心接口：解析原始数据，返回键值对结果virtual std::map<std::string, std::string> parse(const std::string& rawData) = 0;// 辅助接口：返回解析器类型（如"json"、"xml"）virtual std::string type() const = 0;
};#endif // I_DATA_PARSER_H

2. 具体产品：不同格式的解析器实现

（1）JSON解析器（JsonParser.h/.cpp）

// include/parser/JsonParser.h
#ifndef JSON_PARSER_H
#define JSON_PARSER_H#include "parser/IDataParser.h"
#include <iostream>// 具体产品：JSON格式解析器
class JsonParser : public IDataParser {
public:std::map<std::string, std::string> parse(const std::string& rawData) override;std::string type() const override { return "json"; }
};#endif // JSON_PARSER_H// src/parser/JsonParser.cpp
#include "parser/JsonParser.h"// 模拟JSON解析逻辑：提取key-value（实际项目中可调用nlohmann/json等库）
std::map<std::string, std::string> JsonParser::parse(const std::string& rawData) {std::map<std::string, std::string> result;std::cout << "[JSON解析器] 开始解析数据：" << rawData << std::endl;// 模拟解析过程（实际应通过JSON库解析）// 示例：从"{\"name\":\"factory\",\"type\":\"method\"}"中提取键值对result["name"] = "factory";result["type"] = "method";std::cout << "[JSON解析器] 解析完成，提取" << result.size() << "个字段" << std::endl;return result;
}

（2）XML解析器（XmlParser.h/.cpp）

// include/parser/XmlParser.h
#ifndef XML_PARSER_H
#define XML_PARSER_H#include "parser/IDataParser.h"
#include <iostream>// 具体产品：XML格式解析器
class XmlParser : public IDataParser {
public:std::map<std::string, std::string> parse(const std::string& rawData) override;std::string type() const override { return "xml"; }
};#endif // XML_PARSER_H// src/parser/XmlParser.cpp
#include "parser/XmlParser.h"// 模拟XML解析逻辑：提取<key>value</key>（实际项目中可调用tinyxml2等库）
std::map<std::string, std::string> XmlParser::parse(const std::string& rawData) {std::map<std::string, std::string> result;std::cout << "[XML解析器] 开始解析数据：" << rawData << std::endl;// 模拟解析过程（实际应通过XML库解析）// 示例：从"<root><name>factory</name><type>method</type></root>"中提取键值对result["name"] = "factory";result["type"] = "method";std::cout << "[XML解析器] 解析完成，提取" << result.size() << "个字段" << std::endl;return result;
}

（3）YAML解析器（YamlParser.h/.cpp）

// include/parser/YamlParser.h
#ifndef YAML_PARSER_H
#define YAML_PARSER_H#include "parser/IDataParser.h"
#include <iostream>// 具体产品：YAML格式解析器
class YamlParser : public IDataParser {
public:std::map<std::string, std::string> parse(const std::string& rawData) override;std::string type() const override { return "yaml"; }
};#endif // YAML_PARSER_H// src/parser/YamlParser.cpp
#include "parser/YamlParser.h"// 模拟YAML解析逻辑：提取key: value（实际项目中可调用yaml-cpp等库）
std::map<std::string, std::string> YamlParser::parse(const std::string& rawData) {std::map<std::string, std::string> result;std::cout << "[YAML解析器] 开始解析数据：" << rawData << std::endl;// 模拟解析过程（实际应通过YAML库解析）// 示例：从"name: factory\ntype: method"中提取键值对result["name"] = "factory";result["type"] = "method";std::cout << "[YAML解析器] 解析完成，提取" << result.size() << "个字段" << std::endl;return result;
}

3. 抽象工厂：解析器工厂接口（IParserFactory.h）

// include/factory/IParserFactory.h
#ifndef I_PARSER_FACTORY_H
#define I_PARSER_FACTORY_H#include "parser/IDataParser.h"
#include <memory> // 智能指针管理解析器对象// 抽象工厂：所有解析器工厂的统一接口
class IParserFactory {
public:virtual ~IParserFactory() = default;// 工厂方法：创建对应的解析器（返回智能指针，自动管理内存）virtual std::unique_ptr<IDataParser> createParser() = 0;
};#endif // I_PARSER_FACTORY_H

4. 具体工厂：创建对应解析器

（1）JSON解析器工厂（JsonParserFactory.h/.cpp）

// include/factory/JsonParserFactory.h
#ifndef JSON_PARSER_FACTORY_H
#define JSON_PARSER_FACTORY_H#include "factory/IParserFactory.h"
#include "parser/JsonParser.h"// 具体工厂：创建JSON解析器
class JsonParserFactory : public IParserFactory {
public:std::unique_ptr<IDataParser> createParser() override;
};#endif // JSON_PARSER_FACTORY_H// src/factory/JsonParserFactory.cpp
#include "factory/JsonParserFactory.h"std::unique_ptr<IDataParser> JsonParserFactory::createParser() {// 可在此处添加JSON解析器的初始化逻辑（如加载配置、设置解析选项）return std::make_unique<JsonParser>();
}

（2）XML解析器工厂（XmlParserFactory.h/.cpp）

// include/factory/XmlParserFactory.h
#ifndef XML_PARSER_FACTORY_H
#define XML_PARSER_FACTORY_H#include "factory/IParserFactory.h"
#include "parser/XmlParser.h"// 具体工厂：创建XML解析器
class XmlParserFactory : public IParserFactory {
public:std::unique_ptr<IDataParser> createParser() override;
};#endif // XML_PARSER_FACTORY_H// src/factory/XmlParserFactory.cpp
#include "factory/XmlParserFactory.h"std::unique_ptr<IDataParser> XmlParserFactory::createParser() {// 可在此处添加XML解析器的初始化逻辑（如设置命名空间、忽略注释）return std::make_unique<XmlParser>();
}

（3）YAML解析器工厂（YamlParserFactory.h/.cpp）

// include/factory/YamlParserFactory.h
#ifndef YAML_PARSER_FACTORY_H
#define YAML_PARSER_FACTORY_H#include "factory/IParserFactory.h"
#include "parser/YamlParser.h"// 具体工厂：创建YAML解析器
class YamlParserFactory : public IParserFactory {
public:std::unique_ptr<IDataParser> createParser() override;
};#endif // YAML_PARSER_FACTORY_H// src/factory/YamlParserFactory.cpp
#include "factory/YamlParserFactory.h"std::unique_ptr<IDataParser> YamlParserFactory::createParser() {// 可在此处添加YAML解析器的初始化逻辑（如设置缩进、解析模式）return std::make_unique<YamlParser>();
}

5. 测试代码（main.cpp）

#include "factory/IParserFactory.h"
#include "factory/JsonParserFactory.h"
#include "factory/XmlParserFactory.h"
#include "factory/YamlParserFactory.h"
#include <iostream>// 业务函数：接收抽象工厂，完成数据解析（依赖抽象，不依赖具体）
void parseData(IParserFactory& factory, const std::string& rawData) {// 1. 工厂创建解析器（无需知道具体是哪种格式）auto parser = factory.createParser();std::cout << "使用[" << parser->type() << "]解析器处理数据" << std::endl;// 2. 调用解析接口（多态特性：不同解析器表现不同行为）auto result = parser->parse(rawData);// 3. 输出解析结果std::cout << "解析结果：" << std::endl;for (const auto& [key, value] : result) {std::cout << "  " << key << " = " << value << std::endl;}std::cout << "-------------------------" << std::endl;
}int main() {// 测试数据（不同格式的相同内容）const std::string jsonData = "{\"name\":\"factory\",\"type\":\"method\"}";const std::string xmlData = "<root><name>factory</name><type>method</type></root>";const std::string yamlData = "name: factory\ntype: method";// 1. 用JSON工厂解析JSON数据JsonParserFactory jsonFactory;parseData(jsonFactory, jsonData);// 2. 用XML工厂解析XML数据XmlParserFactory xmlFactory;parseData(xmlFactory, xmlData);// 3. 用YAML工厂解析YAML数据YamlParserFactory yamlFactory;parseData(yamlFactory, yamlData);// 新增解析器（如CSV）只需：// - 新增CsvParser（实现IDataParser）// - 新增CsvParserFactory（实现IParserFactory）// - 无需修改parseData等现有代码return 0;
}

2.3 运行结果

使用[json]解析器处理数据
[JSON解析器] 开始解析数据：{"name":"factory","type":"method"}
[JSON解析器] 解析完成，提取2个字段
解析结果：name = factorytype = method
-------------------------
使用[xml]解析器处理数据
[XML解析器] 开始解析数据：<root><name>factory</name><type>method</type></root>
[XML解析器] 解析完成，提取2个字段
解析结果：name = factorytype = method
-------------------------
使用[yaml]解析器处理数据
[YAML解析器] 开始解析数据：name: factory
type: method
[YAML解析器] 解析完成，提取2个字段
解析结果：name = factorytype = method
-------------------------