[设计模式] 工厂模式

什么是工厂模式

工厂模式(Factory Pattern)属于创建型模式，它提供了一种创建对象的最佳方式。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。这满足创建型模式中所要求的“创建与使用相分离”的特点。

工厂模式将目的将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

工厂模式分为以下三类：

• 简单工厂模式（Simple Factory)
• 工厂方法模式（Factory Method）
• 抽象工厂模式（Abstract Factory）

《设计模式》一书中将工厂模式分为两类：工厂方法模式与抽象工厂模式。简单工厂模式被看工厂方法模式的一种特例，两者归为一类。 也就是GOF提出的23种设计模式并不包含简单工厂模式。这三种模式逐步抽象。

简单工厂模式

在简单工厂模式中，创建实例的方法通常为静态方法。因此简单工厂模式又叫作静态工厂方法模式(Static Factory Method Pattern)。

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离，降低系统的耦合度，使得两个修改起来相对容易些，当以后实现改变时，只需要修改工厂类即可。

简单工厂模式中的角色

• 具体工厂：负责实现创建所有实例的内部逻辑。它提供了创建产品的方法，调用者通过该方法来获取产品。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。

• 抽象产品角色：定义了产品的规范，描述了产品的主要特性和功能。简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

• 具体产品角色：是实现或者继承抽象产品的子类，也是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

UML类图

代码

抽象产品接口：

class IProduct{
public:
    virtual void func() = 0;
};

具体产品1和2：

class Product1:public IProduct{
public:
    void func(){
        std::cout<<"I'm product 1 \n";
    }
};

class Product2:public IProduct{
public:
    void func(){
        std::cout<<"I'm product 2 \n";
    }
};

工厂类：

class Factory{
public:
    static IProduct* createProduct(int n){
        switch (n){
            case 1:return new Product1;  
            case 2:return new Product2;
        }
        return nullptr;
    }
};

主函数：

int main(){
    IProduct* p1 = Factory::createProduct(1);
    IProduct* p2 = Factory::createProduct(2);
    p1->func();
    p2->func();

	delete p1, p2;
}

输出内容：

I'm product 1 
I'm product 2

简单工厂模式的缺点在于每次添加新产品就需要修改工厂类。在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展维护，并且工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。违背了“开闭原则”。

为了解决简单工厂模式的问题，出现了工厂方法模式。

工厂方法模式

工厂方法模式是对简单工厂模式的进一步抽象化，并定义一个创建对象的接口。其好处是可以使系统在不修改原来代码的情况下引进新的产品。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类，这样工厂的设计就符合“开闭原则”了，扩展时不必去修改原来的代码。在使用时，用于只需知道产品对应的具体工厂，关注具体的创建过程，甚至不需要知道具体产品类的类名，当我们选择哪个具体工厂时，就已经决定了实际创建的产品是哪个了。

但缺点在于，每增加一个产品都需要增加一个具体产品类和实现工厂类，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

工厂方法模式中的角色

• 抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
• 具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
• 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

UML类图

代码

抽象产品接口：

class IProduct{
public:
    virtual void func() = 0;
};

具体产品：

class Product1:public IProduct{
public:
    void func(){
        std::cout<<"I'm product 1 \n";
    }
};

class Product2:public IProduct{
public:
    void func(){
        std::cout<<"I'm product 2 \n";
    }
};

抽象工厂接口：

class IFactory{
public:
    virtual IProduct* createProduct() = 0;
};

具体工厂：

class Product1Factory:public IFactory{
public:
    IProduct* createProduct(){
        return new Product1;  
    }
};
class Product2Factory:public IFactory{
public:
    IProduct* createProduct(){
        return new Product2;  
    }
};

主函数：

int main(){
    IFactory* fac = nullptr;
    
    fac = new Product1Factory();
    IProduct* p1 = fac->createProduct();
    
    fac = new Product2Factory();
    IProduct* p2 = fac->createProduct();
    
    p1->func();
    p2->func();

	delete fac, p1, p2;
}

输出内容：

I'm product 1 
I'm product 2

抽象工厂模式

在工厂方法模式中，我们使用一个工厂创建一个产品，一个具体工厂对应一个具体产品，但有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。

在介绍抽象工厂模式前，我们先厘清两个概念：

• 产品等级结构：产品等级结构指的是产品的继承结构，例如下图果园1，果园2，果园3出产的苹果属于苹果，也可以说是继承了苹果抽象类，那么这个苹果抽象类和他的子类就构成了一个产品等级结构。
• 产品族：产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，果园1出产苹果、橙子、香蕉。它们就属于同一产品族。

抽象工厂模式主要用于创建相关对象的族，一个工厂就是一个产品族。通过抽象工厂模式，我们能够保证客户端始终只使用同一个产品族中的对象。并且通过隔离具体类的生成，使得客户端不需要明确指定具体生成类。所有的具体工厂都实现了抽象工厂中定义的公共接口。

但该模式的缺点在于添加新的行为时比较麻烦，如果需要添加一个新产品族对象时，需要更改接口及其下所有子类。

抽象工厂模式中的角色

抽象工厂：提供了创建产品的接口，包含多个创建产品的方法，可以创建多个不同等级的产品。所有的具体工厂都必须实现此接口。

具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。用于生产不同产品族，要创建一个产品，用户只需使用其中一个工厂进行获取，完全不需要实例化任何产品对象。

抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。是一个产品家族，每一个具体工厂都能够生产一整组产品。

具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

UML类图

代码

抽象产品接口：

class IProductA{
public:
    virtual void func() = 0;
};

class IProductB{
public:
    virtual void func() = 0;
};

具体产品类实现：

class ProductA1:public IProductA{
public:
    void func(){
        std::cout<<"I'm product A1 \n";
    }
};

class ProductA2:public IProductA{
public:
    void func(){
        std::cout<<"I'm product A2 \n";
    }
};

class ProductB1:public IProductB{
public:
    void func(){
        std::cout<<"I'm product B1 \n";
    }
};

class ProductB2:public IProductB{
public:
    void func(){
        std::cout<<"I'm product B2 \n";
    }
};

抽象工厂接口：

class IFactory{
public:
    virtual IProductA* createProductA() = 0;
    virtual IProductB* createProductB() = 0;
};

具体工厂：

class Product1Factory:public IFactory{
public:
    IProductA* createProductA(){
        return new ProductA1;
    }
    IProductB* createProductB(){
        return new ProductB1;
    }
};

class Product2Factory:public IFactory{
public:
    IProductA* createProductA(){
        return new ProductA2;
    }
    IProductB* createProductB(){
        return new ProductB2;
    }
};

主函数

int main(){
    IFactory* fac1 = new Product1Factory();
    IFactory* fac2 = new Product2Factory();
    
    IProductA* pa1 = fac1->createProductA();
    IProductA* pa2 = fac2->createProductA();
    IProductB* pb1 = fac1->createProductB();
    IProductB* pb2 = fac2->createProductB();

    pa1->func();
    pa2->func();
    pb1->func();
    pb2->func();

    delete fac1, fac2, pa1, pa2, pb1, pb2;
}

输出结果：

I'm product A1
I'm product A2
I'm product B1
I'm product B2