工厂模式

DataExchangeServiceProxy::Create 所体现的“工厂模式”是软件开发中一种经典的创建型设计模式，其核心目的是封装对象的创建过程，使客户端无需直接依赖具体类的构造函数，而是通过统一的“工厂接口”获取对象实例。这种模式能降低代码耦合度，提高扩展性（如新增产品类型时无需修改客户端代码）。

典型的工厂模式实现主要有以下几种，从简单到复杂分为：

一、简单工厂模式（Simple Factory）

核心思想：通过一个单独的工厂类（或静态方法）根据输入参数创建不同类型的对象，客户端只需要调用工厂的创建方法，无需关心具体实现。

结构：

• 产品接口（Product）：定义所有产品的公共方法（如 DataExchangeServiceProxy）。
• 具体产品（ConcreteProduct）：实现产品接口的具体类（如 DataExchangeServiceProxyImpl）。
• 工厂类（Factory）：提供静态或实例方法，根据参数创建并返回具体产品实例。

示例代码：

// 产品接口
class DataExchangeServiceProxy {
public:
    virtual void CreateTask(...) = 0; // 纯虚接口
    // 其他方法...
};

// 具体产品
class DataExchangeServiceProxyImpl : public DataExchangeServiceProxy {
public:
    void CreateTask(...) override { /* 实现 */ }
};

// 简单工厂（可通过静态方法实现）
class ProxyFactory {
public:
    static std::shared_ptr<DataExchangeServiceProxy> Create(
        const std::string& instance_name) {
        // 根据参数创建具体产品（此处简化为固定返回ProxyImpl）
        return std::make_shared<DataExchangeServiceProxyImpl>();
    }
};

// 客户端使用
auto proxy = ProxyFactory::Create("global_de_instance");
proxy->CreateTask(...);

适用场景：产品类型较少且稳定，不需要频繁扩展新类型。

二、工厂方法模式（Factory Method）

核心思想：将对象的创建延迟到子类，父类只定义创建对象的接口，由子类决定具体创建哪种产品。每个产品对应一个工厂子类。

结构：

• 产品接口（Product）：同上（如 DataExchangeServiceProxy）。
• 具体产品（ConcreteProduct）：同上（如 ProxyImplForA、ProxyImplForB，对应不同DE服务实例）。
• 工厂接口（Factory）：定义创建产品的纯虚方法（如 CreateProxy()）。
• 具体工厂（ConcreteFactory）：实现工厂接口，创建对应类型的具体产品。

示例代码：

// 产品接口
class DataExchangeServiceProxy {
public:
    virtual void CreateTask(...) = 0;
};

// 具体产品A（对应实例A）
class ProxyImplA : public DataExchangeServiceProxy {
public:
    void CreateTask(...) override { /* 实例A的实现 */ }
};

// 具体产品B（对应实例B）
class ProxyImplB : public DataExchangeServiceProxy {
public:
    void CreateTask(...) override { /* 实例B的实现 */ }
};

// 工厂接口
class ProxyFactory {
public:
    virtual std::shared_ptr<DataExchangeServiceProxy> CreateProxy() = 0;
};

// 具体工厂A（创建产品A）
class FactoryA : public ProxyFactory {
public:
    std::shared_ptr<DataExchangeServiceProxy> CreateProxy() override {
        return std::make_shared<ProxyImplA>();
    }
};

// 具体工厂B（创建产品B）
class FactoryB : public ProxyFactory {
public:
    std::shared_ptr<DataExchangeServiceProxy> CreateProxy() override {
        return std::make_shared<ProxyImplB>();
    }
};

// 客户端使用
ProxyFactory* factory = new FactoryA(); // 按需选择工厂
auto proxy = factory->CreateProxy();
proxy->CreateTask(...);

适用场景：产品类型较多，且需要频繁扩展新类型（新增产品时只需新增对应的具体产品和工厂，符合“开闭原则”）。

三、抽象工厂模式（Abstract Factory）

核心思想：创建一系列相关或相互依赖的产品族（而非单个产品），工厂接口定义多个产品的创建方法，具体工厂实现这些方法以生成完整的产品族。

结构：

• 产品接口族：多个相关产品的接口（如 DataExchangeProxy、LogProxy，同属“服务代理”产品族）。
• 具体产品族：实现接口族的具体产品（如 DEProxyImpl、LogProxyImpl 组成“DE服务相关代理族”）。
• 抽象工厂接口：定义创建产品族中所有产品的方法（如 CreateDataExchangeProxy()、CreateLogProxy()）。
• 具体工厂：实现抽象工厂，创建对应产品族的所有具体产品。

示例代码：

// 产品接口族
class DataExchangeServiceProxy { public: virtual void CreateTask(...) = 0; };
class LogServiceProxy { public: virtual void Log(...) = 0; };

// 具体产品族（DE服务相关代理）
class DEDataProxy : public DataExchangeServiceProxy {
public: void CreateTask(...) override { /* 实现 */ }
};
class DELogProxy : public LogServiceProxy {
public: void Log(...) override { /* 实现 */ }
};

// 抽象工厂接口
class ServiceProxyFactory {
public:
    virtual std::shared_ptr<DataExchangeServiceProxy> CreateDataProxy() = 0;
    virtual std::shared_ptr<LogServiceProxy> CreateLogProxy() = 0;
};

// 具体工厂（创建DE服务相关代理族）
class DEProxyFactory : public ServiceProxyFactory {
public:
    std::shared_ptr<DataExchangeServiceProxy> CreateDataProxy() override {
        return std::make_shared<DEDataProxy>();
    }
    std::shared_ptr<LogServiceProxy> CreateLogProxy() override {
        return std::make_shared<DELogProxy>();
    }
};

// 客户端使用
ServiceProxyFactory* factory = new DEProxyFactory();
auto dataProxy = factory->CreateDataProxy();
auto logProxy = factory->CreateLogProxy();

适用场景：需要创建多个相关产品（如一套服务的配套代理），且产品族可能有多种变体（如“DE服务代理族”“OTA服务代理族”）。

回到 DataExchangeServiceProxy::Create 的模式定位

DataExchangeServiceProxy::Create 更接近简单工厂模式的变体：

• 它通过静态方法（Create）封装了 DataExchangeServiceProxyImpl 的创建过程，客户端无需直接实例化 Impl 类。
• 虽然没有单独的“工厂类”，但 Create 方法本身承担了工厂的职责（判断初始化是否成功、返回接口实例）。
• 若未来扩展多种 ProxyImpl（如不同协议的代理），可通过参数在 Create 中区分，无需修改客户端调用方式，符合简单工厂的灵活性。

工厂模式的核心价值

1. 解耦：客户端只依赖产品接口，不依赖具体实现类，降低代码耦合。
2. 隐藏细节：对象创建的复杂逻辑（如 InitProxyImpl 中的初始化步骤）被封装在工厂中，客户端无需关心。
3. 可扩展性：新增产品类型时，只需修改工厂或新增工厂子类，无需修改客户端代码（符合“开闭原则”）。

这也是 DataExchangeServiceProxy::Create 采用工厂模式的根本原因——简化客户端调用，同时为DE服务代理的扩展（如支持多实例、多协议）预留空间。