工厂方法模式（Factory Method）深度解析：从原理到实战优化

作者：摘星

次浏览

次

2025-6-4

编辑推荐:

本文主要介绍了工厂方法模式（Factory Method）深度解析：从原理到实战优化相关内容。希望对你的学习有帮助。
本文来自于CSDN，由火龙果软件Linda编辑、推荐。

1. 技术背景

在软件开发中，我们经常遇到需要确保一个类只有一个实例的情况。比如数据库连接池、线程池、配置管理、日志记录器等场景，如果创建多个实例会导致资源浪费或数据不一致的问题。单例模式（Singleton）就是为了解决这类问题而诞生的设计模式。

图1：单例模式应用场景示意图

单例模式属于创建型设计模式，它保证一个类只有一个实例，并提供一个全局访问点。这种模式在Java、C++、Python等多种编程语言中都有广泛应用。

2. 概念定义

2.1 单例模式的核心概念

单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问该实例。单例模式通常用于控制资源密集型对象的创建，或者需要严格限制实例数量的场景。

2.2 单例模式的三个基本要素

私有静态实例变量：存储类的唯一实例

私有构造函数：防止外部通过new创建实例

公有静态访问方法：提供全局访问点

图2：单例模式基本结构

3. 原理剖析

3.1 单例模式的实现原理

单例模式的核心在于控制实例化过程，确保无论调用多少次创建方法，都返回同一个实例。这主要通过以下机制实现：

延迟初始化(Lazy Initialization)：实例在第一次被请求时才创建

线程安全(Thread Safety)：防止多线程环境下创建多个实例

全局访问点(Global Access Point)：通过静态方法提供统一访问入口

3.2 单例模式的生命周期

图3：单例模式生命周期时序图

4. 技术实现

4.1 基础实现（非线程安全）


/**
 * 基础单例实现（非线程安全）
 * 适用于单线程环境
 */
public class BasicSingleton {
    private static BasicSingleton instance;
    
    // 私有构造函数防止外部实例化
    private BasicSingleton() {
        System.out.println("BasicSingleton instance created");
    }
    
    /**
     * 获取单例实例
     * @return 单例实例
     */
    public static BasicSingleton getInstance() {
        if (instance == null) {
            instance = new BasicSingleton();
        }
        return instance;
    }
    
    // 示例业务方法
    public void showMessage() {
        System.out.println("Hello from BasicSingleton!");
    }
}

4.2 线程安全实现（同步方法）


/**
 * 线程安全单例实现（同步方法）
 * 使用synchronized保证线程安全，但性能较低
 */
public class ThreadSafeSingleton {
    private static ThreadSafeSingleton instance;
    
    private ThreadSafeSingleton() {
        System.out.println("ThreadSafeSingleton instance created");
    }
    
    /**
     * 获取单例实例（线程安全）
     * @return 单例实例
     */
    public static synchronized ThreadSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
}

4.3 双重检查锁定（DCL）实现


/**
 * 双重检查锁定单例实现
 * 兼顾线程安全和性能
 */
public class DCLSingleton {
    // volatile确保多线程环境下可见性
    private static volatile DCLSingleton instance;
    
    private DCLSingleton() {
        System.out.println("DCLSingleton instance created");
    }
    
    /**
     * 获取单例实例（双重检查锁定）
     * @return 单例实例
     */
    public static DCLSingleton getInstance() {
        // 第一次检查（无锁）
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                // 第二次检查（有锁）
                if (instance == null) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

4.4 静态内部类实现（推荐）


/**
 * 静态内部类单例实现（推荐）
 * 线程安全且实现简单，利用类加载机制保证唯一性
 */
public class InnerClassSingleton {
    private InnerClassSingleton() {
        System.out.println("InnerClassSingleton instance created");
    }
    
    /**
     * 静态内部类持有单例实例
     */
    private static class SingletonHolder {
        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }
    
    /**
     * 获取单例实例
     * @return 单例实例
     */
    public static InnerClassSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

4.5 枚举实现（最佳实践）


/**
 * 枚举单例实现（最佳实践）
 * 防止反射攻击和序列化问题
 */
public enum EnumSingleton {
    INSTANCE;
    
    // 示例业务方法
    public void doSomething() {
        System.out.println("EnumSingleton doing something");
    }
}

5. 应用场景

5.1 典型应用场景

配置管理：全局配置对象只需要一个实例

日志记录：所有日志应该通过同一个日志记录器处理

数据库连接池：避免频繁创建和销毁连接

缓存系统：统一管理缓存数据

线程池：控制线程资源的使用

5.2 场景选择建议

图4：单例模式实现方式选择流程图

6. 实际案例

6.1 Spring框架中的单例模式

Spring框架默认将Bean配置为单例作用域，这是单例模式的典型应用：


// Spring配置示例
@Configuration
public class AppConfig {
    @Bean
    @Scope("singleton")  // 默认就是singleton，可省略
    public MyService myService() {
        return new MyServiceImpl();
    }
}

6.2 Java Runtime类

JDK中的Runtime类就是单例模式的经典实现：


                                  
                                     
                                       
                                        
/**
 * JDK Runtime类单例实现分析
 */
public class Runtime {
    private static Runtime currentRuntime = new Runtime();
 
    public static Runtime getRuntime() {
        return currentRuntime;
    }
 
    private Runtime() {}
    
    // 其他方法...
}

7. 优缺点分析

7.1 优点

控制实例数量：确保一个类只有一个实例

全局访问点：方便对实例的管理和控制

节省资源：避免频繁创建和销毁对象

避免状态不一致：所有使用方都访问同一个实例

7.2 缺点

违反单一职责原则：单例类既管理自己的生命周期又包含业务逻辑

难以测试：单例的全局状态使得单元测试变得复杂

隐藏依赖关系：通过全局访问点获取实例，依赖关系不明显

线程安全问题：需要特别注意多线程环境下的实现

8. 纵横对比

8.1 单例模式 vs 静态工具类

8.2 不同实现方式对比

9. 实战思考

9.1 单例模式的优化策略

使用SSO(Search Space Optimization)搜索优化：

在分布式系统中，可以使用集中式缓存(如Redis)实现全局单例

通过键值对存储单例状态，确保集群中唯一



                                     
                                      
                                    
                                  
/**
 * 基于Redis的分布式单例实现
 */
public class RedisSingleton {
    private static final String REDIS_KEY = "global:singleton:config";
    private Jedis jedis;
    
    private RedisSingleton() {
        this.jedis = new Jedis("localhost");
    }
    
    private static class Holder {
        private static final RedisSingleton INSTANCE = new RedisSingleton();
    }
    
    public static RedisSingleton getInstance() {
        return Holder.INSTANCE;
    }
    
    public String getConfig(String key) {
        return jedis.hget(REDIS_KEY, key);
    }
    
    public void setConfig(String key, String value) {
        jedis.hset(REDIS_KEY, key, value);
    }
}

关键词重叠法优化：

在需要多个相似单例时，可以使用注册表模式

通过关键词重叠减少重复代码


/**
 * 使用注册表模式管理多个单例
 */
public class SingletonRegistry {
    private static Map<String, Object> registry = new ConcurrentHashMap<>();
    
    private SingletonRegistry() {}
    
    public static synchronized Object getInstance(String className) {
        Object instance = registry.get(className);
        if (instance == null) {
            try {
                instance = Class.forName(className).newInstance();
                registry.put(className, instance);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        return instance;
    }
}