Spring笔记(2) - 生命周期/属性赋值/自动装配及部分源码解析

一.生命周期

1. @Bean自定义初始化和销毁方法

   //====xml方式： init-method和destroy-method====
       class="com.hrh.bean.Person" scope="singleton" init-method="" destroy-method="">
           
           
       
   //====@Bean方式====
   /**
    *单实例：只调用initMethod一次，容器关闭时会调用destroyMethod
    *多实例: 每次调用Bean都调用initMethod，容器关闭不会调用destroyMethod，需要手动调用
    **/
       @Bean(initMethod = "",destroyMethod = "")
       public Person person() {
           System.out.println("注入容器。。。。。");
           return new Person("张三", 20);
       }
   //====实现接口方式====
   /**
    * InitializingBean：定义初始化逻辑，实现afterPropertiesSet()
    * DisposableBean：定义销毁逻辑，实现destroy()
    */
   @Component
   public class Person implements InitializingBean, DisposableBean {
       public Person(){
           System.out.println("Person 。。。 constructor");
       }
   
       @Override
       public void afterPropertiesSet() throws Exception {
           System.out.println("Person 。。。afterPropertiesSet");
       }
   
       @Override
       public void destroy() throws DestroyFailedException {
           System.out.println("Person 。。。destroy");
       }
   }
   @Configurable
   @ComponentScan(value = "com.hrh")
   public class BeanConfig {}
   
   AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
   context.close();

2. @PostConstruct和@PreDestroy

   /**
    * JSR250:
    *  @PostConstruct: 在bean创建完成并且属性赋值完成后，来执行初始化方法
    *  @PreDestroy ：在容器销毁bean之前通知进行清理工作
    */
   @Component
   public class Color {
       public Color() {
           System.out.println("Color 。。。 constructor");
       }
   
       @PostConstruct//对象创建并赋值之后调用
       public void init() throws Exception {
           System.out.println("Color 。。。init");
       }
   
       @PreDestroy//容器移除对象之前
       public void destroy() {
           System.out.println("Color 。。。destroy");
       }
   }

3.  BeanPostProcessor：bean后置处理器，对bean初始化之前和之后的处理，上文的@PostConstruct和@PreDestroy就是使用了该类实现的

       @Component
       public class MyBeanPostProcessor implements BeanPostProcessor {
           /**
            *
            * @param bean 容器创建的实例
            * @param beanName 容器创建实例的名字
            * @return 创建的实例或进行包装后的实例
            * @throws BeansException
            */
           @Override
           public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
               System.out.println("postProcessBeforeInitialization====>【"+bean+"】："+beanName);
               return bean;
           }
       
           @Override
           public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
               System.out.println("postProcessAfterInitialization====>【"+bean+"】："+beanName);
               return bean;
           }
       }
       public static void main(String[] args) {
           AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
       }

   •  原理：从doCreateBean可以看到，在对bean进行属性赋值后，调用initializeBean初始化bean，在initializeBean中会在调用初始化方法前后会遍历所有的BeanPostProcessor实现的方法

         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
         public AnnotationConfigApplicationContext(Class... annotatedClasses) {
             ....
             refresh();//刷新容器
         }
         public void refresh() throws BeansException, IllegalStateException {
             ...
             //初始化剩下所有的(非懒加载的）单实例对象
             finishBeanFactoryInitialization(beanFactory);
         }
         protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
             ...
             //初始化剩下所有的(非懒加载的）单实例对象
             beanFactory.preInstantiateSingletons();
         }
         public void preInstantiateSingletons() throws BeansException {
             ...
             getBean(beanName);
             ...
         }
         @Override
         public Object getBean(String name) throws BeansException {
             return doGetBean(name, null, null, false);
         }
         protected  T doGetBean(
                     final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
                     throws BeansException {
             ...
             //getSingleton获取实例
             sharedInstance = getSingleton(beanName, new ObjectFactory