设计模式之简单工厂模式浅析

[导读]工厂方法模式是一种创建型模式，是简单工厂模式的一个升级版本，主要解决简单工厂模式不符合开闭原则的问题。本文会先说一下简单工厂模式，以及存在的问题，然后再引出工厂模式。

1. 介绍

工厂方法模式是一种创建型模式，是简单工厂模式的一个升级版本，主要解决简单工厂模式不符合开闭原则的问题。本文会先说一下简单工厂模式，以及存在的问题，然后再引出工厂模式。

工厂设计模式是一种创建对象的设计模式，它的主要目的是通过定义一个接口来创建对象，使得子类决定实例化哪个类。这篇文章，我们将分析工厂模式是什么，它包含什么类型以及如何工作。

从整体上看，工厂模式可以分为三种主要类型：简单工厂模式、工厂方法模式和抽象工厂模式。

1.1 简单工厂模式

简单工厂模式定义一个创建对象的类(工厂类)来负责创建其他对象(产品对象)的实例，这个类(工厂类)中的创建功能根据参数不同，创建不同的对象(产品对象)实例。这就存在一个问题，每增加一个产品类，就要修改工厂的创建逻辑，增加一个相应的产品对象创建，这违反了程序设计的开闭原则。

概述

简单工厂模式并不是一个正式的设计模式，而是一个创建对象的简单方法。在简单工厂模式中，通常会有一个工厂类，它根据参数的不同返回不同类型的对象。这个模式的优点是简单明了，但缺点是违背了开闭原则。

角色

工厂类：负责创建产品的实例，提供一个静态方法供外部调用。

产品类：所有产品类都需实现相同的接口，用于定义产品的公共行为。

客户端：通过工厂类来获取产品实例，并使用这些实例。

