引言

设计模式是软件工程中用于解决常见问题的经典解决方案模板。在系统架构设计中，工厂模式（Factory Pattern）作为创建型模式的代表，主要用于封装对象的创建过程，降低代码耦合度，并提升系统的可扩展性。本文将深入解析工厂模式的源码实现，探讨其核心思想、类型及实际应用场景。

工厂模式概述

工厂模式的核心思想是将对象的实例化过程抽象出来，交由一个专门的工厂类负责。这样做的好处是客户端无需关心具体对象的创建细节，只需通过工厂接口获取所需对象。工厂模式主要分为三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式

简单工厂模式通过一个工厂类，根据传入的参数决定创建哪一种产品类的实例。

源码示例：
`java
// 产品接口
interface Product {
void use();
}

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

// 具体产品B
class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("使用产品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();
}
}
`

优点： 客户端与具体产品解耦。
缺点： 违反开闭原则，新增产品时需要修改工厂类。

工厂方法模式

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

源码示例：
`java
// 产品接口
interface Product {
void use();
}

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

// 具体产品B
class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("使用产品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();
}
}
`

优点： 符合开闭原则，新增产品只需增加对应的工厂类。
缺点： 类的数量增多，系统复杂度增加。

抽象工厂模式

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

源码示例：
`java
// 产品族A接口
interface AbstractProductA {
void useA();
}

// 产品族B接口
interface AbstractProductB {
void useB();
}

// 具体产品A1
class ProductA1 implements AbstractProductA {
@Override
public void useA() {
System.out.println("使用产品A1");
}
}

// 具体产品A2
class ProductA2 implements AbstractProductA {
@Override
public void useA() {
System.out.println("使用产品A2");
}
}

// 具体产品B1
class ProductB1 implements AbstractProductB {
@Override
public void useB() {
System.out.println("使用产品B1");
}
}

// 具体产品B2
class ProductB2 implements AbstractProductB {
@Override
public void useB() {
System.out.println("使用产品B2");
}
}

// 抽象工厂接口
interface AbstractFactory {
AbstractProductA createProductA();
AbstractProductB createProductB();
}

// 具体工厂1，生产产品族A1和B1
class ConcreteFactory1 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ProductA1();
}

@Override
public AbstractProductB createProductB() {
return new ProductB1();
}
}

// 具体工厂2，生产产品族A2和B2
class ConcreteFactory2 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ProductA2();
}

@Override
public AbstractProductB createProductB() {
return new ProductB2();
}
}

// 客户端代码
public class Client {
public static void main(String[] args) {
AbstractFactory factory = new ConcreteFactory1();
AbstractProductA productA = factory.createProductA();
AbstractProductB productB = factory.createProductB();
productA.useA();
productB.useB();
}
}
`

优点： 保证产品族的一致性，便于切换产品系列。
缺点： 扩展新产品族困难，违反开闭原则。

工厂模式的应用场景

1. 对象创建复杂： 当对象的创建过程涉及多个步骤或依赖较多时，使用工厂模式封装创建逻辑。
2. 系统需要高扩展性： 工厂方法模式支持新增产品类型而不修改现有代码。
3. 产品族需求： 抽象工厂模式适用于需要创建一系列相关产品的场景，如不同主题的UI组件。
4. 解耦客户端与具体产品： 客户端只需依赖抽象接口，降低耦合度。

##

工厂模式通过封装对象的创建过程，提升了代码的灵活性和可维护性。简单工厂模式适用于产品类型较少的场景；工厂方法模式通过多态性支持开闭原则；抽象工厂模式则专注于产品族的创建。在实际系统架构设计中，根据具体需求选择合适的工厂模式变体，能够有效提升代码质量与系统可扩展性。掌握工厂模式的源码实现，是每位架构师和开发者的必备技能。