【79期】别找了,回答Spring中Bean的生命周期,这里帮你总结好了!

本人花费半年的时间总结的《Java面试指南》已拿腾讯等大厂offer,已开源在github ,欢迎star!

转载声明:转载请注明出处,本技术博客是本人原创文章

本文GitHub https://github.com/OUYANGSIHAI/JavaInterview 已收录,这是我花了6个月总结的一线大厂Java面试总结,本人已拿大厂offer,欢迎star

原文链接:blog.ouyangsihai.cn >> 【79期】别找了,回答Spring中Bean的生命周期,这里帮你总结好了!

点击上方“Java面试题精选”,关注公众号

面试刷图,查缺补漏

号外:****往期面试题,10篇为一个单位归置到本公众号菜单栏-面试题,有需要的欢迎翻阅。

这一节准备给大家讲解Spring 容器中的Bean的生命周期。这一节我个人觉得还是比较实用的,在实际工作当中经常会用到这些知识来解决一些非常棘手的问题。

ApplicationContext中Bean的生命周期

先来张图:

【79期】别找了,回答Spring中Bean的生命周期,这里帮你总结好了!

大家看到这张图肯定是一脸蒙蔽。不要着急,我来慢慢解释:从getBean(…)为触发点,Spring容器的Bean生命周期就经历了图中的生命周期,先分个类:

  • 图中绿色箭头的三个步骤(InstantiationAwareBeanPostProcessor)和粉红色箭头的两个步骤(BeanPostProcessor)为容器级的生命周期接口,当Spring每加载任何一个Bean到容器中时,这些接口都会起到如图中的几次调用。这两个处理器叫做"容器级后处理器",他们的影响是全局的,能够影响所有的Bean.
  • 图中大红色圆圈圈住的接口叫做"工厂级后处理器",类似的接口还有CustomEditorConfigurer,PropertyPlaceholderConfigurer等,这类接口只在上下文初始化的时候调用一次,其目的是完成一些配置文件的加工处理工作。
  • 剩下的就简单了,属于Bean级别的接口,专属于某个Bean所有,每个Bean实例化的时候调用自己特有的。
  • 值得一提的是,无论是”容器级后处理器”还是”工厂级后处理器”,他们都是可以配置多个的(如,配置两个BeanPostProcessor),如果想控制他们的调用顺序,实现一个org.springframework.core.Ordered接口即可。当然了,一般不用,一般一类后处理器只有一个即可。

    重点强调!:

    这些接口的调用顺序并不是一尘不变的,会随便Spring的版本变动而变动,大家要做的是万变不离其宗,知道能够通过这些接口在Bean初始化的时做一些属性上的操作。调用顺序要根据具体的版本来自己测试。下面我会给大家来列一个例子:

    
    public class Student implements BeanFactoryAware, BeanNameAware,
            InitializingBean, DisposableBean,ApplicationContextAware {
        private String name;
    
        public Student(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            System.out.println("BeanFactoryAware......");
        }
    
        @Override
        public void setBeanName(String s) {
            System.out.println("BeanNameAware......");
        }
    
        @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......");
        }
    }
    

    BeanFactoryPostProcessor:

    
    public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
        public MyBeanFactoryPostProcessor() {
            super();
            System.out.println("这是BeanFactoryPostProcessor实现类构造器!!");
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0)
                throws BeansException {
            System.out.println("BeanFactoryPostProcessor调用postProcessBeanFactory方法");
            BeanDefinition bd = arg0.getBeanDefinition("student");
            MutablePropertyValues propertyValues = bd.getPropertyValues();
            //配置文件中的信息在加载到Spring中后以BeanDefinition的形式存在.在这里又可以更改BeanDefinition,所以可以理解为更改配置文件里面的内容
    //        propertyValues.add("zdy","123");
        }
    
    }
    

    BeanPostProcessor:

    
    public class MyBeanPostProcessor implements BeanPostProcessor {
    
        public MyBeanPostProcessor() {
            super();
            System.out.println("这是BeanPostProcessor实现类构造器!!");
        }
    
        @Override
        public Object postProcessAfterInitialization(Object arg0, String arg1)
                throws BeansException {
            System.out.println("BeanPostProcessor接口方法After对属性进行更改!");
            return arg0;
        }
    
        @Override
        public Object postProcessBeforeInitialization(Object arg0, String arg1)
                throws BeansException {
            System.out.println("BeanPostProcessor接口方法Before对属性进行更改!");
            return arg0;
        }
    }
    

    InstantiationAwareBeanPostProcessorAdapter:

    
    public class MyInstantiationAwareBeanPostProcessor extends
            InstantiationAwareBeanPostProcessorAdapter {
    
        public MyInstantiationAwareBeanPostProcessor() {
            super();
            System.out.println("这是InstantiationAwareBeanPostProcessorAdapter实现类构造器!!");
        }
    
        // 接口方法、实例化Bean之前调用
        @Override
        public Object postProcessBeforeInstantiation(Class beanClass,
                                                     String beanName) throws BeansException {
            System.out.println("InstantiationAwareBeanPostProcessor调用Before方法");
            return null;
        }
    
        // 接口方法、实例化Bean之后调用
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName)
                throws BeansException {
            System.out.println("InstantiationAwareBeanPostProcessor调用Ater方法");
            return bean;
        }
    
        // 接口方法、设置某个属性时调用
        @Override
        public PropertyValues postProcessPropertyValues(PropertyValues pvs,
                                                        PropertyDescriptor[] pds, Object bean, String beanName)
                throws BeansException {
            System.out.println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
            return pvs;
        }
    }
    

    然后我们的Main方法:

    
    public class App 
    {
        public static void main( String[] args )
        {
    
            ApplicationContext ac =new ClassPathXmlApplicationContext("applicationContext.xml");
            Student stu = (Student) ac.getBean("student");
            stu.setName("wangwu");
        }
    }
    

    Spring文件最简单:(注意要把我们自己定义的处理器全部加到容器里去)

    
    ?xml version="1.0" encoding="UTF-8"?
    beans
        bean id="student" class="com.zdy.Student"
            constructor-arg value="zhangsan"/
        /bean
        bean id="myBeanFactoryPostProcessor" class="com.zdy.MyBeanFactoryPostProcessor"/bean
        bean id="myInstantiationAwareBeanPostProcessor" class="com.zdy.MyInstantiationAwareBeanPostProcessor"/bean
        bean id="myBeanPostProcessor" class="com.zdy.MyBeanPostProcessor"/bean
    /beans
    

    然后run一下子,看结果:

    
    这是BeanFactoryPostProcessor实现类构造器!!
    BeanFactoryPostProcessor调用postProcessBeanFactory方法
    这是InstantiationAwareBeanPostProcessorAdapter实现类构造器!!
    这是BeanPostProcessor实现类构造器!!
    InstantiationAwareBeanPostProcessor调用Before方法
    InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
    BeanNameAware......
    BeanFactoryAware......
    ApplicationContextAware......
    BeanPostProcessor接口方法Before对属性进行更改!
    InitializingBean......
    InstantiationAwareBeanPostProcessor调用Ater方法
    BeanPostProcessor接口方法After对属性进行更改!
    

    好了,其实大致流程就说完了,我大致针对Bean的生命周期说一下:Spring为了尽可能的把自己内部的东西机制暴露出来给用户使用,所以在Bean创建的过程中加了很多机制,通过所谓的”处理器”Processor暴露出来,然后处理器都有自己的顺序,我们需要做的就是定义好处理器的逻辑,然后注册到Sprinhg容器中,Spring就会调用了。

    其次,还有一种方式,就是让我们的Bean实现一些接口(类似于ApplicationContextAware),通过这种方式,在Bean初始化的某个步骤调用接口定义好的方法来传入一些信息进来,像ApplicationContextAware就把ApplicationContext给传给我们了。

    然后我给大家说几个实用点的知识点,大家记着,用到时回来翻一翻就可以了:

  • 上面的生命周期流程图,时候的时候注意调用先后顺序,避免属性被覆盖的现象。
  • BeanFactoryPostProcessor 主要是在Spring刚加载完配置文件,还没来得及初始化Bean的时候做一些操作。比如篡改某个Bean在配置文件中配置的内容。
  • InstantiationAwareBeanPostProcessorAdapter 基本没什么鸟用,Bean初始化后,还没有设置属性值时调用,和BeanFactoryPostProcessor一样,可以篡改配置文件加载到内存中的信息。
  • ApplicationContextAware:用处很大,注入了ApplicationContext到Bean中。
  • InitializingBean:有用处,可以在Bean属性全部改完之后,再做一些定制化操作。
  • BeanPostProcessor:没什么用,Spring框架内部使用的比较猛,像什么AOP,动态代理,都是在这搞事。后期有时间和大家分析。
  • 其他的像什么init-method,destroy方法,基本都是个摆设。。我是没怎么用过,只知道有这么回事。
  • BeanFactoryPostProcessor 主要是在Spring刚加载完配置文件,还没来得及初始化Bean的时候做一些操作。比如篡改某个Bean在配置文件中配置的内容。

    ApplicationContextAware:用处很大,注入了ApplicationContext到Bean中。

    BeanPostProcessor:没什么用,Spring框架内部使用的比较猛,像什么AOP,动态代理,都是在这搞事。后期有时间和大家分析。

    结语

    好了,Bean的生命周期算上和大家分享完了,其实没什么东西,大家知道有这么回事,能用到”后处理器”搞事的时候回来大致看下顺序即可。其次就是一些Bean实现的接口,最常用的就是(ApplicationContextAware和InitializingBean)了。还有就是BeanPostProcessor,因为这个接口的方法里会把Bean实体以Object传进去。

    所以可以进行一些属性上的操作。其实说实在的,程序员用的比较少。框架内部用的多。OK,这篇讲的其实比较糙,主要是因为没什么东西可讲,Over,Have a good day !

    来源:juejin.im/post/5a4ee1f6518825733e603fcb

    最近五期

    与其在网上拼命找题?** 不如马上关注我们~**

    【79期】别找了,回答Spring中Bean的生命周期,这里帮你总结好了!

    原文始发于微信公众号(Java面试题精选):

    本人花费半年的时间总结的《Java面试指南》已拿腾讯等大厂offer,已开源在github ,欢迎star!

    转载声明:转载请注明出处,本技术博客是本人原创文章

    本文GitHub https://github.com/OUYANGSIHAI/JavaInterview 已收录,这是我花了6个月总结的一线大厂Java面试总结,本人已拿大厂offer,欢迎star

    原文链接:blog.ouyangsihai.cn >> 【79期】别找了,回答Spring中Bean的生命周期,这里帮你总结好了!


     上一篇
    【78期】别找了,Java集合面试问题这里帮你总结好了! 【78期】别找了,Java集合面试问题这里帮你总结好了!
    点击上方“Java面试题精选”,关注公众号 面试刷图,查缺补漏 号外:****往期面试题,10篇为一个单位归置到本公众号菜单栏-面试题,有需要的欢迎翻阅。 Java集合框架为Java编程语言的基础,也是Java面试中很重要的一个知识点。这里
    2021-04-05
    下一篇 
    【80期】说出Java创建线程的三种方式及对比 【80期】说出Java创建线程的三种方式及对比
    点击上方“Java面试题精选”,关注公众号 面试刷图,查缺补漏 号外:****往期面试题,10篇为一个单位归置到本公众号菜单栏-面试题,有需要的欢迎翻阅。 一、Java中创建线程主要有三种方式:1、继承Thread类创建线程类 定义Thre
    2021-04-05