深入Java工厂模式：简单工厂、工厂方法与抽象工厂实战指南

简单工厂模式（Simple Factory Pattern）

核心思想

简单工厂模式通过一个工厂类集中管理对象的创建过程，将客户端与具体实现解耦。其核心在于使用静态方法根据输入参数决定创建哪种产品类的实例，典型特征是通过if-else或switch-case进行类型判断。

public class PizzaFactory {

public static Pizza createPizza(String type) {

return switch (type.toLowerCase()) {

case "cheese" -> new CheesePizza();

case "pepperoni" -> new PepperoniPizza();

case "veggie" -> new VeggiePizza();

default -> throw new IllegalArgumentException("Invalid pizza type");

};

}

}

实现要素

产品接口：定义产品的通用行为

具体产品类：实现接口的具体类型

工厂类：包含静态创建方法的中央枢纽

典型应用场景

对象创建逻辑简单且不频繁变化

产品种类有限的配置化系统

快速原型开发阶段

代码演进示例

// 基础版本

public 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 enum ProductType {

TYPE_A, TYPE_B, TYPE_C

}

public class EnhancedFactory {

public static Product createProduct(ProductType type) {

return switch (type) {

case TYPE_A -> new ProductA();

case TYPE_B -> new ProductB();

case TYPE_C -> new ProductC();

};

}

}

优缺点分析

优势：

客户端与具体类解耦

集中管理对象创建逻辑

快速实现产品配置切换

局限：

违反开闭原则（新增类型需修改工厂）

静态方法难以扩展和继承

类型判断逻辑可能变得复杂

工厂方法模式（Factory Method Pattern）

设计哲学

工厂方法模式通过抽象创建过程，将具体产品的实例化延迟到子类实现。这种模式建立了平行的类层次结构：一个用于产品，一个用于对应的创建者。

public abstract class PizzaStore {

public Pizza orderPizza(String type) {

Pizza pizza = createPizza(type);

pizza.prepare();

pizza.bake();

pizza.cut();

return pizza;

}

protected abstract Pizza createPizza(String type);

}

public class NYPizzaStore extends PizzaStore {

@Override

protected Pizza createPizza(String type) {

return switch (type) {

case "cheese" -> new NYStyleCheesePizza();

case "pepperoni" -> new NYStylePepperoniPizza();

default -> throw new IllegalArgumentException();

};

}

}

模式结构

抽象创建者：声明工厂方法

具体创建者：实现工厂方法

产品接口：定义产品规范

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

应用场景

需要创建可扩展的产品家族

框架需要为不同环境提供组件

需要替换整套产品实现

对象创建需要复杂初始化过程

模式变体

// 参数化工厂方法

public abstract class Creator {

public Product create(ProductType type) {

Product product = createProduct(type);

product.initialize();

return product;

}

protected abstract Product createProduct(ProductType type);

}

// 带缺省实现的工厂方法

public abstract class TransportCompany {

public Transport createTransport(TransportType type) {

Transport t = create(type);

t.setMaintenancePlan(new StandardPlan());

return t;

}

protected Transport create(TransportType type) {

// 默认实现可以抛出异常或返回null

throw new UnsupportedOperationException();

}

}

实际应用案例

Spring框架中的BeanFactory：

public interface BeanFactory {

Object getBean(String name) throws BeansException;

T getBean(String name, Class requiredType) throws BeansException;

}

public class XmlBeanFactory extends DefaultListableBeanFactory {

private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

public XmlBeanFactory(Resource resource) throws BeansException {

this(resource, null);

}

public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {

super(parentBeanFactory);

this.reader.loadBeanDefinitions(resource);

}

}

抽象工厂模式（Abstract Factory Pattern）

模式本质

抽象工厂模式通过接口创建相关或依赖对象的家族，而不需要明确指定具体类。它强调产品之间的兼容性和系统级别的配置。

public interface GUIFactory {

Button createButton();

Menu createMenu();

Dialog createDialog();

}

