异常教程

工厂模式（一文讲透）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战(已更新的所有项目都能学习) / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新开坑项目:《Spring AI 项目实战》 正在持续爆肝中，基于 Spring AI + Spring Boot 3.x + JDK 21...， 点击查看 ;
  • 《从零手撸：仿小红书（微服务架构）》 已完结，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

什么是工厂模式？

在软件开发领域，工厂模式（Factory Pattern）如同现代化工厂中的自动化生产线，它通过标准化的生产流程，将复杂对象的创建过程封装起来。这种设计模式允许开发者通过统一的接口获取不同类型的对象，而无需直接操作具体的创建细节。对于编程新手来说，这就像走进一家汽车4S店，只需说明需要的车型和配置，就能获得一辆完整的车辆，而无需了解发动机装配或电路焊接的具体过程。

该模式的核心价值在于解耦对象创建与使用场景，这使得系统在面对需求变化时展现出强大的适应性。例如电商平台需要新增支付方式时，只需扩展工厂类而无需修改现有代码，这正是工厂模式在软件工程中的典型应用价值。

工厂模式的核心思想

标准化生产流程

工厂模式通过定义一个抽象工厂接口，为不同产品提供统一的创建入口。就像汽车制造中的总装车间，每个生产环节都遵循标准化流程：

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

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

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

智能化生产控制

工厂类通过逻辑判断决定创建何种产品，这个过程可以类比为汽车工厂的订单处理系统：

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

当客户端需要产品时，只需传递参数给工厂方法：

Product product = SimpleFactory.createProduct("A");
product.use(); // 输出 "Using Product A"

这种设计将对象创建逻辑与业务逻辑分离，符合"高内聚，低耦合"的软件设计原则。

工厂模式的适用场景

动态产品类型需求

当系统需要根据运行时条件创建不同对象时，例如：

  • 多语言支持系统需要根据用户语言选择对应的资源管理器
  • 游戏引擎根据地形类型生成不同物理引擎组件
  • 数据库连接池根据配置选择MySQL/PostgreSQL驱动

隐藏复杂创建过程

当对象创建涉及复杂流程（如依赖注入、资源加载等）时，工厂模式能有效封装这些细节。例如：

public class ComplexProduct {
    private final ComponentA componentA;
    private final ComponentB componentB;

    // 私有构造函数防止直接实例化
    private ComplexProduct() {
        componentA = new ComponentA();
        componentB = new ComponentB();
        componentA.init();
        componentB.configure(componentA);
    }

    // 工厂方法负责完整创建流程
    public static ComplexProduct create() {
        ComplexProduct product = new ComplexProduct();
        product.postInit();
        return product;
    }
}

扩展性需求

当需要频繁添加新类型而不想修改现有代码时，工厂模式完美契合开闭原则（对扩展开放，对修改关闭）。例如电商平台添加新支付方式：

public class PaymentFactory {
    public static Payment createPayment(String type) {
        switch (type) {
            case "credit_card": return new CreditCardPayment();
            case "paypal": return new PayPalPayment();
            case "alipay": return new AlipayPayment();
            default: throw new IllegalArgumentException();
        }
    }
}

工厂模式的实现步骤

第一步：定义产品接口或基类

class Animal:
    def speak(self):
        pass

第二步：实现具体产品

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

第三步：创建工厂类

class AnimalFactory:
    @staticmethod
    def get_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError("Invalid animal type")

第四步：客户端使用工厂

factory = AnimalFactory()
animal = factory.get_animal("dog")
print(animal.speak())  # 输出 "Woof!"

通过这四个步骤，我们构建了一个完整的工厂模式实现，每个环节都保持了清晰的职责划分。

工厂模式的变体形式

简单工厂模式

这是最基础的实现形式，通过静态方法直接创建对象。优点是简单易用，但违背开闭原则，新增产品类型需要修改工厂代码。

工厂方法模式

通过引入抽象工厂接口，允许子类决定创建具体产品。这种设计在框架开发中非常常见：

// 抽象工厂接口
interface IFactory {
    Product create();
}

