java工厂模式代码

备案号:蜀ICP备2026035467号-3|网址:www.xservx.com

⚡ 工厂模式核心概念与设计哲学

工厂模式(Factory Pattern)属于创建型设计模式,其本质在于将对象的创建与使用解耦,通过定义一个用于创建对象的接口或类,让子类决定实例化哪一个类。该模式将实例化逻辑集中管理,从而提升系统灵活性、可维护性与可扩展性。

从设计原则视角审视,工厂模式深度践行了:

在Java工程实践中,工厂模式绝非仅用于“new对象”的语法糖,而是应对复杂业务变化的核心防御机制。当业务需求迭代频繁、产品线快速扩张(如多支付渠道、多消息中间件、多数据库适配),工厂模式可显著降低模块间耦合度,避免“牵一发而动全身”的重构风险。

需特别指出:工厂模式并非银弹。若系统仅含1-2个简单对象且无扩展需求,过度使用工厂将引入冗余抽象,增加代码复杂度与调试成本。实践中应遵循“需求驱动抽象”原则,而非机械套用模式。

⚙️ 工厂模式三大变体对比与适用场景

〈工厂模式家族谱系〉

  • 简单工厂(Simple Factory):非GOF23种模式之一,属工厂模式雏形;通过静态方法集中创建对象;适用:产品线稳定、无扩展需求的轻量场景
  • 工厂方法(Factory Method):GOF23核心模式;定义创建对象的接口,子类决定实例化哪个类;适用:产品族固定但需扩展新产品的场景(如新增支付渠道)
  • 抽象工厂(Abstract Factory):GOF23核心模式;提供创建一系列相关或依赖对象的接口;适用:多产品族协同场景(如UI主题:Windows/Linux/macOS)

〔工厂模式选择决策树〕

当面临对象创建需求时,按以下步骤决策:

  1. 产品是否仅1种?→ 是:直接new;否:进入下一步
  2. 未来是否可能新增产品?→ 否:简单工厂;是:进入下一步
  3. 产品间是否存在强关联(必须成套使用)?→ 是:抽象工厂;否:工厂方法

下文将逐层展开三种模式的代码实现与工程细节,所有示例均经JDK 17验证,可直接集成至Spring Boot项目。

⚡ 简单工厂模式:代码实现与反模式警示

简单工厂通过静态方法封装创建逻辑,典型结构如下:

【产品接口】

public interface PaymentProcessor {
    String processPayment(double amount);
    String getChannelName();
}

【具体产品】

public class WeChatPay implements PaymentProcessor {
    @Override
    public String processPayment(double amount) {
        return "微信支付:¥" + amount;
    }
    @Override
    public String getChannelName() {
        return "WeChatPay";
    }
}
public class Alipay implements PaymentProcessor {
    @Override
    public String processPayment(double amount) {
        return "支付宝支付:¥" + amount;
    }
    @Override
    public String getChannelName() {
        return "AliPay";
    }
}

【工厂类】

public class PaymentFactory {
    public static PaymentProcessor createPayment(String type) {
        switch (type.toLowerCase()) {
            case "wechat":
                return new WeChatPay();
            case "alipay":
                return new Alipay();
            default:
                throw new IllegalArgumentException("Unsupported payment type: " + type);
        }
    }
}

【客户端调用】

public class OrderService {
    public void checkout(String channel, double amount) {
        PaymentProcessor processor = PaymentFactory.createPayment(channel);
        System.out.println(processor.processPayment(amount));
    }
}
// 调用示例
OrderService service = new OrderService();
service.checkout("wechat", 199.99); // 输出:微信支付:¥199.99

⚠️ 简单工厂的三大致命缺陷

  1. 违反开闭原则:新增支付渠道需修改工厂switch语句,存在引入Bug风险
  2. 静态方法无法继承:限制工厂类扩展性,难以与Spring依赖注入集成
  3. 参数校验集中:所有校验逻辑集中于工厂,违反单一职责原则

因此,简单工厂仅适用于原型验证阶段或内部工具类。生产级系统推荐使用工厂方法模式替代。

⚙️ 工厂方法模式:企业级实践标准

工厂方法通过为每种产品定义专属工厂,实现创建逻辑的分布式管理:

【工厂接口】

public interface PaymentFactory {
    PaymentProcessor createProcessor();
}

【具体工厂】

