Spring Bean的生命周期

实例化bean对象 -> 设置对象属性 -> 检查一系列Aware接口并设置相关依赖 -> BeanPostProcessor接口的前置处理 -> InitializingBean接口的afterPropertiesSet方法 -> init-method -> BeanPostProcessor接口的后置处理 -> bean准备就绪 -> DisposableBean接口destory方法 -> destory-method

1. 初始化bean

   容器通过获取BeanDefinition中的信息进行实例化，这一步仅仅是简单的实例化，并没有进行依赖注入。

   实例化的对象被包装在BeanWrapper对象中，BeanWrapper提供了设置对象属性的接口，从而避免了使用反射机制来注入属性。

2. 设置对象属性（依赖注入）

   实例化后的Bean仍是一个原生状态，然后Spring根据BeanDefinition中的信息进行依赖注入，并且通过BeanWrapper提供的设置属性的接口完成依赖注入。

3. 注入Aware接口

   Spring会检测该对象是否实现了xxxAware接口，并将相关的xxxAware实例注入给bean

   • BeanNameAware 通过Bean的引用来获取Bean的ID
   • BeanFactoryAware 获取Spring BeanFactory容器
   • ApplicationContextAwaer 获取Spring ApplicationContext容器

4. BeanPostProcessor前置处理

   如果Spring实现了BeanPostProcessor接口，将调用它的 postProcessBeforeInitialization(Object bean, String beanName) 方法对Bean增强处理。如对Bean进行修改，增加某个功能。

5. InitializingBean接口

   InitializingBean接口有一个方法：afterPropertiesSet() 作用是在bean正式构造完成前增加我们自己自定义的逻辑，与前置处理不同，该函数的入参没有bean对象， 因为无法处理bean对象本身，只能增加一些额外的逻辑。

6. init-method 声明，作用同InitializingBean接口

7. BeanPostProcessor后置处理

   如果Spring实现了BeanPostProcessor接口，将调用它的 postProcessAfterInitialization(Object bean, String beanName) 和4一样，只不过6是在Bean初始化前执行的，而这个是在Bean初始化后执行的，时机不同

8. bean初始化完成，经过以上的工作后，Bean将一直驻留在应用上下文中给应用使用，直到应用上下文被销毁

9. DispostbleBean接口，DispostbleBean接口只有一个函数：destroy()，在bean被销毁前执行此函数里的逻辑。

10. destroy-method声明，作用同DispostbleBean接口

测试代码

public class Person implements BeanNameAware, BeanFactoryAware,
        ApplicationContextAware, InitializingBean, DisposableBean {

    private String name;

    public Person() {
        System.out.println("调用默认构造器实例化对象...");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("调用Setter方法设置属性...");
        this.name = name;
    }

    public void initMethod() {
        System.out.println("执行init-method声明逻辑...");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware 获取BeanFactory -> " + beanFactory.hashCode());
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("BeanNameAware 获取beanName -> " + name);
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("执行DisposableBean逻辑...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("执行InitializingBean逻辑...");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("ApplicationContextAware 获取applicationContext -> " + applicationContext.hashCode());
    }
}

自定义BeanPostProcessor

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor前置处理，" + beanName + " -> " + bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor后置处理，" + beanName + " -> " + bean);
        return bean;
    }
}

配置类

@Configuration
public class AppConfig {

    @Bean
    public MyBeanPostProcessor myBeanPostProcessor() {
        return new MyBeanPostProcessor();
    }

    @Bean
    public Person person() {
        Person person = new Person();
        person.setName("biubiu");
        return person;
    }
}

@Test
void liftCycle() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    context.registerShutdownHook();
}

结果

调用默认构造器实例化对象...
调用Setter方法设置属性...
BeanNameAware 获取beanName -> biubiu
BeanFactoryAware 获取BeanFactory -> 1498621286
ApplicationContextAware 获取applicationContext -> 761973299
BeanPostProcessor前置处理，person -> Person{name='biubiu'}
执行InitializingBean逻辑...
BeanPostProcessor后置处理，person -> Person{name='biubiu'}
执行DisposableBean逻辑...
执行DisposableBean逻辑...