// 具体工厂A
class ConcreteFactoryA implements IFactory {
    public Product create() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements IFactory {
    public Product create() {
        return new ConcreteProductB();
    }
}

抽象工厂模式

当需要创建多个相关产品族时，可以使用该模式。例如配置管理系统需要同时创建数据库连接器和日志记录器：

// 抽象工厂
interface ConfigFactory {
    Database createDatabase();
    Logger createLogger();
}

// 开发环境工厂
class DevFactory implements ConfigFactory {
    public Database createDatabase() { return new SQLite(); }
    public Logger createLogger() { return new ConsoleLogger(); }
}

// 生产环境工厂
class ProdFactory implements ConfigFactory {
    public Database createDatabase() { return new MySQL(); }
    public Logger createLogger() { return new FileLogger(); }
}

不同变体模式的选择取决于具体需求，但核心思想始终是封装对象创建逻辑。

工厂模式的优缺点分析

核心优势

优势点具体表现
解耦对象创建与使用客户端无需了解对象构建细节
灵活扩展新增产品类型无需修改现有代码
统一管理创建逻辑集中管理，便于维护
适应复杂场景可处理依赖注入、多步骤初始化等复杂流程

局限性

局限点潜在问题
增加类的数量每个产品需要对应工厂类，可能导致类结构膨胀
过度设计风险简单场景可能引入不必要的复杂性
维护成本工厂逻辑复杂时需要额外维护
性能开销动态创建对象可能带来轻微性能损耗（通常可以忽略不计）

实际案例分析：图形绘制系统

需求背景

设计一个支持多种图形（圆形、矩形、三角形）绘制的系统，要求：

  1. 客户端通过统一接口请求图形对象
  2. 可扩展新的图形类型
  3. 隐藏具体实现细节

工厂模式解决方案

定义图形接口

public interface Shape {
    void draw();
}

实现具体图形

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

创建图形工厂

public class ShapeFactory {
    public static Shape getShape(String type) {
        if ("circle".equals(type)) {
            return new Circle();
        } else if ("rectangle".equals(type)) {
            return new Square();
        }
        throw new IllegalArgumentException("Invalid shape type");
    }
}

客户端使用

Shape circle = ShapeFactory.getShape("circle");
circle.draw(); // 输出 "Drawing a circle"

Shape rectangle = ShapeFactory.getShape("rectangle");
rectangle.draw(); // 输出 "Drawing a rectangle"

扩展新图形

当需要添加三角形时，只需：

  1. 创建新类Triangle
  2. 修改工厂方法逻辑
else if ("triangle".equals(type)) {
    return new Triangle();
}

这种设计完美展示了工厂模式在扩展性上的优势。

工厂模式与依赖注入的关系

虽然两者都涉及对象创建，但核心目标不同：

  • 工厂模式聚焦于对象实例化过程的封装
  • 依赖注入关注对象间依赖关系的管理

但两者常协同工作，例如：

// 使用工厂注入依赖
public class ReportService {
    private final Database database;

    public ReportService() {
        this.database = DatabaseFactory.createDatabase(); // 工厂创建依赖
    }
}

典型应用场景示例

1. 数据库连接管理

public class DatabaseFactory {
    public static Connection getConnection(String type) {
        if ("mysql".equals(type)) {
            return new MySQLConnection();
        } else if ("postgres".equals(type)) {
            return new PostgreSQLConnection();
        }
        throw new IllegalArgumentException();
    }
}

2. 游戏对象生成

public class GameObjectFactory {
    public static GameObject create(String type) {
        switch (type) {
            case "enemy": return new Enemy();
            case "obstacle": return new Obstacle();
            case "powerup": return new PowerUp();
            default: throw new IllegalArgumentException();
        }
    }
}

3. 网络请求适配器

public class RequestAdapterFactory {
    public static RequestAdapter getAdapter(String protocol) {
        if ("http".equals(protocol)) {
            return new HTTPAdapter();
        } else if ("https".equals(protocol)) {
            return new HTTPSAdapter();
        }
        throw new IllegalArgumentException();
    }
}

这些案例展示了工厂模式在不同领域的通用性。

总结与最佳实践

关键总结

  • 工厂模式通过封装对象创建逻辑，实现系统解耦
  • 根据需求选择简单工厂、工厂方法或抽象工厂模式
  • 新增产品类型时只需扩展而非修改现有代码
  • 注意避免过度设计，简单场景应保持简洁

开发建议

  1. 接口优先：所有产品应实现共同接口或继承基类
  2. 单一职责：每个工厂类专注生产特定类型产品
  3. 参数验证：对工厂方法参数进行有效性检查
  4. 组合工厂：复杂系统可采用分层工厂结构
  5. 文档记录：明确记录工厂支持的产品类型和使用规范

常见误区

  • 滥用工厂模式：简单对象创建无需引入工厂
  • 工厂方法过度复杂：应保持工厂逻辑简洁
  • 忽略扩展性：未考虑未来产品类型扩展的可能性
  • 忽略异常处理：未对无效参数进行适当处理

通过合理应用工厂模式，开发者可以构建出更灵活、易维护的系统架构。这种设计模式不仅是面向对象编程的重要思想，更是构建可扩展软件系统的基石之一。在实际开发中，建议结合具体场景需求选择合适的工厂变体，让代码结构既清晰又富有弹性。

最新发布

查看更多文章