spring03 Bean的生命周期

Bean 的生命周期

graph LR 创建 --> 依赖注入 依赖注入 --> 初始化 初始化 --> 可用 可用 --> 销毁

点击查看代码

    @Autowired
    public void autowired(@Value("${JAVA_HOME}")String home){
        log.info("依赖注入{}",home);
    }

    @PostConstruct
    public void init(){
        log.info("初始化前");
    }

    @PreDestroy
    public void destroy(){
        log.info("销毁前");
    }

创建前后的增强

• postProcessBeforeInstantiation
  • 这里返回的对象若不为 null 会替换掉原本的 bean，并且仅会走 postProcessAfterInitialization 流程
• postProcessAfterInstantiation
  • 这里如果返回 false 会跳过依赖注入阶段

依赖注入前的增强

• postProcessProperties
  • 如 @Autowired、@Value、@Resource

初始化前后的增强

• postProcessBeforeInitialization
  • 这里返回的对象会替换掉原本的 bean
  • 如 @PostConstruct、@ConfigurationProperties
• postProcessAfterInitialization
  • 这里返回的对象会替换掉原本的 bean
  • 如代理增强

销毁之前的增强

• postProcessBeforeDestruction
  • 如 @PreDestroy

点击查看代码

@Component
@Slf4j(topic = "MyBeanPostProcessors")
public class MyBeanPostProcessors implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor {
    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        if (bean.getClass() == BeanS03.class) {
            log.info("<<<<<< 销毁之前执行, 如 @PreDestroy");
        }
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanName.equals("beanS03")) {
            log.info("<<<<<< 实例化之前执行, 这里返回的对象会替换掉原本的 bean");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if (beanName.equals("beanS03")) {
            log.info("<<<<<< 实例化之后执行, 这里如果返回 false 会跳过依赖注入阶段");
//            return false;
        }
        return true;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if (beanName.equals("beanS03")) {
            log.info("<<<<<< 依赖注入阶段执行, 如 @Autowired、@Value、@Resource");
        }
        return pvs;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("beanS03")) {
            log.info("<<<<<< 初始化之前执行, 这里返回的对象会替换掉原本的 bean, 如 @PostConstruct、@ConfigurationProperties");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("beanS03")) {
            log.info("<<<<<< 初始化之后执行, 这里返回的对象会替换掉原本的 bean, 如代理增强");
        }
        return bean;
    }
}

模板方法设计模式
模板设计模式, 指大流程已经固定好了, 通过接口回调（bean 后处理器）在一些关键点前后提供扩展

点击查看代码

 public static void main(String[] args) {
        MyBeanS03 myBeanS03 = new MyBeanS03();
        myBeanS03.addMyTemplateMethod(object -> System.out.println("注入 @Autowired"));
        myBeanS03.getBean();
    }

    static class MyBeanS03{
        private List<BeanPostProcessor> beanPostProcessors = new ArrayList<>();
        public void getBean(){
            Object o = new Object();
            System.out.println("创建" + o);
            System.out.println("依赖注入" + o);
            for (BeanPostProcessor beanPostProcessor : beanPostProcessors) {
                beanPostProcessor.inject(o);
            }
            System.out.println("初始化");
        }
        public void addMyTemplateMethod(BeanPostProcessor beanPostProcessor){
           beanPostProcessors.add(beanPostProcessor);
        }
    }
    static interface BeanPostProcessor{
        void inject(Object object);
    }

bean 后处理器排序

点击查看代码

    @Order(1)
    static class P1 implements BeanPostProcessor {
        private static final Logger log = LoggerFactory.getLogger(P1.class);

        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            log.debug("postProcessBeforeInitialization @Order(1)");
            return bean;
        }
    }

    @Order(2)
    static class P2 implements BeanPostProcessor {
        private static final Logger log = LoggerFactory.getLogger(P2.class);

        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            log.debug("postProcessBeforeInitialization @Order(2)");
            return bean;
        }

    }

    static class P3 implements BeanPostProcessor, PriorityOrdered {
        private static final Logger log = LoggerFactory.getLogger(P3.class);

        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            log.debug("postProcessBeforeInitialization PriorityOrdered");
            return bean;
        }

        @Override
        public int getOrder() {
            return 100;
        }
    }

    static class P4 implements BeanPostProcessor, Ordered {
        private static final Logger log = LoggerFactory.getLogger(P4.class);

        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            log.debug("postProcessBeforeInitialization Ordered");
            return bean;
        }

        @Override
        public int getOrder() {
            return 0;
        }
    }

    static class P5 implements BeanPostProcessor {
        private static final Logger log = LoggerFactory.getLogger(P5.class);

        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            log.debug("postProcessBeforeInitialization");
            return bean;
        }
    }

顺序

  1. 实现了 PriorityOrdered 接口的优先级最高
  2. 实现了 Ordered 接口（默认 Order 值为 0）与加了 @Order 注解的平级, Order 值越小优先级越高，相同值先加载的优先级高
  3. 其它的排在最后