Spring单例模式实现与最佳实践-代码聚汇网

Spring单例模式实现与最佳实践

清浅池塘·2026-08-11·阅读 26 GEO检测（免费）

Spring单例模式@Scope注解@Bean注解

|难度：普通|阅读约 23 分钟

1. Spring框架中的单例模式实现机制

在Spring框架中，单例模式是最常用的Bean作用域之一。Spring通过两种主要方式实现单例：

@Scope注解显式声明
@Bean注解的默认行为

这两种方式虽然最终效果相同，但在实现机制和使用场景上存在差异。理解这些差异对于设计健壮的Spring应用至关重要。

1.1 @Scope注解的单例声明

@Scope注解是Spring中用于定义Bean作用域的核心注解。当我们需要显式声明一个Bean为单例时，可以这样使用：

java复制@Scope("singleton")
@Component
public class OrderService {
    // 类实现
}

或者使用常量形式（更推荐）：

java复制@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
@Component
public class OrderService {
    // 类实现
}

这种方式的几个关键特点：

显式声明了Bean的作用域，代码可读性更好
可以与其它作用域（如prototype）明确区分
适用于需要强调作用域的场景

注意：虽然"singleton"是默认值，但在团队协作项目中，显式声明可以避免误解，特别是当Bean的作用域对业务逻辑有重要影响时。

1.2 @Bean注解的默认单例行为

在Java配置类中，@Bean方法默认就会创建单例Bean：

java复制@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
}

这种方式的特性包括：

简洁 - 不需要额外注解
约定优于配置 - 遵循Spring的默认约定
适用于大多数常规场景

实际上，@Bean的这种行为是因为Spring的默认作用域就是singleton。如果我们查看@Bean的源码，会发现它确实没有强制指定作用域，而是依赖于框架的默认行为。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 单例Bean的底层实现原理

2.1 Spring容器的单例注册表

Spring通过SingletonBeanRegistry接口及其实现来管理单例Bean。核心机制包括：

单例缓存：使用ConcurrentHashMap存储已创建的单例实例
同步控制：通过synchronized块保证线程安全
早期引用：解决循环依赖问题

java复制// 简化的Spring单例注册表示例
public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    public Object getSingleton(String beanName) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            synchronized (this.singletonObjects) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    // 创建并注册单例
                    singletonObject = createBean(beanName);
                    this.singletonObjects.put(beanName, singletonObject);
                }
            }
        }
        return singletonObject;
    }
}

2.2 单例Bean的生命周期

单例Bean的生命周期与普通Bean有所不同：

容器启动时预初始化（可通过lazy-init延迟）
生命周期与容器相同
销毁时调用destroy方法

典型生命周期方法调用顺序：

构造器或工厂方法
@PostConstruct注解方法
InitializingBean的afterPropertiesSet()
自定义init-method
使用期
@PreDestroy注解方法
DisposableBean的destroy()
自定义destroy-method

3. 单例模式的最佳实践与陷阱

3.1 适合使用单例的场景

无状态服务：如工具类、配置类
重量级资源：数据库连接池、线程池
核心业务服务：如订单服务、支付服务
缓存管理器

3.2 应避免单例的情况

有状态的Bean：可能导致线程安全问题
需要每次使用新实例的场景：如原型模式更合适
测试环境：可能影响测试隔离性

3.3 线程安全考虑

虽然Spring容器本身保证了单例创建的线程安全，但开发者仍需注意：

避免实例变量：尽量使用局部变量或方法参数
必要的同步：对共享资源使用适当的同步机制
不可变对象：尽可能设计不可变类

java复制// 线程安全的单例服务示例
@Service
public class StatisticsService {
    private final AtomicLong counter = new AtomicLong(0);
    
    public void increment() {
        counter.incrementAndGet();
    }
    
    public long getCount() {
        return counter.get();
    }
}

4. 高级应用：自定义作用域与场景单例

4.1 实现自定义作用域

Spring允许注册自定义作用域，实现更灵活的生命周期管理：

java复制public class ScenarioScope implements Scope {
    private final Map<String, Object> scenarioInstances = new ConcurrentHashMap<>();
    
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        String scenarioId = ScenarioContext.getCurrentScenarioId();
        String key = scenarioId + ":" + name;
        
        return scenarioInstances.computeIfAbsent(key, 
            k -> objectFactory.getObject());
    }
    
    // 其他必要方法实现...
}

// 注册自定义作用域
@Component
public class ScenarioScopeRegistrar implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        beanFactory.registerScope("scenario", new ScenarioScope());
    }
}

4.2 场景单例与全局单例的比较

特性	全局单例	场景单例
生命周期	整个应用	特定场景期间
存储位置	单例缓存	自定义存储
适用场景	通用服务	场景相关服务
内存占用	固定	动态变化
线程安全	需要保证	通常更简单

5. 常见问题排查

5.1 单例Bean中的依赖问题

问题现象：单例Bean中注入原型Bean时，原型行为失效。

原因分析：Spring在注入依赖时只执行一次注入操作。

解决方案：

使用方法注入（@Lookup）
实现ApplicationContextAware获取新实例
使用ObjectFactory延迟获取

java复制@Service
@Scope("singleton")
public class OrderService {
    @Autowired
    private ObjectFactory<UserService> userServiceProvider;
    
    public void processOrder() {
        UserService userService = userServiceProvider.getObject();
        // 每次都会获取新实例
    }
}

5.2 循环依赖问题

Spring通过三级缓存解决单例Bean的循环依赖：

