spring bean 生命周期

@Bean指定初始化和销毁方法

@Component
public class Car {
  public Car(){
     System.out.println("car constructor...");
  }
  
  public void init(){
     System.out.println("car ... init...");
  }
  
  public void detory(){
     System.out.println("car ... detory...");
  }
}

/**
 * bean的生命周期：
 *     bean创建---初始化----销毁的过程
 * 容器管理bean的生命周期；
 * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
 * 
 * 构造（对象创建）
 *     单实例：在容器启动的时候创建对象
 *     多实例：在每次获取的时候创建对象\
 * 初始化：
 *     对象创建完成，并赋值好，调用初始化方法。。。
 * 销毁：
 *     单实例：容器关闭的时候
 *     多实例：容器不会管理这个bean；容器不会调用销毁方法；
 * 
 * 1）、指定初始化和销毁方法；
 *     通过@Bean指定init-method和destroy-method；
 */
@ComponentScan("com.atguigu.bean")
@Configuration
public class MainConfigOfLifeCycle {
  //@Scope("prototype")
  @Bean(initMethod="init",destroyMethod="detory")
  public Car car(){
     return new Car();
  }
}

测试类

public class IOCTest_LifeCycle {
  
  @Test
  public void test01(){
     //1、创建ioc容器
     AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
     System.out.println("容器创建完成...");
     //applicationContext.getBean("car");
     //关闭容器
     applicationContext.close();
  }
 
}

InitializingBean和DisposableBean

@Component
public class Cat implements InitializingBean,DisposableBean {
  public Cat(){
     System.out.println("cat constructor...");
  }
  @Override
  public void destroy() throws Exception {
     // TODO Auto-generated method stub
     System.out.println("cat...destroy...");
  }
  @Override
  public void afterPropertiesSet() throws Exception {
     // TODO Auto-generated method stub
     System.out.println("cat...afterPropertiesSet...");
  }
}

/**
 * 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
 *          DisposableBean（定义销毁逻辑）;
 */
@ComponentScan("com.atguigu.bean")//采用包扫描方式
@Configuration
public class MainConfigOfLifeCycle {
 
}

测试类

public class IOCTest_LifeCycle {
  
  @Test
  public void test01(){
     //1、创建ioc容器
     AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
     System.out.println("容器创建完成...");
     
     //applicationContext.getBean("car");
     //关闭容器
     applicationContext.close();
  }
}

@PostConstruct&@PreDestroy

@Component
public class Dog{
  
  public Dog(){
     System.out.println("dog constructor...");
  }
  
  //对象创建并赋值之后调用
  @PostConstruct
  public void init(){
     System.out.println("Dog....@PostConstruct...");
  }
  
  //容器移除对象之前
  @PreDestroy
  public void detory(){
     System.out.println("Dog....@PreDestroy...");
  }
}

/**
 * 3）、可以使用JSR250；
 *     @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
 *     @PreDestroy：在容器销毁bean之前通知我们进行清理工作
 */
@ComponentScan("com.atguigu.bean")
@Configuration
public class MainConfigOfLifeCycle {
 
}

测试类

public class IOCTest_LifeCycle {
  
  @Test
  public void test01(){
     //1、创建ioc容器
     AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
     System.out.println("容器创建完成...");
     
     //applicationContext.getBean("car");
     //关闭容器
     applicationContext.close();
  }
}

BeanPostProcessor-后置处理器

/**
 * 后置处理器：初始化前后进行处理工作
 * 将后置处理器加入到容器中
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
     // TODO Auto-generated method stub
     System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
     return bean;
  }
 
  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
     // TODO Auto-generated method stub
     System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
     return bean;
  }
}

/**
 * BeanPostProcessor.postProcessBeforeInitialization
 * 初始化：
 *     对象创建完成，并赋值好，调用初始化方法。。。
 * BeanPostProcessor.postProcessAfterInitialization
 
 * 4）、BeanPostProcessor【interface】：bean的后置处理器；
 *     在bean初始化前后进行一些处理工作；
 *     postProcessBeforeInitialization:在初始化之前工作
 *     postProcessAfterInitialization:在初始化之后工作
 */
@ComponentScan("com.atguigu.bean")
@Configuration
public class MainConfigOfLifeCycle {
  
  //@Scope("prototype")
  @Bean(initMethod="init",destroyMethod="detory")
  public Car car(){
     return new Car();
  }
}

BeanPostProcessor原理

 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
 
 BeanPostProcessor原理
 populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
 initializeBean
 {
 	applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 	invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
 	applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}

BeanPostProcessor在Spring底层的使用

Spring底层对 BeanPostProcessor 的使用；
bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx BeanPostProcessor;
ApplicationContextAware

@Component
public class Dog implements ApplicationContextAware {
  //@Autowired
  private ApplicationContext applicationContext;
  public Dog(){
     System.out.println("dog constructor...");
  }
  //对象创建并赋值之后调用
  @PostConstruct
  public void init(){
     System.out.println("Dog....@PostConstruct...");
  }
  //容器移除对象之前
  @PreDestroy
  public void detory(){
     System.out.println("Dog....@PreDestroy...");
  }
  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
     // TODO Auto-generated method stub
     this.applicationContext = applicationContext;
  }
}