1. Bean作用域概述
在Spring框架中，Bean作用域决定了Bean实例的生命周期和可见范围。理解作用域是掌握Spring IoC容器的关键基础，它直接影响着应用的性能表现、线程安全性和资源管理策略。
Spring最初只支持两种基本作用域：singleton（单例）和prototype（原型）。随着框架发展，Spring为Web应用新增了request、session等作用域，并提供了灵活的自定义作用域机制。选择合适的作用域需要考虑以下因素：
- 对象创建成本
- 线程安全需求
- 状态保持需求
- 资源占用情况
实际开发中最容易犯的错误就是作用域选择不当。比如在有状态的场景使用单例会导致线程安全问题，而在无状态服务中使用原型又会造成资源浪费。
2. Singleton作用域深度解析
2.1 核心特性与工作机制
Singleton是Spring容器的默认作用域，具有以下典型特征：
- 唯一实例：每个Spring IoC容器中，同名的Bean定义只对应一个实例
- 全局共享：所有依赖注入和getBean()调用都返回同一对象引用
- 缓存机制：通过单例池(Singleton Objects)实现实例缓存
java复制// 典型单例Bean配置
@Bean
@Scope("singleton") // 可省略，默认就是singleton
public DataSource dataSource() {
return new HikariDataSource();
}
单例Bean的实例化时机由lazy-init属性控制：
false(默认)：容器启动时立即初始化true：首次请求时延迟初始化
2.2 单例池实现原理
Spring通过三级缓存机制管理单例Bean：
- 一级缓存(singletonObjects)：存储完全初始化好的Bean
- 二级缓存(earlySingletonObjects)：存储提前暴露的原始Bean
- 三级缓存(singletonFactories)：存储Bean工厂对象
java复制// 简化的单例获取流程
public Object getSingleton(String beanName) {
// 1. 检查一级缓存
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 2. 检查二级缓存
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 3. 检查三级缓存
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// 升级到二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
return singletonObject;
}
2.3 线程安全实践
单例Bean的线程安全问题需要特别关注：
无状态Bean（线程安全）
java复制@Service
public class CalculatorService {
// 无成员变量，纯方法操作
public int add(int a, int b) {
return a + b;
}
}
有状态Bean（非线程安全）
java复制@Service
public class CounterService {
private int count; // 共享状态
public void increment() {
count++; // 非原子操作
}
}
解决方案对比：
| 方案 | 实现方式 | 优缺点 |
|---|---|---|
| 改为prototype | @Scope("prototype") |
确保线程安全但增加创建开销 |
| 使用ThreadLocal | 将状态存储在ThreadLocal中 | 轻量级但需注意内存泄漏 |
| 同步控制 | 添加synchronized或Lock | 影响并发性能 |
3. Prototype作用域详解
3.1 核心特性与使用场景
Prototype作用域每次都会创建新实例，适用于：
- 需要保持独立状态的Bean
- 创建成本不高的对象
- 线程不安全需要隔离的场景
xml复制<bean id="shoppingCart" class="com.example.ShoppingCart" scope="prototype"/>
与Singleton的关键差异：
- 实例化时机：每次getBean()时创建
- 生命周期管理：Spring只负责初始化不负责销毁
- 性能影响：频繁创建可能增加GC压力
3.2 生命周期管理陷阱
Prototype Bean需要特别注意资源释放问题：
java复制public class FileProcessor implements DisposableBean {
private FileInputStream fileStream;
@Override
public void destroy() throws Exception {
// 不会被Spring调用！
fileStream.close();
}
}
正确做法：
java复制public void processFile() {
try(FileInputStream fis = new FileInputStream("data.txt")) {
// 处理文件
} catch (IOException e) {
// 异常处理
}
}
3.3 性能优化策略
对于创建成本高的Prototype Bean，可以考虑：
- 对象池模式：使用commons-pool等库实现
- 延迟加载：结合@Lazy注解
- 轻量级设计：减少初始化逻辑
java复制@Scope("prototype")
@Lazy // 延迟到首次使用时初始化
public class ExpensiveResource {
// 复杂初始化逻辑
}
4. 作用域交互问题与解决方案
4.1 单例依赖原型问题
典型场景：
java复制@Service
public class OrderService {
@Autowired
private ShoppingCart cart; // 希望每次使用新实例
public void checkout() {
cart.addItems(...);
}
}
即使ShoppingCart是prototype，OrderService中注入的也是同一个实例。
4.2 解决方案对比
方案1：方法注入(Lookup Method)
java复制public abstract class OrderService {
public abstract ShoppingCart getCart();
public void checkout() {
ShoppingCart cart = getCart();
// 使用cart
}
}
XML配置：
xml复制<bean id="orderService" class="com.example.OrderService">
<lookup-method name="getCart" bean="shoppingCart"/>
</bean>
方案2：ObjectProvider
java复制@Service
public class OrderService {
@Autowired
private ObjectProvider<ShoppingCart> cartProvider;
public void checkout() {
ShoppingCart cart = cartProvider.getObject();
// 使用cart
}
}
方案3：@Scope(proxyMode)
java复制@Service
public class OrderService {
@Autowired
@Scope(
value = "prototype",
proxyMode = ScopedProxyMode.TARGET_CLASS
)
private ShoppingCart cart;
}
方案对比表：
| 方案 | 实现复杂度 | 性能影响 | 适用场景 |
|---|---|---|---|
| Lookup Method | 中 | 低 | 传统XML配置项目 |
| ObjectProvider | 低 | 中 | Spring 4.3+项目 |
| Scoped Proxy | 高 | 高 | 需要AOP特性的场景 |
5. Web作用域与自定义作用域
5.1 Web作用域详解
Spring为Web应用提供四种特殊作用域：
| 作用域 | 生命周期 | 典型应用 |
|---|---|---|
| request | 单个HTTP请求 | 表单数据、临时状态 |
| session | 用户会话期间 | 用户偏好、购物车 |
| application | ServletContext生命周期 | 全局缓存 |
| websocket | WebSocket会话期间 | 实时通信状态 |
配置方式：
java复制@Bean
@Scope(
value = WebApplicationContext.SCOPE_SESSION,
proxyMode = ScopedProxyMode.TARGET_CLASS
)
public UserPreferences userPreferences() {
return new UserPreferences();
}
5.2 自定义作用域实现
实现自定义作用域需要：
- 实现
org.springframework.beans.factory.config.Scope接口 - 注册到Spring容器
示例：集群作用域
java复制public class ClusterScope implements Scope {
private final Map<String, Object> cache = new ConcurrentHashMap<>();
@Override
public Object get(String name, ObjectFactory<?> objectFactory) {
return cache.computeIfAbsent(name, k -> objectFactory.getObject());
}
@Override
public Object remove(String name) {
return cache.remove(name);
}
// 其他方法实现...
}
注册自定义作用域：
java复制@Configuration
public class ScopeConfig {
@Bean
public static CustomScopeConfigurer clusterScopeConfigurer() {
CustomScopeConfigurer configurer = new CustomScopeConfigurer();
configurer.addScope("cluster", new ClusterScope());
return configurer;
}
}
6. 作用域最佳实践
6.1 选择策略
根据业务场景选择作用域：
- 无状态服务：优先使用singleton
- 有状态组件：根据生命周期选择request/session/prototype
- 昂贵资源：考虑自定义作用域或对象池
6.2 性能考量
作用域对性能的影响因素：
- 实例化开销：prototype > singleton
- 内存占用：长时间存活的作用域(session)可能积累状态
- 清理成本：需要手动管理资源的prototype Bean
6.3 常见陷阱
- 意外共享状态：在singleton中错误使用实例变量
- 内存泄漏：未及时清理session/request作用域的Bean
- 循环依赖：prototype Bean间的循环引用会导致异常
java复制// 错误示例：singleton中的可变状态
@Service
public class AnalyticsService {
private Map<String, Integer> counters = new HashMap<>();
public void count(String event) {
counters.merge(event, 1, Integer::sum);
}
}
修正方案：
java复制@Service
public class AnalyticsService {
private final ConcurrentHashMap<String, AtomicInteger> counters = new ConcurrentHashMap<>();
public void count(String event) {
counters.computeIfAbsent(event, k -> new AtomicInteger()).incrementAndGet();
}
}
在实际项目中，我通常会遵循以下检查清单来确保作用域使用正确：
- 明确Bean是否有状态需求
- 评估对象的创建成本
- 考虑并发访问场景
- 规划资源释放策略
- 编写对应的单元测试验证行为
对于复杂的业务场景，建议使用组合策略。比如在电商系统中：
- 商品服务(无状态)：singleton
- 购物车(用户会话)：session
- 订单处理(需要隔离)：prototype
- 支付处理器(昂贵资源)：自定义pooled作用域