Spring Bean 核心知识点全解析:从基础配置到高级实战
·
前言
在 Spring 框架的世界里,Bean 是一切的核心。无论是初学者还是资深开发者,深入理解 Bean 的配置、生命周期、依赖注入机制,都是掌握 Spring 必不可少的一步。
本文将从零开始,系统梳理 Spring Bean 的核心知识点,涵盖 XML 配置、注解配置、JavaConfig 三种配置方式,深入剖析 Bean 的完整生命周期,详解作用域策略,并分享延迟初始化、条件化装配等高级特性。最后,结合实际场景提供最佳实践和常见问题解决方案,帮助你从“会用”到“精通”。
文章特色
✅ 全面覆盖:从基础概念到高级特性,一次性讲透 Spring Bean
✅ 实战导向:丰富的代码示例,可直接用于生产环境
✅ 深度解析:不仅告诉你“怎么用”,更解释“为什么这样用”
适合人群
Spring 初学者:系统学习 Bean 核心概念
进阶开发者:深入理解生命周期、作用域等高级特性
架构师:掌握条件化装配等企业级配置技巧
面试准备:全面梳理 Spring Bean 相关知识点
概述
定义
- 定义 :
Bean 是 Spring IoC 容器管理的对象,是 Spring 应用程序的核心组件。
Bean 是由 Spring 容器实例化、组装、管理的对象。
- 核心价值 :
- 解耦:通过依赖注入实现对象间的松耦合
- 生命周期管理:容器统一管理对象的创建、初始化、销毁
- 配置灵活:支持 XML、注解、Java 配置等多种配置方式
- AOP 基础:为面向切面编程提供基础支持
核心
核心原理
Bean的配置方式
XML 配置方式
基础配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- Bean 基础配置 -->
<bean id="userService" class="com.example.service.UserServiceImpl">
<property name="userDao" ref="userDao"/>
</bean>
<bean id="userDao" class="com.example.dao.UserDaoImpl"/>
依赖注入
- 构造器注入(推荐)
<bean id="userService" class="com.example.service.UserServiceImpl">
<constructor-arg index="0" ref="userDao"/>
<constructor-arg index="1" value="admin"/>
</bean>
- setter注入
<bean id="userService" class="com.example.service.UserServiceImpl">
<property name="userDao" ref="userDao"/>
<property name="maxRetry" value="3"/>
</bean>
- 注入集合
<bean id="userService" class="com.example.service.UserServiceImpl">
<property name="userList">
<list>
<value>user1</value>
<value>user2</value>
</list>
</property>
<property name="properties">
<props>
<prop key="url">jdbc:mysql://localhost:3306/test</prop>
<prop key="username">root</prop>
</props>
</property>
</bean>
注解配置方式
核心注解
// 组件注册注解
@Component // 通用组件
@Repository // DAO 层
@Service // Service 层
@Controller // Controller 层
// 依赖注入注解
@Autowired // 自动注入(byType)
@Qualifier("beanName") // 指定 Bean 名称
@Resource // JSR-250 注解(byName)
@Value // 注入配置值
// 配置类注解
@Configuration // 标记为配置类
@Bean // 注册 Bean
@ComponentScan // 扫描组件
@Import // 导入其他配置
// 作用域与生命周期
@Scope // 指定作用域
@Lazy // 延迟初始化
@PostConstruct // 初始化后回调
@PreDestroy // 销毁前回调
// 条件化注册
@Conditional // 条件化装配
@Profile // 环境配置
@Primary // 主要候选者
@DependsOn // 依赖的 Bean 优先初始化
代码示例
- 配置类实例
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
@Bean
public DataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUrl("jdbc:mysql://localhost:3306/test");
dataSource.setUsername("root");
dataSource.setPassword("password");
return dataSource;
}
@Bean
public UserDao userDao(DataSource dataSource) {
return new UserDaoImpl(dataSource);
}
@Bean
public UserService userService(UserDao userDao) {
UserServiceImpl userService = new UserServiceImpl();
userService.setUserDao(userDao);
return userService;
}
}
- Service 层示例
@Service
public class UserServiceImpl implements UserService {
@Autowired
@Qualifier("userDao")
private UserDao userDao;
@Value("${service.max.retry:3}")
private int maxRetry;
@Override
public User findUserById(Long id) {
return userDao.findById(id);
}
}
Java 配置与 XML 混合使用
@Configuration
@ImportResource("classpath:spring-dao.xml")
@ComponentScan(basePackages = "com.example.service")
public class AppConfig {
// 可以在这里定义 Java 配置的 Bean
}
Bean生命周期
生命周期完整流程
[实例化阶段]
1. 实例化 Bean(构造器调用)
[属性设置阶段]
2. 设置属性值(依赖注入)
[Aware 回调阶段]
3. 调用 BeanNameAware 的 setBeanName()
4. 调用 BeanFactoryAware 的 setBeanFactory()
5. 调用 ApplicationContextAware 的 setApplicationContext()
[初始化阶段]
6. 调用 BeanPostProcessor 的 postProcessBeforeInitialization()
7. 调用 InitializingBean 的 afterPropertiesSet()
8. 调用 @PostConstruct 注解的方法
9. 调用 init-method 指定的初始化方法
10. 调用 BeanPostProcessor 的 postProcessAfterInitialization()
[就绪可用阶段]
✓ Bean 就绪,可以使用
[销毁阶段]
11. 调用 @PreDestroy 注解的方法
12. 调用 DisposableBean 的 destroy()
13. 调用 destroy-method 指定的销毁方法
生命周期代码示例
@Component
public class LifecycleBean implements BeanNameAware, BeanFactoryAware,
ApplicationContextAware, InitializingBean, DisposableBean {
private String beanName;
private BeanFactory beanFactory;
private ApplicationContext applicationContext;
// 1. 构造器
public LifecycleBean() {
System.out.println("1. 实例化 Bean");
}
// 2. 属性注入
@Autowired
public void setDependency(DependencyBean dependency) {
System.out.println("2. 依赖注入");
}
// 3. BeanNameAware
@Override
public void setBeanName(String name) {
this.beanName = name;
System.out.println("3. BeanNameAware.setBeanName() - " + name);
}
// 4. BeanFactoryAware
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
System.out.println("4. BeanFactoryAware.setBeanFactory()");
}
// 5. ApplicationContextAware
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
System.out.println("5. ApplicationContextAware.setApplicationContext()");
}
// 6. BeanPostProcessor 前置处理
// 由容器调用,不在 Bean 中定义
// 7. @PostConstruct
@PostConstruct
public void postConstruct() {
System.out.println("7. @PostConstruct 注解方法");
}
// 8. InitializingBean
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("8. InitializingBean.afterPropertiesSet()");
}
// 9. init-method
public void customInit() {
System.out.println("9. 自定义 init-method");
}
// 10. BeanPostProcessor 后置处理(由容器调用)
// Bean 就绪可以使用
// 11. @PreDestroy
@PreDestroy
public void preDestroy() {
System.out.println("11. @PreDestroy 注解方法");
}
// 12. DisposableBean
@Override
public void destroy() throws Exception {
System.out.println("12. DisposableBean.destroy()");
}
// 13. destroy-method
public void customDestroy() {
System.out.println("13. 自定义 destroy-method");
}
}
生命周期配置方式
XML 配置指定初始化和销毁方法:
<bean id="lifecycleBean" class="com.example.bean.LifecycleBean"
init-method="customInit" destroy-method="customDestroy"/>
配置类方式:
@Bean(initMethod = "customInit", destroyMethod = "customDestroy")
public LifecycleBean lifecycleBean() {
return new LifecycleBean();
}
Bean 的作用域
五种作用域
| 作用域 | 描述 | 使用场景 |
|---|---|---|
| singleton | 单例,容器中只存在一个实例(默认) | 无状态的服务类 |
| prototype | 原型,每次获取都创建新实例 | 有状态的命令对象 |
| request | 每次 HTTP 请求创建一个实例 | 请求级数据 |
| session | 同一个 HTTP Session 共享一个实例 | 会话级数据 |
| application | ServletContext 生命周期内共享一个实例 | 应用级数据 |
作用域配置
// 单例(默认)
@Scope("singleton")
public class SingletonBean {
// ...
}
// 原型
@Scope("prototype")
public class PrototypeBean {
// ...
}
// 使用 ConfigurableBeanFactory.SCOPE_SINGLETON 常量
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class PrototypeBean {
// ...
}
XML 配置:
<bean id="singletonBean" class="com.example.bean.SingletonBean" scope="singleton"/>
<bean id="prototypeBean" class="com.example.bean.PrototypeBean" scope="prototype"/>
作用域注意事项
原型 Bean 在依赖注入到单例 Bean 时需要注意:
@Service
public class SingletonService {
@Autowired
private ApplicationContext context;
public void usePrototypeBean() {
// 每次使用时都从容器获取新实例
PrototypeBean prototype = context.getBean(PrototypeBean.class);
// 使用 prototype...
}
}
// 方式2:使用 ObjectFactory
@Service
public class SingletonService {
@Autowired
private ObjectFactory<PrototypeBean> prototypeBeanFactory;
public void usePrototypeBean() {
PrototypeBean prototype = prototypeBeanFactory.getObject();
// 使用 prototype...
}
}
// 方式3:使用 @Lookup 注解(推荐)
@Service
public abstract class SingletonService {
@Lookup
public abstract PrototypeBean getPrototypeBean();
public void usePrototypeBean() {
PrototypeBean prototype = getPrototypeBean();
// 使用 prototype...
}
}
作用域代理
@Component
@Scope(
value = WebApplicationContext.SCOPE_REQUEST,
proxyMode = ScopedProxyMode.TARGET_CLASS
)
public class RequestScopedBean {
// 请求作用域
}
@Service
public class SingletonService {
@Autowired
private RequestScopedBean requestBean; // 会自动使用代理
// 每次调用 requestBean 的方法时都会获取当前请求的实例
}
补充说明
@Lazy 注解 (延迟初始化)
@Configuration
public class AppConfig {
@Bean
@Lazy // 延迟加载,第一次使用时才初始化
public ExpensiveBean expensiveBean() {
return new ExpensiveBean();
}
}
全局延迟初始化:
<!-- 所有 Bean 都延迟初始化 -->
<beans default-lazy-init="true">
<!-- ... -->
</beans>
@Conditional 注解
// 自定义条件
public class DatabaseCondition implements Condition {
/**
* `matches()` 方法返回 `true` 时,对应的 Bean 才会被注册
* 通过 `ConditionContext` 获取环境信息、类加载器、BeanFactory 等
* 通过 `AnnotatedTypeMetadata` 获取注解的元数据信息
*
* # application-dev.properties
* database.type=h2
* # application-prod.properties
* database.type=mysql
* 当配置 database.type=mysql 时,mysqlDataSource() 才会被注册。
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
String dbType = context.getEnvironment().getProperty("database.type");
return "mysql".equals(dbType);
}
}
@Configuration
public class AppConfig {
@Bean
@Conditional(DatabaseCondition.class)
public DataSource mysqlDataSource() {
return new MysqlDataSource();
}
// 只要有 cache.enabled 属性就创建
// 属性不存在时也创建(默认开启)@ConditionalOnProperty(name = "cache.enabled", matchIfMissing = true)
// 支持多个属性值
//@ConditionalOnProperty(name = "cache.type", havingValue = "redis")
@Bean
@ConditionalOnProperty(name = "cache.enabled", havingValue = "true")
public CacheManager cacheManager() {
return new RedisCacheManager();
}
//检查类路径中是否存在指定的类
@Bean
@ConditionalOnClass(name = "com.mongodb.MongoClient")
public MongoClient mongoClient() {
return new MongoClient();
}
@Bean
@ConditionalOnMissingBean(DataSource.class)
public DataSource defaultDataSource() {
return new HikariDataSource();
}
}
@Profile 注解(环境配置)
@Configuration
@Profile("development")
public class DevConfig {
@Bean
public DataSource dataSource() {
return new EmbeddedDatabaseBuilder()
.setType(EmbeddedDatabaseType.H2)
.build();
}
}
@Configuration
@Profile("production")
public class ProdConfig {
@Bean
public DataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUrl("jdbc:mysql://prod-db:3306/app");
dataSource.setUsername("app");
dataSource.setPassword("${db.password}");
return dataSource;
}
}
// 激活 profile
// 方式1:JVM 参数
// -Dspring.profiles.active=production
// 方式2:环境变量
// export SPRING_PROFILES_ACTIVE=production
// 方式3:代码激活
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.getEnvironment().setActiveProfiles("production");
context.register(AppConfig.class);
context.refresh();
自动装配策略
// byType(默认)
@Autowired
private UserService userService; // 按类型查找
// byName
@Resource(name="userService")
private UserService userService; // 按名称查找
// @Qualifier 指定 Bean 名称
@Autowired
@Qualifier("userServiceImpl")
private UserService userService;
// @Primary 主要候选者
@Configuration
public class Config {
@Bean
@Primary
public UserService primaryUserService() {
return new PrimaryUserServiceImpl();
}
@Bean
public UserService secondaryUserService() {
return new SecondaryUserServiceImpl();
}
}
循环依赖
// 构造器注入 - 不支持循环依赖
@Service
public class ServiceA {
private final ServiceB serviceB;
public ServiceA(ServiceB serviceB) {
this.serviceB = serviceB;
}
}
@Service
public class ServiceB {
private final ServiceA serviceA;
public ServiceB(ServiceA serviceA) {
this.serviceA = serviceA;
}
}
// setter/字段注入 - 支持(通过三级缓存处理)
@Service
public class ServiceA {
@Autowired
private ServiceB serviceB;
}
@Service
public class ServiceB {
@Autowired
private ServiceA serviceA;
}
循环依赖在 [[Ioc_Container]]中有进行说明解释
外部化配置
//方法一 @Value 注入
@Value("${jdbc.url}")
private String url;
//方法二 类型安全的配置
@Configuration
@ConfigurationProperties(prefix = "database")
public class DatabaseConfig {
}
写在最后
Spring Bean 虽然是基础概念,但其设计理念体现了依赖注入、控制反转、面向切面编程等核心思想。深入理解 Bean,不仅有助于日常开发,更能帮助你理解 Spring 的设计哲学,提升架构思维。
希望本文能够帮助你全面掌握 Spring Bean,从配置到实践,从会用到精通。如有疑问或建议,欢迎在评论区交流讨论!
更多推荐


所有评论(0)