前言

在 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 共享一个实例会话级数据
applicationServletContext 生命周期内共享一个实例应用级数据
作用域配置
// 单例(默认)
@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,从配置到实践,从会用到精通。如有疑问或建议,欢迎在评论区交流讨论!

Logo

汇聚全球AI编程工具,助力开发者即刻编程。

更多推荐