首页 > 代码库 > 【设计模式】工厂模式

【设计模式】工厂模式

2024-11-01 07:03:39 204人阅读

1、工厂模式概述

工厂方法模式使用的频率非常高，在我们日常的开发中总能见到它的身影。

工厂方法解决的问题是可以让你轻松方便的构造对象实例，而不必不必关心构造对象实例的细节和复杂过程。

在我们日常生活中经常遇到的有三种工厂模式：简单工厂模式，工厂模式，抽象工厂模式。

2、简单工厂模式

2.1 应用

例如部署多种数据库的情况，可能在不同的地方要使用不同的数据库，此时只需要在配置文件中设定数据库的类型，每次再根据类型生成实例，这样，不管下面的数据库类型怎么变化，在客户端看来都是只有一个AbstractProduct，使用的时候根本无需修改代码。提供的类型也可以用比较便于识别的字符串，这样不用记很长的类名，还可以保存为配置文件。

这样，每次只需要修改配置文件和添加新的产品子类即可。

所以简单工厂模式一般应用于多种同类型类的情况，将这些类隐藏起来，再提供统一的接口，便于维护和修改。

2.2 类图

技术分享

2.3 代码

2.3.1 产品类

//AbstractProduct.h

#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_

#include <stdio.h>

class AbstractProduct
{
public:
    AbstractProduct();
    virtual ~AbstractProduct();
    
public:
    virtual void operation() = 0;
};

class ProductA:public AbstractProduct
{
public:
    ProductA();
    virtual ~ProductA();
    
public:
    void operation();
};

class ProductB:public AbstractProduct
{
public:
    ProductB();
    ~ProductB();
    
public:
    void operation();
};

#endif

//AbstractProduct.cpp

#include "AbstractProduct.h"

AbstractProduct::AbstractProduct(){}

AbstractProduct::~AbstractProduct(){}

ProductA::ProductA(){}

ProductA::~ProductA(){}

void ProductA::operation()
{
    fprintf(stderr,"productA operation!\n");
}

ProductB::ProductB(){}

ProductB::~ProductB(){}

void ProductB::operation()
{
    fprintf(stderr,"productB operation!\n");
}

2.3.2 工厂类

//SimpleFactory.h

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#include "AbstractProduct.h"

class AbstractFactory{

public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProduct* createProduct(int type) = 0;    
};

class SimpleFactory:public AbstractFactory
{
public:
    SimpleFactory();
    ~SimpleFactory();
    
public:
    AbstractProduct* createProduct(int type);
};

#endif

//SimpleFactory.cpp

#include "SimpleFactory.h"

AbstractFactory::AbstractFactory(){}

AbstractFactory::~AbstractFactory(){}

SimpleFactory::SimpleFactory(){}

SimpleFactory::~SimpleFactory(){}

AbstractProduct* SimpleFactory::createProduct(int type)
{
    AbstractProduct* temp = NULL;

    switch(type)
    {
    case 1:
        temp = new ProductA();
        break;
    case 2:
        temp = new ProductB();
        break;
    default:
        break;
    }
    return temp;
}

2.3.3 调用

//client.cpp

#include "SimpleFactory.h"

int main()
{
    AbstractFactory* factory = new SimpleFactory();

    AbstractProduct* product = factory->createProduct(1);
    product->operation();
    delete product;
    product = NULL;
    
    product = factory->createProduct(2);
    product->operation();
    delete product;
    product = NULL;

    return 0;
}

2.4 优缺点

2.4.1 优点

1.隐藏了对象创建的细节，将产品的实例化推迟到子类中实现。

2.客户端基本不用关心使用的是哪个产品，只需要知道用哪个工厂就行了，提供的类型也可以用比较便于识别的字符串。

3.方便添加新的产品子类，每次只需要修改工厂类传递的类型值就行了。

4.遵循了依赖倒转原则。

2.4.2 缺点

1.要求产品子类的类型差不多，使用的方法名都相同，如果类比较多，而所有的类又必须要添加一种方法，则会是非常麻烦的事情。或者是一种类另一种类有几种方法不相同，客户端无法知道是哪一个产品子类，也就无法调用这几个不相同的方法。

