设计模式-工厂模式设计与详解

一、工厂模式概述

工厂模式（Factory Pattern）是一种常用的创建型设计模式，其核心目的是实现创建对象的接口和具体的实例化分离，通过建立一个工厂类，对实现了同一接口的一些类进行实例的创建，以增加系统的灵活性和可维护性。

当需要大量创建一个类的实例的时候，可以使用工厂模式，即从原生的使用类的构造去创建对象的形式迁移到基于工厂提供的方法去创建对象的形式。基于工厂模式的实例创建具有以下好处：

• 大批量创建对象的时候有统一的入口，易于代码维护；
• 当发生修改时，仅需修改工厂类的创建方法即可；
• 符合现实世界的模式，即由工厂来制作产品（对象）；

本文将通过类图及示例代码详细介绍工厂模式的三种形式：简单工厂模式、工厂方法模式 和 抽象工厂模式。

二、简单工厂模式

简单工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，让其子类决定实例化哪一个类。该模式将对象的创建集中管理，通过专门的工厂类来负责创建所有实例，这样可以避免在客户代码中重复创建对象，降低系统的耦合度，提高模块的可复用性。

1. 简单工厂模式类图

以下类图展示了简单工厂模式的结构：

在这个类图中，Client 不直接与具体产品类（ConcreteProductA 和 ConcreteProductB）交互，而是通过 Factory 类来进行。这样做的优点是客户端从具体产品的创建过程中解耦，提高了程序的扩展性和可维护性。

2. 简单工厂模式示例代码

下面的示例代码进一步阐释了简单工厂模式的应用：

• 抽象产品：定义了产品的接口，所有的产品都必须实现这个接口。

interface Product {
    void use();
}

• 具体产品：实现了产品接口的实体类，定义了具体产品的行为。

class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

• 简单工厂：一个工厂类，提供了一个创建对象的方法，客户端通过调用这个方法并传入参数来创建不同的产品实例。

class Factory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

• 调用简单工厂示例：客户端使用 Factory 类创建具体的产品实例。这种方式的主要优点是工厂类包含必要的逻辑判断，可以决定在运行时创建哪个产品的实例。由于使用了工厂类，客户端可以完全从具体产品的实现中解耦，只需要关心产品的接口。

public class Client {
    public static void main(String[] args) {
        Product product = Factory.createProduct("A");
        product.use();
    }
}

通过这种方式，简单工厂模式使得新增产品类时，只需要扩展工厂类而不需要修改现有的客户代码，从而增加了系统的灵活性。

也就是将"A"换成其他产品，如果产品类不存在，我们需要新增产品类，同时添加createProduct里type为新产品的情况，其实还是有点麻烦的，所有下面的工厂方法就是对此的改进。

三、工厂方法模式

工厂方法模式是一种创建型设计模式，它提供了一个创建对象的方法，但实际的工作将由子类完成，这样的设计模式可以让类的实例化推迟到其子类中进行。这种模式通过定义一个创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类，从而使代码管理更加简单，同时也扩展了系统的可能功能。

1. 工厂方法模式类图

下面的类图描述了工厂方法模式的结构：

在这个模式中，Creator 类定义了一个抽象的 factoryMethod()，该方法需要被子类实现以返回一个 Product 类的实例。这样，客户端代码只依赖于 Product 接口，而具体实例化哪个产品类由具体的 Creator 子类决定，这样提高了系统的灵活性和扩展性。

2. 工厂方法模式示例代码

以下示例代码进一步阐释了工厂方法模式的应用：

• 产品接口：定义了所有具体产品需要实现的接口。

interface Product {
    void use();
}

• 具体产品：实现了产品接口的具体类，这些类定义了具体产品的行为。

class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

• 抽象创建者：定义了抽象的工厂方法，由具体创建者来实现。

abstract class Creator {
    abstract Product factoryMethod();
}

• 具体创建者：继承抽象创建者，实现了工厂方法，决定实际生产的产品。

class ConcreteCreatorA extends Creator {
    @Override
    Product factoryMethod() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    @Override
    Product factoryMethod() {
        return new ConcreteProductB();
    }
}

• 客户端使用：客户端代码通过调用工厂方法来获取产品对象，而无需知道具体的产品类。

public class Client {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreatorA();
        Product product = creator.factoryMethod();
        product.use();
    }
}

通过这种方式，工厂方法模式使得添加新产品类时，只需添加一个具体的创建者而无需修改现有代码，符合开闭原则，提高了代码的可维护性和扩展性。

