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

发布时间：2025-02-23 10:02:28
本文热度：浏览 10 赞 0 评论 0
文章标签： Java 设计模式工厂模式
全文共1字，阅读约需1分钟

简单工厂模式（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> T getBean(String name, Class<T> 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<String, Resource> 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<String, Supplier<Product>> registry = new HashMap<>();
    
    public void register(String type, Supplier<Product> supplier) {
        registry.put(type, supplier);
    }
    
    public Product create(String type) {
        Supplier<Product> 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<String, Class<? extends Product>> mappings = new HashMap<>();
    
    public void scanPackage(String packageName) {
        Reflections reflections = new Reflections(packageName);
        Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(ProductRegistration.class);
        
        for (Class<?> clazz : annotated) {
            ProductRegistration annotation = clazz.getAnnotation(ProductRegistration.class);
            mappings.put(annotation.value(), (Class<? extends Product>) clazz);
        }
    }
    
    public Product create(String type) throws Exception {
        Class<? extends Product> clazz = mappings.get(type);
        return clazz.getDeclaredConstructor().newInstance();
    }
}

架构视角的工厂模式

在分层架构中的应用

表示层：视图组件工厂
业务层：服务对象工厂
持久层：DAO工厂
基础设施层：连接池工厂

微服务中的工厂模式

客户端工厂：

public class ServiceClientFactory {
    private final Map<String, ServiceClient> 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> T create(Class<T> type) {
        String configKey = type.getSimpleName().toLowerCase();
        Map<String, Object> config = configClient.getConfig(configKey);
        return configureInstance(type, config);
    }
    
    private <T> T configureInstance(Class<T> type, Map<String, Object> config) {
        // 使用反射构建配置对象
    }
}

性能优化实践

对象池工厂

public class ObjectPool<T> {
    private final Queue<T> available = new ConcurrentLinkedQueue<>();
    private final Supplier<T> factory;
    
    public ObjectPool(Supplier<T> 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<Connection> pool = new ObjectPool<>(() -> createDatabaseConnection());
Connection conn = pool.borrow();
try {
    // 使用连接
} finally {
    pool.release(conn);
}

缓存工厂

public class CachingFactory {
    private final Map<Class<?>, Object> cache = new ConcurrentHashMap<>();
    
    @SuppressWarnings("unchecked")
    public <T> T getInstance(Class<T> type) {
        return (T) cache.computeIfAbsent(type, t -> {
            try {
                return type.getDeclaredConstructor().newInstance();
            } catch (Exception e) {
                throw new RuntimeException("创建实例失败", e);
            }
        });
    }
}

设计模式演进趋势

响应式编程中的工厂

public class ReactiveFactory {
    public Mono<Resource> 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<String, Function<Config, Product>> constructors = new HashMap<>();
    
    public void register(String type, Function<Config, Product> 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);
    }
}

正文到此结束

所属分类：Java学习

本文链接： https://refblogs.com/article/841
版权声明： 本文由老牛原创发布，转载或复制请以超链接形式转载,并注明出处搬砖的码农。