2.每添加一个产品子类，都必须在工厂类中添加一个判断分支，这违背了开放-封闭原则。

3、工厂模式

3.1 工厂模式定义

Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.（定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。）

工厂模式基本与简单工厂模式差不多，上面也说了，每次添加一个产品子类都必须在工厂类中添加一个判断分支，这样违背了开放-封闭原则，因此，工厂模式就是为了解决这个问题而产生的。

既然每次都要判断，那我就把这些判断都生成一个工厂子类，这样，每次添加产品子类的时候，只需再添加一个工厂子类就可以了。这样就完美的遵循了开放-封闭原则。但这其实也有问题，如果产品数量足够多，要维护的量就会增加，好在一般工厂子类只用来生成产品类，只要产品子类的名称不发生变化，那么基本工厂子类就不需要修改，每次只需要修改产品子类就可以了。

3.2 应用场景

基本与简单工厂模式一致，只不过是改进了简单工厂模式中的开放-封闭原则的缺陷，使得模式更具有弹性。将实例化的过程推迟到子类中，由子类来决定实例化哪个。

同样工厂模式一般应该于程序中大部分地方都只使用其中一种产品，工厂类也不用频繁创建产品类的情况。这样修改的时候只需要修改有限的几个地方即可。

3.3 类图

技术分享

3.4 代码

3.4.1 产品类

//AbstractProduct.h

#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_

#include <stdio.h>

class AbstractProduct
{
public:
    AbstractProduct();
    virtual ~AbstractProduct();
    
public:
    virtual void operation() = 0;
};

class ProductA:public AbstractProduct
{
public:
    ProductA();
    virtual ~ProductA();
    
public:
    void operation();
};

class ProductB:public AbstractProduct
{
public:
    ProductB();
    ~ProductB();
    
public:
    void operation();
};

#endif

//AbstractProduct.cpp

#include "AbstractProduct.h"

AbstractProduct::AbstractProduct(){}

AbstractProduct::~AbstractProduct(){}

ProductA::ProductA(){}

ProductA::~ProductA(){}

void ProductA::operation()
{
    fprintf(stderr,"productA operation!\n");
}

ProductB::ProductB(){}

ProductB::~ProductB(){}

void ProductB::operation()
{
    fprintf(stderr,"productB operation!\n");
}

3.4.2 工厂类

//AbstractFactory.h

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#include "AbstractProduct.h"

class AbstractFactory
{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProduct* createProduct() = 0;    
};

class FactoryA:public AbstractFactory
{
public:
    FactoryA();
    ~FactoryA();
    
public:
    AbstractProduct* createProduct();
};

class FactoryB:public AbstractFactory
{
public:
    FactoryB();
    ~FactoryB();
    
public:
    AbstractProduct* createProduct();
};

#endif

//AbstractFactory.cpp

#include "AbstractFactory.h"

AbstractFactory::AbstractFactory(){}

AbstractFactory::~AbstractFactory(){}

FactoryA::FactoryA(){}

FactoryA::~FactoryA(){}

AbstractProduct* FactoryA::createProduct()
{
    AbstractProduct* temp = NULL;
    temp = new ProductA();
    return temp;
}

FactoryB::FactoryB(){}

FactoryB::~FactoryB(){}

AbstractProduct* FactoryB::createProduct()
{
    AbstractProduct* temp = NULL;
    temp = new ProductB();
    return temp;
}

3.4.3 调用

//client.cpp

#include "AbstractFactory.h"

int main()
{
    AbstractFactory* factory = new FactoryA();
    AbstractProduct* product = factory->createProduct();
    product->operation();
    delete product;
    product = NULL;
    delete factory;
    factory = NULL;
    
    factory = new FactoryB();
    product = factory->createProduct();
    product->operation();
    delete product;
    product = NULL;
    delete factory;
    factory = NULL;
    return 0;
}

3.5 优缺点

3.5.1 优点