public class WeChatPayFactory implements PaymentFactory {
    @Override
    public PaymentProcessor createProcessor() {
        return new WeChatPay();
    }
}
public class AlipayFactory implements PaymentFactory {
    @Override
    public PaymentProcessor createProcessor() {
        return new Alipay();
    }
}

【客户端调用】

// 通过依赖注入获取工厂(Spring方式)
@Service
public class OrderService {
    private final PaymentFactory factory;
    public OrderService(PaymentFactory factory) {
        this.factory = factory;
    }
    public void checkout(double amount) {
        PaymentProcessor processor = factory.createProcessor();
        System.out.println(processor.processPayment(amount));
    }
}
// 动态切换支付渠道
OrderService wechatOrder = new OrderService(new WeChatPayFactory());
OrderService aliOrder = new OrderService(new AlipayFactory());

【与Spring集成】

@Configuration
public class PaymentConfig {
    @Bean
    @Qualifier("wechat")
    public PaymentFactory wechatFactory() {
        return new WeChatPayFactory();
    }
    @Bean
    @Qualifier("alipay")
    public PaymentFactory alipayFactory() {
        return new AlipayFactory();
    }
}
@Service
public class OrderService {
    @Autowired
    @Qualifier("wechat")
    private PaymentFactory factory;
}

工厂方法模式的核心优势在于:新增支付渠道仅需新增产品类与工厂类,无需修改现有代码。此特性使系统具备“热插拔”能力,完美支持插件化架构。

〔抽象工厂模式〕:多产品族协同场景

当业务涉及多个产品族(如:Windows/Linux/macOS桌面主题,每个主题含按钮/文本框/菜单等组件),抽象工厂确保产品族内组件的兼容性:

【产品族接口】

public interface Button {
    void render();
}
public interface TextField {
    void display();
}

【具体产品】

public class WindowsButton implements Button {
    public void render() { System.out.println("Windows按钮"); }
}
public class LinuxButton implements Button {
    public void render() { System.out.println("Linux按钮"); }
}
public class WindowsTextField implements TextField {
    public void display() { System.out.println("Windows文本框"); }
}
public class LinuxTextField implements TextField {
    public void display() { System.out.println("Linux文本框"); }
}

【抽象工厂】

public interface GUIFactory {
    Button createButton();
    TextField createTextField();
}

【具体工厂】

public class WindowsFactory implements GUIFactory {
    public Button createButton() { return new WindowsButton(); }
    public TextField createTextField() { return new WindowsTextField(); }
}
public class LinuxFactory implements GUIFactory {
    public Button createButton() { return new LinuxButton(); }
    public TextField createTextField() { return new LinuxTextField(); }
}

【客户端使用】

public class Application {
    private final Button button;
    private final TextField field;
    public Application(GUIFactory factory) {
        this.button = factory.createButton();
        this.field = factory.createTextField();
    }
    public void run() {
        button.render();
        field.display();
    }
}
// 根据操作系统动态选择工厂
GUIFactory factory = isWindows() ? new WindowsFactory() : new LinuxFactory();
Application app = new Application(factory);
app.run();

💡 抽象工厂 vs 工厂方法关键差异

  • 工厂方法:一个工厂生产一种产品(单产品族)
  • 抽象工厂:一个工厂生产多种产品(多产品族)
  • 抽象工厂的工厂接口需定义多个创建方法

【电商订单系统】工厂模式实战案例

以电商订单处理为例,展示工厂模式在真实业务中的落地价值:

【订单状态机设计】

public interface OrderState {
    void next(OrderContext context);
    void prev(OrderContext context);
    String getStatus();
}

【具体状态】

public class PendingState implements OrderState {
    public void next(OrderContext context) {
        context.setState(new PaidState());
    }
    public String getStatus() { return "待支付"; }
}
public class PaidState implements OrderState {
    public void next(OrderContext context) {
        context.setState(new ShippedState());
    }
    public void prev(OrderContext context) {
        context.setState(new PendingState());
    }
    public String getStatus() { return "已支付"; }
}

【状态工厂】

public class OrderStateFactory {
    private static final Map states = new HashMap<>();
    static {
        states.put("pending", new PendingState());
        states.put("paid", new PaidState());
        states.put("shipped", new ShippedState());
        states.put("delivered", new DeliveredState());
    }
    public static OrderState getState(String status) {
        return states.get(status.toLowerCase());
    }
}