public class WindowsFactory implements GUIFactory {

@Override public Button createButton() { return new WinButton(); }

@Override public Menu createMenu() { return new WinMenu(); }

@Override public Dialog createDialog() { return new WinDialog(); }

}

public class MacOSFactory implements GUIFactory {

@Override public Button createButton() { return new MacButton(); }

@Override public Menu createMenu() { return new MacMenu(); }

@Override public Dialog createDialog() { return new MacDialog(); }

}

关键特征

创建多个相关产品对象

保证产品之间的兼容性

系统需要多个产品系列配置

产品对象的创建需要解耦

模式实现进阶

// 支持动态切换的工厂

public class Environment {

private GUIFactory factory;

public Environment(GUIFactory factory) {

this.factory = factory;

}

public void renderUI() {

Button btn = factory.createButton();

Menu menu = factory.createMenu();

btn.render();

menu.show();

}

}

// 带缓存机制的抽象工厂

public abstract class CachedFactory implements ResourceFactory {

private Map cache = new ConcurrentHashMap<>();

public Resource getResource(String key) {

return cache.computeIfAbsent(key, k -> createResource(k));

}

protected abstract Resource createResource(String key);

}

复杂场景应用

数据库访问抽象工厂：

public interface DBFactory {

Connection createConnection();

Statement createStatement();

ResultSet createResultSet();

}

public class MySQLFactory implements DBFactory {

@Override

public Connection createConnection() {

return new MySQLConnection();

}

@Override

public Statement createStatement() {

return new MySQLStatement();

}

@Override

public ResultSet createResultSet() {

return new MySQLResultSet();

}

}

public class OracleFactory implements DBFactory {

// 类似实现Oracle相关对象

}

模式对比与选型策略

决策矩阵

维度

简单工厂

工厂方法

抽象工厂

产品维度

单个产品

单个产品

产品族

扩展性

需修改工厂类

新增子类

新增接口实现类

系统复杂度

低

中

高

客户端依赖

依赖具体工厂

依赖抽象工厂

依赖抽象工厂

典型应用场景

配置驱动对象创建

框架扩展点

跨平台UI/数据库访问

性能考量

对象缓存：使用享元模式优化高频创建的对象

延迟加载：对资源密集型产品实现按需创建

线程安全：多线程环境下的双重检查锁定

对象池技术：结合对象池管理昂贵资源

public class ThreadSafeFactory {

private volatile Product instance;

public Product getInstance() {

if (instance == null) {

synchronized (this) {

if (instance == null) {

instance = createProduct();

}

}

}

return instance;

}

protected abstract Product createProduct();

}

工程实践建议

模式组合应用

工厂+策略模式：通过工厂创建不同的策略实现

工厂+建造者模式：处理复杂对象的创建过程

工厂+原型模式：快速克隆预配置对象

工厂+依赖注入：实现松耦合的系统架构

测试策略

工厂方法测试模板：

public abstract class FactoryTestBase {

protected abstract Product createProduct();

@Test

public void testProductInterface() {

Product p = createProduct();

assertNotNull(p);

assertTrue(p instanceof Product);

}

}

public class ConcreteFactoryTest extends FactoryTestBase {

@Override

protected Product createProduct() {

return new ConcreteFactory().createProduct();

}

}

使用Mock对象测试工厂：

public class ServiceTest {

@Test

public void testWithMockFactory() {

Product mockProduct = mock(Product.class);

when(mockProduct.operation()).thenReturn("test");

Factory mockFactory = mock(Factory.class);

when(mockFactory.createProduct()).thenReturn(mockProduct);

Service service = new Service(mockFactory);

assertEquals("test", service.executeOperation());

}

}

典型反模式

万能工厂：试图用单个工厂创建所有类型对象

过度抽象：为简单创建逻辑引入不必要的层次

循环依赖：工厂与产品之间的双向依赖

