设计模式之工厂模式工厂模式是我们最常用的实例化对象模式了，平时我们创建对象都是通过new的方式来创建，但是这样会导致代码

~~本文已参与「新人创作礼」活动，一起开启掘金创作之路。~~

一、简介

工厂模式是我们最常用的实例化对象模式了，平时我们创建对象都是通过new的方式来创建，但是这样会导致代码耦合性较高，不易维护和扩展，有没有一种方式来帮助我们管理对象呢？当然有，它就是工厂模式。每次需要创建对象时不自己new了，而是通过工厂去获取，降低代码之间的耦合度。比如我们常用的spring框架，它就是通过工厂模式来管理对象的。

工厂模式属于创建型设计模式，一共分三种，分别是：简单工厂模式、工厂方法模式和抽象工厂模式。接下来我们分别讲解这三种工厂模式。

二、简单工厂模式

2.1 简介

定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。

简单来说，简单工厂模式有一个具体的工厂类，可以生成多个不同的产品。

2.2 优缺点

优点：

工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
客户端无需知道所创建具体产品的类名，只需知道参数即可。
也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点：

简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度、
系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
简单工厂模式使用了 static 工厂方法（只能说大部分，前面也说过，是通常使用static，不用创建工厂对象之间），造成工厂角色无法形成基于继承的等级结构。

2.3 应用场景

对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

2.4 模式结构

2.4.1 主要角色

简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
具体产品（ConcreteProduct）：是简单工厂模式的创建目标。

2.4.2 UML类图

2.5 代码实现

下面以运算方法为例来说明：

2.5.1 抽象产品和具体产品

/**
 * 抽象产品对象：
 */
public interface Operation {

    /**
     * 获取两个整数的计算结果
     * @param x
     * @param y
     * @return
     */
    int getResult(int x, int y);
}


/**
 * 具体工厂对象：加法
 */
public class AddOperation implements Operation{

    @Override
    public int getResult(int x, int y) {
        return x + y;
    }
}

/**
 * 具体工厂对象：减法
 */
public class SubOperation implements Operation{

    @Override
    public int getResult(int x, int y) {
        return x - y;
    }
}

2.5.2 简单工厂对象

public class SimpleFactory {

    /**
     * 工厂方法：使用了static修饰，使用时可以直接通过类调用，而不用创建一个工厂对象
     * @param operation 算术运算符，这里只支持加、减，也可以添加乘、除等运算
     * @return
     */
    public static Operation getOperation(String operation) {
        return switch (operation) {
            case "+" -> new AddOperation();
            case "-" -> new SubOperation();
            default -> null;
        };
    }
}

2.5.3 测试

/**
 * 简单工厂对象测试方法
 */
@Test
void getOperation() {
    int x = 10;
    int y = 4;
    String ope = "+";
    
    // 1、通过简单工厂获取对应的操作对象
    Operation operation = SimpleFactory.getOperation(ope);
    // 2、操作对象调用操作方法获取结果
    int addResult = operation.getResult(x, y);
    System.out.println(addResult);  // 14

    ope = "-";
    // 1、通过简单工厂获取对应的操作对象
    operation = SimpleFactory.getOperation(ope);
    // 2、操作对象调用操作方法获取结果
    int subResult = operation.getResult(x, y);
    System.out.println(subResult);  // 6
}

三、工厂方法模式

3.1 简介

工厂方法模式是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

3.2 优缺点

优点：

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

类的个数容易过多，增加复杂度
增加了系统的抽象性和理解难度
抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

3.3 应用场景

1）客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。

2）创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。

3）客户不关心创建产品的细节，只关心产品的品牌

3.4 模式结构

3.4.1 主要角色

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

3.4.2 UML类图

3.5 代码实现

3.5.1 抽象产品和具体产品

/**
 * 抽象产品对象：
 */
public interface Operation {

    /**
     * 获取两个整数的计算结果
     * @param x
     * @param y
     * @return
     */
    int getResult(int x, int y);
}


/**
 * 具体工厂对象：加法
 */
public class AddOperation implements Operation{

    @Override
    public int getResult(int x, int y) {
        return x + y;
    }
}

/**
 * 具体工厂对象：减法
 */
public class SubOperation implements Operation{

    @Override
    public int getResult(int x, int y) {
        return x - y;
    }
}

3.5.2 工厂方法和具体工厂

/**
 * 工厂方法：只做一件事，获取操作对象
 */
public interface FactoryMethod {

    Operation getOperation();
}

/**
 * 具体工厂对象：加法工厂对象
 */
public class AddFactory implements FactoryMethod{
    @Override
    public Operation getOperation() {
        return new AddOperation();
    }
}

/**
 * 具体工厂对象：减法工厂对象
 */
public class SubFactory implements FactoryMethod{
    @Override
    public Operation getOperation() {
        return new SubOperation();
    }
}

3.5.3 测试

@Test
void getOperation() {
    int x = 10;
    int y = 4;

    // 1、创建具体工厂方法对象
    FactoryMethod addFactory = new AddFactory();
    // 2、通过工厂方法对象获取操作对象
    Operation operation = addFactory.getOperation();
    // 3、操作对象获取操作结果
    int addResult = operation.getResult(x, y);
    System.out.println(addResult);

    // 1、创建具体工厂方法对象
    FactoryMethod subFactory = new SubFactory();
    // 2、通过工厂方法对象获取操作对象
    operation = subFactory.getOperation();
    // 3、操作对象获取操作结果
    int subResult = operation.getResult(x, y);
    System.out.println(subResult);
}