与简单工厂加个产品需要改一揽子的代码相比，工厂方法只需要创建一个新的创建者类，客户端调用时ConcreteCreatorA更换为新类名就可以。

四、抽象工厂模式

抽象工厂模式是创建型设计模式中的一种，它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。这种模式是工厂方法模式的一种扩展，它用于创建产品家族，而不仅仅是单一产品。通过这种方式，可以增强程序的灵活性和可维护性，同时也支持良好的封装性和扩展性。

1. 抽象工厂模式类图

以下类图清晰展示了抽象工厂模式的结构和组件之间的关系：

在这个模式中，AbstractFactory 是一个抽象类，定义了创建一系列产品的接口。每个具体工厂类（如 ConcreteFactory1 和 ConcreteFactory2）实现这个接口，生产具体的产品实例。客户端通过使用工厂接口，而不是直接实例化产品，从而使得具体的产品在客户端保持抽象状态。

2. 抽象工厂模式示例代码

以下示例代码详细说明了抽象工厂模式的实现：

• 产品接口：定义了产品的操作。

interface AbstractProductA {
    void use();
}

interface AbstractProductB {
    void use();
}

• 具体产品：实现产品接口的具体类。

class ConcreteProductA1 implements AbstractProductA {
    public void use() {
        System.out.println("Using ConcreteProductA1");
    }
}

class ConcreteProductA2 implements AbstractProductA {
    public void use() {
        System.out.println("Using ConcreteProductA2");
    }
}

class ConcreteProductB1 implements AbstractProductB {
    public void use() {
        System.out.println("Using ConcreteProductB1");
    }
}

class ConcreteProductB2 implements AbstractProductB {
    public void use() {
        System.out.println("Using ConcreteProductB2");
    }
}

• 抽象工厂：定义了创建一系列产品的方法。

abstract class AbstractFactory {
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}

• 具体工厂：实现抽象工厂，定义了生产具体产品的方式。

class ConcreteFactory1 extends AbstractFactory {
    @Override
    AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

class ConcreteFactory2 extends AbstractFactory {
    @Override
    AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    AbstractProductB createProductB() {


        return new ConcreteProductB2();
    }
}

• 客户端使用：客户端通过抽象工厂接口创建并使用产品。

public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();
        AbstractProductA productA = factory.createProductA();
        AbstractProductB productB = factory.createProductB();
        productA.use();
        productB.use();
    }
}

通过这种方式，抽象工厂模式允许系统在不具体指定产品的情况下创建一系列相关或依赖的对象，支持配置多个工厂，每个工厂创建不同的产品实例，从而增强系统的灵活性和扩展性。

这也是工厂方法模式的升级，虽然在开闭原则上做出了让步，但是为更强的灵活和扩展创造了条件。

五、三种工厂模式异同

首先，我们来看三种工厂模式的定义：

• 简单工厂模式：最简单的工厂模式，适合产品种类较少且不经常变化的情况。工厂类集中处理所有产品的创建逻辑，这简化了代码但降低了系统的扩展性。

• 工厂方法模式：允许多个创建者子类来实现具体的产品创建。这种分散的创建过程提高了系统的灵活性，并且增强了代码的可扩展性。

• 抽象工厂模式：提供一个创建一系列相关或互依赖对象的接口，而无需指定它们具体的类。适用于处理多个系列产品的情况，每个具体工厂都能生产一个完整的产品家族。

接着，我们用一张表来总结三种工厂模式的特性差异：

通过上述表格，我们可以清晰地看到每种工厂模式的特点及其适用的场景。在不同的开发需求下，我们需要选择最合适的模式。

六、工厂模式的优势与应用场景

1. 工厂模式的优势

2. 工厂模式的应用场景

• 当系统中的产品有多于一个的产品族，而系统只消费其中某一产品族时。
• 当属于同一个产品族的一组产品被设计用于一起使用时，可以使用抽象工厂模式。
• 当系统需要被配置成一个具有多个不同行为的产品组成时，可以使用工厂模式确保其灵活性和可扩展性。

七、工厂模式总结

工厂模式是设计模式中非常关键的一类，主要用于解决对象创建过程中的复杂性，并帮助将对象的实例化过程与使用者分离，从而增加系统的整体封装性和灵活性。通过定义一个用于创建对象的接口，允许子类决定实例化哪一个类，工厂模式使一个类的实例化延迟到其子类。这种模式不仅帮助管理和维护大型软件系统中的对象创建问题，也使系统更加模块化，易于理解和扩展。总的来说，工厂模式在需要生成复杂对象时，提供了极大的便利和高效的管理与维护策略。