singletonObjects：完整单例缓存
earlySingletonObjects：早期引用缓存
singletonFactories：单例工厂缓存

典型解决方案：

重构设计，避免循环依赖
使用setter注入代替构造器注入
使用@Lazy延迟初始化

5.3 单例Bean的内存泄漏

由于单例生命周期长，容易积累内存泄漏：

常见泄漏点：

监听器未正确注销
集合类不断增长
缓存未设置上限

检测工具：

VisualVM
Eclipse MAT
YourKit

预防措施：

定期审查单例Bean
实现DisposableBean清理资源
使用WeakReference处理缓存

6. 性能优化技巧

6.1 延迟初始化权衡

通过@Lazy实现延迟初始化：

优点：

加快应用启动速度
减少初始内存占用

缺点：

首次请求延迟
可能掩盖初始化问题

java复制@Configuration
public class AppConfig {
    @Bean
    @Lazy
    public HeavyResource heavyResource() {
        return new HeavyResource();
    }
}

6.2 单例Bean的初始化优化

并行初始化：通过@DependsOn控制顺序
分批初始化：结合@Lazy使用
预加载关键服务：确保核心服务可用

6.3 缓存策略选择

根据单例Bean的特性选择合适的缓存策略：

静态数据：应用启动时加载
半静态数据：定时刷新
动态数据：懒加载+缓存失效

java复制@Service
public class ProductService {
    private final Map<Long, Product> productCache = new ConcurrentHashMap<>();
    
    @Scheduled(fixedRate = 3600000)
    public void refreshCache() {
        // 定期刷新缓存
    }
}

7. 测试策略

7.1 单例Bean的单元测试

挑战：单例状态可能影响测试隔离。

解决方案：

重置状态：@BeforeEach中重置关键状态
使用Mockito.spy()部分模拟
考虑原型作用域测试变体

7.2 集成测试考虑

上下文缓存：重用应用上下文加速测试
脏上下文处理：@DirtiesContext注解
测试专用配置：@TestConfiguration

java复制@SpringBootTest
public class OrderServiceTest {
    @Autowired
    private OrderService orderService;
    
    @Test
    @DirtiesContext
    public void testSingletonState() {
        // 测试会修改单例状态
    }
}

8. 现代Spring中的单例模式演进

8.1 Spring Boot中的自动化配置

Spring Boot大量使用条件化单例Bean：

java复制@Configuration
@ConditionalOnClass(DataSource.class)
public class DataSourceAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public DataSource dataSource() {
        // 创建单例DataSource
    }
}

8.2 响应式编程中的单例

在WebFlux等响应式环境中：

单例Bean需要是无阻塞的
避免共享可变状态
考虑使用反应式缓存

java复制@Service
public class ReactiveProductService {
    private final ReactiveCache<Long, Product> cache;
    
    public Mono<Product> getProduct(Long id) {
        return cache.get(id);
    }
}

8.3 Spring AI中的单例应用

在AI组件集成中：

模型加载器适合单例
预测服务通常设计为无状态单例
训练服务可能需要原型作用域

java复制@Configuration
public class AiConfig {
    @Bean
    @Scope("singleton")
    public ModelLoader modelLoader() {
        return new PretrainedModelLoader();
    }
}

9. 设计模式结合实践

9.1 单例与其他模式的组合

单例+工厂模式：集中管理对象创建
单例+策略模式：运行时选择算法
单例+门面模式：提供统一接口

java复制@Service
public class PaymentStrategyFactory {
    private final Map<String, PaymentStrategy> strategies;
    
    @Autowired
    public PaymentStrategyFactory(List<PaymentStrategy> strategyList) {
        strategies = strategyList.stream()
            .collect(Collectors.toMap(
                PaymentStrategy::getType,
                Function.identity()
            ));
    }
    
    public PaymentStrategy getStrategy(String type) {
        return strategies.get(type);
    }
}

9.2 单例与微服务架构

在微服务中：

每个服务实例维护自己的单例
分布式缓存代替本地缓存
考虑Spring Cloud的@RefreshScope

java复制@Service
@RefreshScope
public class ConfigService {
    @Value("${app.config}")
    private String config;
    
    // 配置更新时会刷新Bean
}

10. 实际案例：电商系统中的单例应用

10.1 购物车服务设计

典型错误：将购物车设计为单例

正确做法：

用户会话作用域
或原型作用域+Redis存储

java复制@Service
@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ShoppingCartService {
    // 每个会话独立的购物车
}

10.2 库存服务实现

适合单例的场景：

集中管理库存状态
需要原子操作
高频率访问

java复制@Service
public class InventoryService {
    private final Map<Long, AtomicInteger> stockMap = new ConcurrentHashMap<>();
    
    @Transactional
    public boolean reduceStock(Long productId, int quantity) {
        AtomicInteger stock = stockMap.get(productId);
        if (stock == null) {
            throw new ProductNotFoundException(productId);
        }
        return stock.updateAndGet(current -> current >= quantity ? current - quantity : current) >= 0;
    }
}

10.3 优惠券服务优化

单例+定时任务实现优惠券过期：

java复制@Service
public class CouponService {
    @Scheduled(cron = "0 0 3 * * ?")
    public void expireCoupons() {
        // 每天凌晨3点处理过期优惠券
    }
}

在Spring框架中合理使用单例模式需要深入理解其工作机制和适用场景。通过@Scope注解显式声明或依赖@Bean的默认行为都是有效的实现方式，但要注意线程安全、内存管理和测试策略等方面的问题。对于特殊需求，Spring的灵活作用域机制允许我们扩展自定义作用域，如场景单例等实现。