设计模式之简单工厂模式(C#语言描述)

严格意义上来说，简单工厂模式并不属于GoF的23种设计模式，但是它是学习其他工厂模式的基础和前提条件。理解了简单工厂模式，学习工厂方法模式和抽象工厂模式会比较容易一些。

简单工厂模式的定义

定义一个工厂类，他可以根据不同的参数返回不同类的实例。通常情况下，被创建的类的实例通常都具有共同的父类。

简单工厂模式又可以称之为静态工厂方法模式，因为创建对象实例的方法通常都是静态方法。

在简单工厂模式中，只需要记住一点。一个简单的参数可以即可获得所需的对象实例。

简单工厂模式的UML图如下：

简单工厂模式包含三个角色：

1、工厂角色(Factory)：该类是简单工厂的核心，我们所需要的对象实例就是这个类帮我们创建的，它里面有一个静态方法GetProduct(string productType)，我们通过传入产品类型(productType)来得到我们想要的产品。

2、抽象产品角色(AbstractProduct)：该类是所有产品的父类。它可以是接口或者抽象类。只有这样我们才能给工厂的GetProduct(string productType)方法定义返回值。

3、实体产品(ConcreteProductA，ConcreteProductB，ConcreteProductC):这些类是简单工厂最终要创建的目标，也是客户端最终想要的对象实例。

现在来假设一种场景，我们开发过程中，肯定会用到按钮，圆形按钮、正方形按钮、矩形按钮等等，在程序的很多地方我们都可能会复用这些按钮。我们可以通过一个简单工厂来帮助我们创建这些按钮。

简单工厂模式的类图

SimpleFactory是个工厂类，负责创建对象(具体的工厂)。Product是要创建产品的抽象类，负责定义统一的接口。ProductA和ProductB是具体的产品类型，是Product的实现。我们看一下简单工厂模式的优缺点。

简单工厂模式优点：

实现简单、结构清晰。抽象出一个专门的工厂类来负责某类工厂对象的创建。使用者可以不关注具体工厂对象的类名，只要传入相应的参数就能创建对应的工厂对象。简单工厂模式的缺点：

不易扩展，一旦新增产品类型，就得修改工厂的创建逻辑，不符合开闭原则。当产品类型较多的时候，工厂创建逻辑会过于复杂，不利于维护。简单工厂模式的应用场景：

产品具有明显的继承关系，并且产品的类型不多或有限。所有的产品具体有相同的方法和类似的属性，使用者不关心具体的类型，只希望传入合适的参数，然后返回合适的工厂对象。1.2 工厂方法模式

为了解决简单工厂存在的，新增产品类型，就修改工厂的创建逻辑的问题。提出了工厂方法模式。工厂方法模式定义了一个创建对象(产品对象)的接口，让子类(工厂类)来决定创建哪个类(产品类)的实例。它是一个类(工厂类)的实例化，延迟到其子类。

Product是要创建产品的抽象类，ProductA和ProductB是具体的产品类型。Factory是所有工厂的抽象类，负责定义统一的接口。ProductAFactory和ProductBFactory是具体的工厂类，分别负责产品ProductA和ProductB的创建。工厂方法类利用依赖倒置原则，高层模块不依赖于底层的模块，它们应该依赖于抽象，面向接口编程，从而解决了简单工厂模式违反软件设计的开闭原则的问题。工厂方法模式也有一些优缺点，接下来我们看一下。

工厂方法模式的优点：

解决了简单工厂模式违反开闭原则的问题，使程序扩展性增强。工厂方法模式的缺点：

对于由多种分类(存在不同的分类方式组合)的产品，或者具有二级分类的产品，工厂方法模式不适用。工厂方法模式的应用场景：

客户端不知道它所需要的对象的类。工厂类希望通过其子类来决定创建哪个具体类的对象。2，举例

一般主程序只关注业务逻辑(抽象类接口)，不关心具体的业务细节(抽象类接口的具体实现)。这些业务细节就可以放在创建对象的逻辑(工厂创建逻辑)中，主程序只要设置指定的参数，就能通过创建对象的逻辑获取相应对象(工厂对象)。

接下来会分别举例说明简单工厂模式、工厂方法模式的C语言实现。

2.1 简单工厂模式举例

#include

enum {

PRODUCTA = 1,

PRODUCTB,

PRODUCTC,

};

// define product interface

typedef struct Product {

void (*show)(struct Product*);

} Product;

// define specific productA class

typedef struct ProductA {

Product product;

} ProductA;

// define productA show function

void ProductA_show(Product* product) {

printf("This is ProductA\n");

}

// define specific productB class

typedef struct ProductB {

Product product;

} ProductB;

// define productB show function

void ProductB_show(Product* product) {

printf("This is ProductB\n");

}

// define factory class

typedef struct Factory {

Product* (*create_product)(int);

} Factory;

// define factory create product logic

Product* factory_create_product(int type) {

Product* product = NULL;

switch (type) {

case 1:

product = (Product*)malloc(sizeof(ProductA));

product->show = ProductA_show;

break;

case 2:

product = (Product*)malloc(sizeof(ProductB));

product->show = ProductB_show;

break;

default:

printf("Invalid product type\n");

break;

}

return product;

}

int main() {

// implement factory instance

Factory simple_factory = { factory_create_product };

// use factory instance to create specific productA

Product* productA = simple_factory.create_product(PRODUCTA);

productA->show(productA);

free(productA);

// use factory instance to create specific productB

Product* productB = simple_factory.create_product(PRODUCTB);

productB->show(productB);

free(productB);

// use factory instance to create specific productC

Product* productC = simple_factory.create_product(PRODUCTC);

if (productC != NULL) {

free(productC);

}

return 0;

}

在这个例子中，定义了一个产品接口(Product)和两个具体产品类(ProductA 和 ProductB)，这两个具体的产品类都实现了产品接口。此外，还定义了一个工厂类(Factory)，它有一个 create_product 方法，通过该方法可以根据传入的参数创建不同类型的产品对象。

在 main 函数中，使用工厂类实例化了一个工厂对象，然后用这个工厂对象创建了具体产品对象ProductA 和ProductB，并调用它们的 show 方法打印出相应的信息。当传入一个无效的参数时，工厂类会打印出错误信息。

2.2 工厂方法模式举例

#include

// define product interface

typedef struct Product {

void (*show)(struct Product*);

} Product;

// define specific productA class

typedef struct ProductA {

Product product;

} ProductA;

// define productA show function

void ProductA_show(Product* product) {

printf("This is ProductA\n");

}

// define specific productB class

typedef struct ProductB {

Product product;

} ProductB;

// define productB show function

void ProductB_show(Product* product) {

printf("This is ProductB\n");

}

// define factory interface

typedef struct Factory {

Product* (*create_product)(struct Factory*);

} Factory;

// define specific factoryA class

typedef struct FactoryA {

Factory factory;

} FactoryA;

// inplement factoryA create_product function

Product* factoryA_create_product(Factory* factory) {

Product* product = (Product*)malloc(sizeof(Product));

product->show = ProductA_show;

return product;

}

// define specific factoryB class

typedef struct FactoryB {

Factory factory;

} FactoryB;

// inplement factoryB create_product function

Product* factoryB_create_product(Factory* factory) {

Product* product = (Product*)malloc(sizeof(Product));

product->show = ProductB_show;

return product;

}

int main() {

// create specific factoryA instance

FactoryA FactoryA;

FactoryA.factory.create_product = factoryA_create_product;

// create specific factoryB instance

FactoryB FactoryB;

FactoryB.factory.create_product = factoryB_create_product;

// use specific factory instance create specific product

Product* productA = FactoryA.factory.create_product(&FactoryA.factory);

productA->show(productA);

free(productA);

// use specific factory instance create specific product

Product* productB = FactoryB.factory.create_product(&FactoryB.factory);

productB->show(productB);

free(productB);

return 0;

}

在这个例子中，定义了一个产品接口(Product)和两个具体产品类(ProductA 和 ProductB)，这两个具体的产品类都实现了产品接口。另外，还定义了一个工厂接口(Factory)和两个具体工厂类(FactoryA 和 FactoryB)，它们都实现了工厂接口。每个具体工厂类都有一个创建产品的方法，通过该方法可以创建相应的产品对象。

在 main 函数中，首先创建了具体工厂对象FactoryA 和 FactoryB，然后通过它们的create_product方法分别创建了具体产品对象ProductA 和ProductB。最后，使用 free 函数释放了创建的产品对象。