1.基本与简单工厂模式一致，多的一点优点就是遵循了开放-封闭原则，使得模式的灵活性更强。

2.良好的封装性，代码结构清晰。一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类型就可以了，不用知道创建对象的艰辛过程，降低模块间的耦合。

3.工厂方法模式的扩展性非常优秀。在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。

4.屏蔽产品类。这一特点非常重要，产品类的实现如何变化，调用者都不需要关心，它只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不要发生变化。因为产品类的实例化工作是由工厂类负责的，一个产品对象具体由哪一个产品生成是由工厂类决定的。

5.工厂方法模式是典型的解耦框架。高层模块值需要知道产品的抽象类，其他的实现类都不用关心，符合迪米特法则，我不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；当然也符合里氏替换原则，使用产品子类替换产品父类，没问题！

3.5.2 缺点

和简单工厂模式一致。

4、抽象工厂模式

4.1 定义

Provide an interface for creating families of related or dependent objects without specifyingtheir concrete classes.（为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。）

抽象工厂模式就变得比工厂模式更为复杂，就像上面提到的缺点一样，工厂模式和简单工厂模式要求产品子类必须要是同一类型的，拥有共同的方法，这就限制了产品子类的扩展。于是为了更加方便的扩展，抽象工厂模式就将同一类的产品子类归为一类，让他们继承同一个抽象子类，我们可以把他们一起视作一组，然后好几组产品构成一族。

此时，客户端要使用时必须知道是哪一个工厂并且是哪一组的产品抽象类。每一个工厂子类负责产生一族产品，而子类的一种方法产生一种类型的产品。在客户端看来只有AbstractProductA和AbstractProductB两种产品，使用的时候也是直接使用这两种产品。而通过工厂来识别是属于哪一族产品。

4.2 类图

技术分享

产品ProductA_1和ProductB_1构成一族产品，对应于有Factory1来创建，也就是说Factory1总是创建的ProductA_1和ProductB_1的产品，在客户端看来只需要知道是哪一类工厂和产品组就可以了。一般来说， ProductA_1和ProductB_1都是适应同一种环境的，所以他们会被归为一族。

4.3 使用场景

例如Linux和windows两种操作系统下，有2个挂件A和B，他们在Linux和Windows下面的实现方式不同，Factory1负责产生能在Linux下运行的挂件A和B，Factory2负责产生能在Windows下运行的挂件A和B，这样如果系统环境发生变化了，我们只需要修改工厂就行了。

4.4 代码

4.4.1 产品类

//AbstractProductA.h

#ifndef _ABSTRACTPRODUCTA_H_
#define _ABSTRACTPRODUCTA_H_

#include <stdio.h>

class AbstractProductA
{
public:
    AbstractProductA();
    virtual ~AbstractProductA();
    
public:
    virtual void operationA() = 0;
};

class ProductA_1:public AbstractProductA
{
public:
    ProductA_1();
    virtual ~ProductA_1();
    
public:
    void operationA();
};

class ProductA_2:public AbstractProductA
{
public:
    ProductA_2();
    ~ProductA_2();
    
public:
    void operationA();
};

#endif

//AbstractProductA.cpp

#include "AbstractProductA.h"

AbstractProductA::AbstractProductA(){}

AbstractProductA::~AbstractProductA(){}

ProductA_1::ProductA_1(){}

ProductA_1::~ProductA_1(){}

void ProductA_1::operationA()
{
    fprintf(stderr,"productA_1 operation!\n");
}

ProductA_2::ProductA_2(){}

ProductA_2::~ProductA_2(){}

void ProductA_2::operationA()
{
    fprintf(stderr,"productA_2 operation!\n");
}

//AbstractProductB.h

#ifndef _ABSTRACTPRODUCTB_H_
#define _ABSTRACTPRODUCTB_H_

#include <stdio.h>

class AbstractProductB
{
public:
    AbstractProductB();
    virtual ~AbstractProductB();
    
public:
    virtual void operationB() = 0;
};

