遇到面试官问bean生命周期，让我回答bean生命周期中调用的接口和方法，给我整蒙了
没办法，老老实实学习和记录一下。
目录
对于普通的java对象，通过new方法创建的对象，当没有引用时被垃圾回收机制回收。
而SpringBean对象，Spring会扫描指定包下面的Java类，然后将其变成beanDefinition对象，然后Spring会根据beanDefinition来创建bean，它们的生命周期完全由容器控制。
一、生命周期流程、
实例化 -> 属性赋值 -> 初始化 -> 销毁
- 调用 Bean 构造方法或工厂方法实例化 Bean
- 利用依赖注入完成 Bean 中所有属性值的配置注入
- 如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值
- 如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用
- 如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用
- 如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP 就是利用它实现的
- 如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法
- 如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法
- 如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了
- 如果在<bean> 中指定了该 Bean 的作用范围为 scope=“singleton”，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在 中指定了该 Bean 的作用范围为 scope=“prototype”，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean
- 如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁
二、接口方法分类
| 类型 | 描述 |
|---|---|
| Bean自身的方法 | 包括了Bean本身调用的方法和通过配置文件中的init-method和destroy-method指定的方法 |
| Bean级生命周期接口方法 | 包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法 |
| 容器级生命周期接口方法 | 包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现的方法，一般称它们的实现类为“后处理器”。 |
| 工厂后处理器接口方法 | 括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法 |
三、演示
1. 调用Bean自身的方法和Bean级生命周期接口方法
public class UserBean implements BeanFactoryAware, BeanNameAware,
InitializingBean, DisposableBean {
private String name;//名称
private BeanFactory beanFactory;
private String beanName;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("传入当前工厂实例");
this.beanFactory = beanFactory;
}
@Override
public void setBeanName(String s) {
System.out.println("传入当前 Bean 的 id 值："+s);
this.beanName =s;
}
@Override
public void destroy() throws Exception {
System.out.println("实现Bean级生命周期接口接口的destroy()");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("实现Bean级生命周期接口的afterPropertiesSet()");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void myInit() {
System.out.println("调用<bean>的init-method属性指定的方法");
}
public void myDestory() {
System.out.println("调用<bean>的destroy-method属性指定的方法");
}
}
2.实现BeanPostProcessor接口
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("预初始化方法对"+bean+"进行加工");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("后初始化方法对"+bean+"进行加工");
return bean;
}
}
3. 实现InstantiationAwareBeanPostProcessor接口
InstantiationAwareBeanPostProcessor本质上是BeanPostProcessor的子接口
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
public MyInstantiationAwareBeanPostProcessor(){
System.out.println("这是InstantiationAwareBeanPostProcessorAdapter实现类构造器");
}
//实例化Bean之前调用
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("实例化前调用InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization（）");
return bean;
}
//实例化Bean之后调用
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("实例化后调用InstantiationAwareBeanPostProcessor.postProcessAfterInitialization（）");
return bean;
}
//设置某个属性时调用
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
System.out.println("设置"+pvs.toString()+"属性时调用InstantiationAwareBeanPostProcessor的postProcessProperties（）");
return pvs;
}
}
4.工厂后处理器接口
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public MyBeanFactoryPostProcessor(){
System.out.println("实例化MyBeanFactoryPostProcessor构造器");
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
System.out.println("调用BeanFactoryPostProcessor.postProcessBeanFactory（）");
BeanDefinition bd = configurableListableBeanFactory.getBeanDefinition("userBean");
System.out.println("实例化Bean:"+bd.toString());
bd.getPropertyValues().addPropertyValue("name", "测试后工厂方法");
System.out.println("注入属性:"+bd.getPropertyValues().getPropertyValues());
}
}
5. 配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<bean id="beanPostProcessor" class="com.tung.MyBeanPostProcessor">
</bean>
<bean id="instantiationAwareBeanPostProcessor" class="com.tung.MyInstantiationAwareBeanPostProcessor">
</bean>
<bean id="beanFactoryPostProcessor" class="com.tung.MyBeanFactoryPostProcessor">
</bean>
<bean id="userBean" class="com.tung.UserBean" init-method="myInit"
destroy-method="myDestory" scope="singleton" p:name="张三"/>
</beans>
6.测试
public class BeanLifeCycle {
public static void main(String[] argss){
System.out.println("初始化容器");
ApplicationContext factory = new ClassPathXmlApplicationContext("/beans.xml");
System.out.println("容器初始化成功");
UserBean userBean = factory.getBean("userBean",UserBean.class);
System.out.println(userBean);
System.out.println("开始关闭容器");
((ClassPathXmlApplicationContext)factory).registerShutdownHook();
}
}
结果
