spring Bean的生命周期

1.什么是Bean？

在 Spring 框架中，Bean 是由 Spring 容器管理的对象。Bean 可以是普通的 Java 对象（pojo)，也可以是服务类、数据访问对象(DAO)、控制器等各种类型的组件。Spring 通过配置文件（如 XML 文件）、Java 配置类或者注解的方式来定义和管理这些 Bean。

2.Spring如何管理Bean的生命周期

在Spring框架中，Bean的生命周期是Spring IoC（控制反转）容器管理的核心部分，它涵盖了Bean从创建到销毁的整个过程。Bean的生命周期是从 Bean 实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中，这个过程被称为Spring Bean的生命周期。下面是具体的对整个生命周期进行逐步解析。

一、Bean的定义和创建

Spring框架可以通过多种方式创建和定义Bean。

1.通过 XML 配置文件定义 Bean；

<?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 id="UserService" class="com.ape.UserServiceImpl">
        <!-- 可以在这里通过Set或构造方法注入属性值 -->
    </bean>

</beans>

2.Spring通过注解如@Component、@Service、@Repository等自动识别并注册Bean；

@Service
public class UserService {
    
}

3.通过配置类定义；

@Configuration
public class SpringConfig {

    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
}

二、Bean的实例化过程

在这个阶段，Spring容器根据Bean的定义信息创建Bean的实例。这通常是通过Java的new关键字调用Bean的构造方法完成的。如果Bean是通过工厂方法创建的，则调用相应的工厂方法。

public class MyBean {  
    public MyBean() {  
        System.out.println("创建这个Bean");  
    }  
}

三、属性赋值阶段

在Bean实例化之后，Spring容器会根据配置文件或注解中的信息，将Bean的属性值或依赖的Bean注入到当前Bean中。这包括通过setter方法注入、构造方法注入、字段注入等方式。

public class StudentBean {  
    private String name;  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    // ...  
}  
  
// XML中注入属性  
<bean id="StudentBean " class="com.ape.StudentBean">  
    <property name="name" value="sname"/>  
</bean>  
  
// 注解方式注入属性  
@Component  
public class StudentBean {  
    @Value("sname")  
    private String name;  
    // ...  
}

四、Bean 的初始化过程

初始化阶段是Bean生命周期中最复杂的阶段之一，它包含了多个子阶段。

Aware接口回调：如果Bean实现了Spring的某些Aware接口（如BeanNameAware、BeanFactoryAware、ApplicationContextAware等），则容器会回调这些接口的方法，使Bean能够感知到容器和容器中的其他Bean。

@Component  
public class StudentBean implements BeanNameAware {  
    @Override  
    public void setBeanName(String name) {  
        System.out.println("Bean name is " + name);  
    }  
    // ...  
}

初始化回调：
1.BeanPostProcessor的postProcessBeforeInitialization方法：在Bean的初始化回调之前调用，可以修改Bean的属性或执行一些前置操作。
2.InitializingBean接口的afterPropertiesSet方法：如果Bean实现了InitializingBean接口，则Spring会调用其afterPropertiesSet方法。
3.@PostConstruct注解的方法：如果Bean中有使用@PostConstruct注解的方法，Spring会在依赖注入完成后调用该方法。
4.BeanPostProcessor的postProcessAfterInitialization方法：在Bean的初始化回调之后调用，可以对Bean进行进一步的加工或检查。

@Component  
public class StudentBean implements InitializingBean {  
  
    @PostConstruct  
    public void init() {  
        System.out.println("Bean is going through init method with @PostConstruct");  
    }  
  
    @Override  
    public void afterPropertiesSet() throws Exception {  
        System.out.println("Bean is going through afterPropertiesSet method");  
    }  
  
    // ...  
}  
  
// BeanPostProcessor实现  
public class MyBeanPostProcessor implements BeanPostProcessor {  
    // ...  
    @Override  
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {  
        // 前置处理逻辑  
        return bean;  
    }  
  
    @Override  
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  
        // 后置处理逻辑  
        return bean;  
    }  
}

五、 使用阶段

在完成所有初始化阶段后，Bean进入使用阶段。在这个阶段，Bean已经被完全初始化并准备好被应用程序使用。这是应用程序逻辑使用和操作Bean的主要时间段。

ApplicationContext context = new AnnotationConfigApplicationContext(applicationContext.class);  
StudentBean studentBean = context.getBean(StudentBean.class);  

六、销毁阶段

当Spring容器关闭时，如果Bean实现了DisposableBean接口，或者使用了@PreDestroy注解标记了销毁方法，则Spring会调用这些方法以执行必要的清理操作，如释放资源、关闭连接等。

@Component  
public class StudentBean implements DisposableBean {  
  
    @PreDestroy  
    public void destroy() {  
        System.out.println("Bean将被销毁");  
    }  
  
    @Override  
    public void destroy() throws Exception {  
        // 清理逻辑  
    }  
  
    // ...  
}

3.总结

Spring Bean 的生命周期是一种复杂却强大的机制，它使得开发者能够在 Bean 的创建、初始化、使用以及销毁等各个阶段嵌入自定义逻辑。而 Bean 后处理器正是这一机制的关键扩展点，开发者通过实现 BeanPostProcessor 接口，能够在无需修改 Bean 实现代码的前提下，对 Bean 的生命周期实施更为精细的控制。这让 Spring 框架变得更为灵活且强大，足以应对各类复杂的业务需求。