Spring注解驱动开发--bean的生命周期

前言

　　bean的生命周期指的是 bean 的创建、初始化和销毁的过程。bean的创建是由容器完成的，但我们可以通过多种方式自定义bean的初始化和销毁的方法：容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法。

自定义初始化和销毁方法

     ① 通过@Bean指定init-method和destroy-method指定初始化和销毁方法；

@ComponentScan("com.atneusoft.bean")
@Configuration
public class MainConfigOfLifeCycle {
    
    @Bean(initMethod="init",destroyMethod="detory")
    public Car car(){
        return new Car();
    }

}

　  同下

  class="com.atneusoft.bean.Person"  scope="prototype" destroy-method=""  init-method=""> 

 

　 ② 通过让Bean实现相关接口

                      InitializingBean（定义初始化逻辑），
                      DisposableBean（定义销毁逻辑）;

public class Cat implements InitializingBean, DisposableBean {

    public Cat() {
        System.out.println("Cat constructor...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("cat afterPropertiesSet....");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("cat destroy....");
    }
}

 

     ③可以使用JSR250注解指定具体的方法

         　　　　@PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
         　　　　@PreDestroy：在容器销毁bean之前通知我们进行清理工作    

public class Car{

    public Cat() {
        System.out.println("Cat constructor...");
    }


    @PostConstruct
    public void init() {
        System.out.println("cat 。。construct ...初始化之后。。。。。");
    }

    @PreDestroy
    public void  destroy(){
        System.out.println("cat  destroy 之前");
    }
}

BeanPostProcessor 接口

　　　  可以通过上面提到的三种方式进行bean的初始化方法

     　　 bean的后置处理器： 在bean初始化前后进行一些处理工作
       　　　　　　  postProcessBeforeInitialization:在初始化之前工作
        　　　　　　 postProcessAfterInitialization:在初始化之后工作

          注意：自定义bean的后置处理器将作用于所有的bean初始化前后，而bean的初始化方法只作用于当前bean

public class MyPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization " + beanName +"===>" + bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization " + beanName +"===>" + bean);
        return bean;
    }
}

public interface BeanPostProcessor {

    /**
     * Apply this {@code BeanPostProcessor} to the given new bean instance before any bean
     * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
     * or a custom init-method). The bean will already be populated with property values.
     * The returned bean instance may be a wrapper around the original.
     * 
The default implementation returns the given {@code bean} as-is.
     * @param bean the new bean instance
     * @param beanName the name of the bean
     * @return the bean instance to use, either the original or a wrapped one;
     * if {@code null}, no subsequent BeanPostProcessors will be invoked
     * @throws org.springframework.beans.BeansException in case of errors
     * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
     */
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    /**
     * Apply this {@code BeanPostProcessor} to the given new bean instance after any bean
     * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
     * or a custom init-method). The bean will already be populated with property values.
     * The returned bean instance may be a wrapper around the original.
     * 
In case of a FactoryBean, this callback will be invoked for both the FactoryBean
     * instance and the objects created by the FactoryBean (as of Spring 2.0). The
     * post-processor can decide whether to apply to either the FactoryBean or created
     * objects or both through corresponding {@code bean instanceof FactoryBean} checks.
     * 
This callback will also be invoked after a short-circuiting triggered by a
     * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,
     * in contrast to all other {@code BeanPostProcessor} callbacks.
     * 
The default implementation returns the given {@code bean} as-is.
     * @param bean the new bean instance
     * @param beanName the name of the bean
     * @return the bean instance to use, either the original or a wrapped one;
     * if {@code null}, no subsequent BeanPostProcessors will be invoked
     * @throws org.springframework.beans.BeansException in case of errors
     * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
     * @see org.springframework.beans.factory.FactoryBean
     */
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

}

Bean的后置处理器的原理

自定义的bean的后置处理器，将自定义好的处理器置于容器当中，postProcessBeforeInitialization 方法处打断点，启动注解的方式spring容器，跟踪方法调用栈如下

@Configuration
public class PostProcessConfig {

    @Bean
    public MyPostProcessor myPostProcessor(){
        return new MyPostProcessor();
    }
}

 

@Test
    void Test01() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(PostProcessConfig.class);
        Cat cat = applicationContext.getBean(Cat.class);
        applicationContext.close();
        System.out.println(cat);
    }

调用栈如下

 

 

创建bean的关键代码如下

      try {
            populateBean(beanName, mbd, instanceWrapper);//为bean的各种属性赋值，在bean的始化之前完成
            exposedObject = initializeBean(beanName, exposedObject, mbd);//初始化bean，
        }

初始化bean方法如下

    protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction