工厂模式

工厂模式

lx 4 2025-08-19

工厂模式详解

工厂设计模式(Factory Design Pattern)是创建型设计模式中最常用的模式之一，它提供了一种创建对象的最佳方式，而无需向客户端暴露创建逻辑。

工厂模式的核心思想

工厂模式的核心思想是将对象的创建与使用分离，客户端不需要知道对象的具体创建过程，只需要通过工厂获取所需的对象。

工厂模式的三种形式

工厂模式主要有三种形式：

1. 简单工厂模式(Simple Factory)

简单工厂模式又称为静态工厂方法模式，它定义一个工厂类，根据传入的参数不同返回不同类的实例。

结构：

  • 工厂类(Factory)：负责创建所有产品
  • 抽象产品类(Product)：定义产品的接口
  • 具体产品类(ConcreteProduct)：实现抽象产品类的接口

示例代码：

// 抽象产品
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}

// 简单工厂
class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端使用
public class Client {
    public static void main(String[] args) {
        Product product = SimpleFactory.createProduct("A");
        product.use();
    }
}

优点：

  • 客户端与具体产品解耦
  • 客户端不需要知道具体产品的类名

缺点：

  • 工厂类集中了所有产品的创建逻辑，职责过重
  • 增加新产品需要修改工厂类，违反开闭原则

2. 工厂方法模式(Factory Method)

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类。

结构：

  • 抽象工厂(Factory)：声明工厂方法
  • 具体工厂(ConcreteFactory)：实现工厂方法，返回具体产品实例
  • 抽象产品(Product)：定义产品接口
  • 具体产品(ConcreteProduct)：实现产品接口

示例代码：

// 抽象产品
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}

// 抽象工厂
interface Factory {
    Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端使用
public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactoryA();
        Product product = factory.createProduct();
        product.use();
    }
}

优点：

  • 完全符合开闭原则，增加新产品只需增加新的工厂类
  • 客户端不需要知道具体产品的类名
  • 多态性设计，工厂方法可以返回产品的子类

缺点：

  • 每增加一个产品就要增加一个具体工厂类，增加了系统的复杂度

3. 抽象工厂模式(Abstract Factory)

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

结构：

  • 抽象工厂(AbstractFactory)：声明一组创建产品的方法
  • 具体工厂(ConcreteFactory)：实现抽象工厂的方法，创建具体产品
  • 抽象产品(AbstractProduct)：定义产品接口
  • 具体产品(ConcreteProduct)：实现产品接口

示例代码：

// 抽象产品A
interface ProductA {
    void use();
}

// 具体产品A1
class ConcreteProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using Product A1");
    }
}

// 具体产品A2
class ConcreteProductA2 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using Product A2");
    }
}

// 抽象产品B
interface ProductB {
    void operate();
}

// 具体产品B1
class ConcreteProductB1 implements ProductB {
    @Override
    public void operate() {
        System.out.println("Operating Product B1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void operate() {
        System.out.println("Operating Product B2");
    }
}

// 抽象工厂
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端使用
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();
        ProductA productA = factory.createProductA();
        ProductB productB = factory.createProductB();
        productA.use();
        productB.operate();
    }
}

优点：

  • 保证客户端始终只使用同一个产品族中的对象
  • 产品族内的约束对客户端透明
  • 符合开闭原则（增加产品族容易）

缺点：

  • 难以支持新种类的产品（需要修改抽象工厂接口）
  • 系统复杂度高

工厂模式的应用场景

  1. 简单工厂模式：

    • 工厂类负责创建的对象比较少
    • 客户端只需要传入工厂类的参数，不需要关心对象的创建逻辑

  2. 工厂方法模式：

    • 客户端不知道它所需要的对象的类
    • 类的实例化延迟到子类
    • 一个类通过其子类来指定创建哪个对象

  3. 抽象工厂模式：

    • 系统需要独立于产品的创建、组合和表示
    • 系统需要配置多个产品族中的一个来使用
    • 需要提供一个产品类库，且只想显示它们的接口而不是实现

工厂模式在JDK中的应用

  1. java.util.Calendar 的 getInstance() 方法
  2. java.text.NumberFormat 的 getInstance() 方法
  3. java.nio.charset.Charset 的 forName() 方法
  4. java.sql.DriverManager#getConnection()

总结

工厂模式通过将对象的创建与使用分离，提高了系统的灵活性和可维护性。选择哪种工厂模式取决于具体的业务需求：

  • 简单工厂：适用于对象创建逻辑简单的情况
  • 工厂方法：适用于需要扩展性强、支持新产品的情况
  • 抽象工厂：适用于需要创建产品族、保证产品兼容性的情况
小卡拉