忽略生命周期：未考虑对象销毁等管理逻辑

现代演进方向

函数式工厂：

public class FunctionalFactory {

private final Map> registry = new HashMap<>();

public void register(String type, Supplier supplier) {

registry.put(type, supplier);

}

public Product create(String type) {

Supplier supplier = registry.get(type);

if (supplier == null) {

throw new IllegalArgumentException("No product registered for " + type);

}

return supplier.get();

}

}

基于注解的自动注册：

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

public @interface ProductRegistration {

String value();

}

public class AutoDetectFactory {

private final Map> mappings = new HashMap<>();

public void scanPackage(String packageName) {

Reflections reflections = new Reflections(packageName);

Set> annotated = reflections.getTypesAnnotatedWith(ProductRegistration.class);

for (Class clazz : annotated) {

ProductRegistration annotation = clazz.getAnnotation(ProductRegistration.class);

mappings.put(annotation.value(), (Class) clazz);

}

}

public Product create(String type) throws Exception {

Class clazz = mappings.get(type);

return clazz.getDeclaredConstructor().newInstance();

}

}

架构视角的工厂模式

在分层架构中的应用

表示层：视图组件工厂

业务层：服务对象工厂

持久层：DAO工厂

基础设施层：连接池工厂

微服务中的工厂模式

客户端工厂：

public class ServiceClientFactory {

private final Map clients = new ConcurrentHashMap<>();

public ServiceClient getClient(String serviceName) {

return clients.computeIfAbsent(serviceName, name -> {

String endpoint = discoveryClient.getEndpoint(name);

return new RestServiceClient(endpoint);

});

}

}

容错工厂：

public class CircuitBreakerFactory {

public CircuitBreaker create(String serviceName) {

CircuitBreakerConfig config = configRepository.getConfig(serviceName);

return new CircuitBreaker.Builder()

.failureThreshold(config.getThreshold())

.timeout(config.getTimeout())

.build();

}

}

云原生环境应用

动态配置工厂：

public class CloudConfigFactory {

private final ConfigServerClient configClient;

public T create(Class type) {

String configKey = type.getSimpleName().toLowerCase();

Map config = configClient.getConfig(configKey);

return configureInstance(type, config);

}

private T configureInstance(Class type, Map config) {

// 使用反射构建配置对象

}

}

性能优化实践

对象池工厂

public class ObjectPool {

private final Queue available = new ConcurrentLinkedQueue<>();

private final Supplier factory;

public ObjectPool(Supplier factory) {

this.factory = factory;

}

public T borrow() {

T obj = available.poll();

return obj != null ? obj : factory.get();

}

public void release(T obj) {

available.offer(obj);

}

}

// 使用示例

ObjectPool pool = new ObjectPool<>(() -> createDatabaseConnection());

Connection conn = pool.borrow();

try {

// 使用连接

} finally {

pool.release(conn);

}

缓存工厂

public class CachingFactory {

private final Map, Object> cache = new ConcurrentHashMap<>();

@SuppressWarnings("unchecked")

public T getInstance(Class type) {

return (T) cache.computeIfAbsent(type, t -> {

try {

return type.getDeclaredConstructor().newInstance();

} catch (Exception e) {

throw new RuntimeException("创建实例失败", e);

}

});

}

}

设计模式演进趋势

响应式编程中的工厂

public class ReactiveFactory {

public Mono createResourceAsync(String config) {

return Mono.fromCallable(() -> createResource(config))

.subscribeOn(Schedulers.boundedElastic());

}

private Resource createResource(String config) {

// 阻塞型资源创建

return new Resource(config);

}

}

函数式编程结合

public class FunctionalFactory {

private final Map> constructors = new HashMap<>();

public void register(String type, Function constructor) {

constructors.put(type, constructor);

}

public Product build(String type, Config config) {

return constructors.getOrDefault(type, cfg -> {

throw new IllegalArgumentException("Unknown product type");

}).apply(config);

}

}