3.6 与简单工厂的联系和区别

可以看到，两者的抽象产品和具体产品完全一样，不同的是工厂实现部分，简单工厂是通过switch进行判断返回那个产品对象的，而工厂方法模式是在客户端指明使用哪个产品对象。
基于这两种获取产品的方式，若简单工厂模式需要添加乘除这两种产品时，需要去修改工厂类，而工厂方法模式者只需比简单工厂模式多创建一个乘/除的工厂方法，然后客户端指明其对象即可，不用修改原有代码，因此满足开闭原则。

注意：

当需要生成的产品不多且不会增加（即不需要再次扩展），一个具体工厂类就可以完成任务时，可删除抽象工厂类。这时工厂方法模式将退化到简单工厂模式。如常用的运算：加减乘除、幂、开方等就可直接使用简单工厂模式。

四、抽象工厂模式

4.1 简介

抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本：工厂方法模式只生产一个等级的产品（一类抽象产品），而抽象工厂模式可生产多个等级的产品（多类抽象产品）。

4.2 使用抽象工厂模式需要满足的条件

系统中有多个产品族**（多个抽象产品）**，每个具体工厂创建同一族（存在关联关系）但属于不同等级结构（不属于同一个抽象产品）的产品。
系统一次只可能消费其中某一族产品**（存在关联关系的不同抽象产品）**，即同族的产品一起使用。

4.3 优缺点

优点：

可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，只需增加一个新的具体工厂，不需要修改原代码，满足开闭原则。

缺点：

当产品族中需要增加一个新种类的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度

4.4 应用场景

1）的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。

2）有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。

3）提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

4.5 模式扩展

抽象工厂模式的扩展有一定的“开闭原则”倾斜性：

1）当增加一个新的产品族时只需增加一个新的具体工厂，不需要修改原代码，满足开闭原则

2）当产品族中需要增加一个新种类的产品时，则所有的工厂类都需要进行修改，不满足开闭原则

4.6 模式结构

4.6.1 主要角色

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。一个具体工厂就是一个产品族（都有该工厂生产）
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

4.6.2 UML类图

4.7 代码实现

4.7.1 抽象产品一及相关具体产品

/**
 * 抽象产品一：手机
 */
public interface Phone {

    /**
     * 使用的操作系统
     * @return
     */
    String useOS();
}

/**
 * 抽象产品一的具体产品一：华为手机
 */
public class HuaWeiPhone implements Phone{
    @Override
    public String useOS() {
        return "HarmonyOS";
    }
}

/**
 * 抽象产品一的具体产品二：小米手机
 */
public class XiaoMiPhone implements Phone{
    @Override
    public String useOS() {
        return "MUI";
    }
}

4.7.2 抽象产品二及相关具体产品

/**
 * 抽象产品二：电脑
 */
public interface Computer {

    String useCpu();
}

/**
 * 抽象产品二的具体产品一：华为电脑
 */
public class HuaWeiComputer implements Computer{
    @Override
    public String useCpu() {
        return "AMD";
    }
}

/**
 * 抽象产品二的具体产品二：小米电脑
 */
public class XiaoMiComputer implements Computer {
    @Override
    public String useCpu() {
        return "Intel";
    }
}

4.7.3 抽象工厂及相关具体工厂

/**
 * 抽象工厂
 */
public interface AbstartFactory {

    /**
     * 生产手机
     * @return
     */
    Phone producePhone();

    /**
     * 生产电脑
     * @return
     */
    Computer produceComputer();
}

/**
 * 具体工厂一：华为工厂
 */
public class HuaWeiFactory implements AbstartFactory{
    @Override
    public Phone producePhone() {
        return new HuaWeiPhone();
    }

    @Override
    public Computer produceComputer() {
        return new HuaWeiComputer();
    }
}

/**
 * 具体工厂二：小米工厂
 */
public class XiaoMiFactory implements AbstartFactory{
    @Override
    public Phone producePhone() {
        return new XiaoMiPhone();
    }

    @Override
    public Computer produceComputer() {
        return new XiaoMiComputer();
    }
}

4.7.4 测试

@Test
void produce() {
    // 1、创建具体工厂对象
    AbstartFactory huaweiFactory = new HuaWeiFactory();
    // 2、通过具体工厂对象获取具体产品
    Phone huaweiPhone = huaweiFactory.producePhone();
    Computer huaweiComputer = huaweiFactory.produceComputer();
    // 3、获取产品信息
    String huaweiOS = huaweiPhone.useOS();
    String huaweiCpu = huaweiComputer.useCpu();
    System.out.println(huaweiOS);
    System.out.println(huaweiCpu);

    // 1、创建具体工厂对象
    AbstartFactory xiaomiFactory = new XiaoMiFactory();
    // 2、通过具体工厂对象获取具体产品
    Phone xiaomiPhone = xiaomiFactory.producePhone();
    Computer xiaomiComputer = xiaomiFactory.produceComputer();
    // 3、获取产品信息
    String xiaomiOS = xiaomiPhone.useOS();
    String xiaomiCpu = xiaomiComputer.useCpu();
    System.out.println(xiaomiOS);
    System.out.println(xiaomiCpu);
}

4.8 与工厂方法模式的联系和区别

工厂方法模式一个工作只做一件事情，而抽象工厂模式一次可以做两件甚至多件事（上例中即生产手机也生产电脑）
当系统中只存在同一等级（同一件事）的产品时，抽象工厂模式将退化到工厂方法模式，如上例中，只存在手机产品，而没有电脑产品时，其UML类图将与工厂方法模式的UML类图一致。