【订单上下文】

public class OrderContext {
    private OrderState state;
    public OrderContext(String initialStatus) {
        this.state = OrderStateFactory.getState(initialStatus);
    }
    public void setState(OrderState state) { this.state = state; }
    public void next() { state.next(this); }
    public void prev() { state.prev(this); }
    public String getStatus() { return state.getStatus(); }
}

【实际业务流程】

// 订单创建时初始状态为待支付
OrderContext order = new OrderContext("pending");
// 用户支付后状态流转
order.next(); // → 已支付
System.out.println(order.getStatus()); // 输出:已支付
// 用户申请退款
order.prev(); // → 待支付
order.next(); // → 已支付(重新支付后)
order.next(); // → 已发货

通过工厂模式管理订单状态,系统可轻松扩展新状态(如“售后中”、“已取消”),且各状态逻辑完全解耦,符合单一职责原则。

⚠️ 工厂模式常见误区与反模式

〔误区1:过度设计陷阱〕

某团队将简单服务类也套用工厂模式:

// 反例:为UserService添加工厂
public interface UserServiceFactory {
    UserService create();
}
// 实际调用:new UserServiceFactoryImpl().create().findAll();

问题:UserService无复杂创建逻辑,工厂模式引入冗余抽象,增加维护成本

〔误区2:工厂类膨胀问题〕

当产品数量达20+时,工厂类数量激增,可采用:
→ 注册表模式:用Map注册工厂实例
→ 反射+配置:通过配置文件动态加载工厂类

〔误区3:忽略线程安全〕

单例工厂在并发场景下可能创建重复对象:

// 危险实现
public class SingletonFactory {
    private static PaymentProcessor processor;
    public static PaymentProcessor getInstance() {
        if (processor == null) processor = new WeChatPay();
        return processor;
    }
}

正确方案:使用双重检查锁定或静态内部类

〔误区4:违反迪米特法则〕

客户端直接依赖工厂类而非接口:

// 反例:OrderService直接依赖WeChatPayFactory
public class OrderService {
    private final WeChatPayFactory factory;
}

应通过接口依赖(PaymentFactory),实现解耦

🚀 工厂模式性能优化与工程实践

〔缓存策略优化〕

对创建成本高的对象(如数据库连接池),在工厂中加入缓存:

public class ConnectionFactory {
    private static final Map pool = new ConcurrentHashMap<>();
    public static Connection getConnection(String dbType) {
        return pool.computeIfAbsent(dbType, k -> createConnection(k));
    }
    private static Connection createConnection(String dbType) {
        // 创建连接逻辑(如HikariCP初始化)
    }
}

〔Spring工厂Bean集成〕

@Component
public class PaymentFactoryBean implements FactoryBean {
    private final String channel;
    public PaymentFactoryBean(String channel) {
        this.channel = channel;
    }
    @Override
    public PaymentProcessor getObject() {
        return switch (channel) {
            case "wechat" -> new WeChatPay();
            case "alipay" -> new Alipay();
            default -> throw new IllegalArgumentException();
        };
    }
    @Override
    public Class getObjectType() {
        return PaymentProcessor.class;
    }
}

〔测试友好性优化〕

通过Mock工厂解耦单元测试:

@Test
void testCheckout() {
    PaymentFactory mockFactory = Mockito.mock(PaymentFactory.class);
    PaymentProcessor mockProcessor = Mockito.mock(PaymentProcessor.class);
    when(mockFactory.createProcessor()).thenReturn(mockProcessor);
    when(mockProcessor.processPayment(100.0)).thenReturn("Mocked payment");
    OrderService service = new OrderService(mockFactory);
    assertEquals("Mocked payment", service.checkout(100.0));
}

✅ 工程落地黄金准则

  1. 优先使用Spring依赖注入替代手动工厂
  2. 工厂类应保持无状态(避免成员变量)
  3. 创建逻辑复杂时,拆分到Builder模式
  4. 日志记录关键创建事件(便于追踪问题)

〔工厂模式学习路径图〕

  1. 掌握基本工厂模式实现(Java 8+语法)
  2. 理解SOLID原则在工厂模式中的体现
  3. 实战电商/支付/日志系统案例
  4. 集成Spring IoC容器实现企业级应用
  5. 探索工厂模式与响应式编程结合(Project Reactor)