class ProductB_1:public AbstractProductB
{
public:
    ProductB_1();
    virtual ~ProductB_1();
    
public:
    void operationB();
};

class ProductB_2:public AbstractProductB
{
public:
    ProductB_2();
    ~ProductB_2();
    
public:
    void operationB();
};

#endif

//AbstractProductB.cpp

#include "AbstractProductB.h"

AbstractProductB::AbstractProductB(){}

AbstractProductB::~AbstractProductB(){}

ProductB_1::ProductB_1(){}

ProductB_1::~ProductB_1(){}

void ProductB_1::operationB()
{
    fprintf(stderr,"productB_1 operation!\n");
}

ProductB_2::ProductB_2(){}

ProductB_2::~ProductB_2(){}

void ProductB_2::operationB()
{
    fprintf(stderr,"productB_2 operation!\n");
}

4.4.2 工厂类

//AbstractFactory.h

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#include "AbstractProductA.h"
#include "AbstractProductB.h"

class AbstractFactory
{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProductA* createProductA() = 0;    
    virtual AbstractProductB* createProductB() = 0;    
};


class Factory1:public AbstractFactory
{
public:
    Factory1();
    ~Factory1();
    
public:
    AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};

class Factory2:public AbstractFactory
{
public:
    Factory2();
    ~Factory2();
    
public:
    AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};

#endif

//AbstractFactory.cpp

#include "AbstractFactory.h"

AbstractFactory::AbstractFactory(){}

AbstractFactory::~AbstractFactory(){}

Factory1::Factory1(){}

Factory1::~Factory1(){}

AbstractProductA* Factory1::createProductA()
{
    AbstractProductA* temp = NULL;
    temp = new ProductA_1();
    return temp;
}

AbstractProductB* Factory1::createProductB()
{
    AbstractProductB* temp = NULL;
    temp = new ProductB_1();
    return temp;
}

Factory2::Factory2(){}

Factory2::~Factory2(){}

AbstractProductA* Factory2::createProductA()
{
    AbstractProductA* temp = NULL;
    temp = new ProductA_2();
    return temp;
}

AbstractProductB* Factory2::createProductB()
{
    AbstractProductB* temp = NULL;
    temp = new ProductB_2();
    return temp;
}

4.4.3 调用

//client.cpp

#include "AbstractFactory.h"

int main()
{
    AbstractFactory* factory = new Factory1();
    AbstractProductA* productA = factory->createProductA();
    AbstractProductB* productB = factory->createProductB();
    productA->operationA();
    productB->operationB();
    
    delete factory;
    factory = NULL;
    delete productA;
    productA = NULL;
    delete productB;
    productB = NULL;
    
    factory = new Factory2();
    productA = factory->createProductA();
    productB = factory->createProductB();
    productA->operationA();
    productB->operationB();
    
    delete factory;
    factory = NULL;
    delete productA;
    productA = NULL;
    delete productB;
    productB = NULL;
    return 0;
}

4.5 优缺点

4.5.1 优点

1.封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂就行了。

2.可以支持不同类型的产品，使得模式灵活性更强。

3.可以非常方便的使用一族中间的不同类型的产品。

4.5.2 缺点

1.结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。

2.每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。

【设计模式】工厂模式

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > 【设计模式】工厂模式

【设计模式】工厂模式

1、工厂模式概述

2、简单工厂模式

2.1 应用

2.2 类图

2.3 代码

2.3.1 产品类

2.3.2 工厂类

2.3.3 调用

2.4 优缺点

2.4.1 优点

2.4.2 缺点

3、工厂模式

3.1 工厂模式定义

3.3 类图

3.4 代码

3.4.1 产品类

3.4.2 工厂类

3.4.3 调用

3.5 优缺点

3.5.1 优点

3.5.2 缺点

4、抽象工厂模式

4.1 定义

4.2 类图

4.3 使用场景

4.4 代码

4.4.1 产品类

4.4.2 工厂类

4.4.3 调用

4.5 优缺点

4.5.1 优点

4.5.2 缺点

看完仍有疑问？有类似问题直接问程序猿