精华内容
下载资源
问答
  • ​ 这其实是一道面试题,是我在面试百度的时候被问到的,当时没有答出来(因为自己真的很菜),后来在网上寻找答案,看到也是一头雾水,直到看到了《Spring in action》这本书,书上有对Bean声明周期的大致解释,但是...

    前言

    ​ 这其实是一道面试题,是我在面试百度的时候被问到的,当时没有答出来(因为自己真的很菜),后来在网上寻找答案,看到也是一头雾水,直到看到了《Spring in action》这本书,书上有对Bean声明周期的大致解释,但是没有代码分析,所以就自己上网寻找资料,一定要把这个Bean生命周期弄明白!

    ​ 网上大部分都是验证的Bean 在面试问的生命周期,其实查阅JDK还有一个完整的Bean生命周期,这同时也验证了书是具有片面性的,最fresh 的资料还是查阅原始JDK!!!

    一、Bean 的完整生命周期

    ​ 在传统的Java应用中,bean的生命周期很简单,使用Java关键字 new 进行Bean 的实例化,然后该Bean 就能够使用了。一旦bean不再被使用,则由Java自动进行垃圾回收。

    ​ 相比之下,Spring管理Bean的生命周期就复杂多了,正确理解Bean 的生命周期非常重要,因为Spring对Bean的管理可扩展性非常强,下面展示了一个Bean的构造过程

    ​ Bean 的生命周期

    如上图所示,Bean 的生命周期还是比较复杂的,下面来对上图每一个步骤做文字描述:

    1. Spring启动,查找并加载需要被Spring管理的bean,进行Bean的实例化
    2. Bean实例化后对将Bean的引入和值注入到Bean的属性中
    3. 如果Bean实现了BeanNameAware接口的话,Spring将Bean的Id传递给setBeanName()方法
    4. 如果Bean实现了BeanFactoryAware接口的话,Spring将调用setBeanFactory()方法,将BeanFactory容器实例传入
    5. 如果Bean实现了ApplicationContextAware接口的话,Spring将调用Bean的setApplicationContext()方法,将bean所在应用上下文引用传入进来
    6. 如果Bean实现了BeanPostProcessor接口,Spring就将调用他们的postProcessBeforeInitialization()方法。
    7. 如果Bean 实现了InitializingBean接口,Spring将调用他们的afterPropertiesSet()方法。类似的,如果bean使用init-method声明了初始化方法,该方法也会被调用
    8. 如果Bean 实现了BeanPostProcessor接口,Spring就将调用他们的postProcessAfterInitialization()方法。
    9. 此时,Bean已经准备就绪,可以被应用程序使用了。他们将一直驻留在应用上下文中,直到应用上下文被销毁。
    10. 如果bean实现了DisposableBean接口,Spring将调用它的destory()接口方法,同样,如果bean使用了destory-method 声明销毁方法,该方法也会被调用。

    上面是Spring 中Bean的核心接口和生命周期,面试回答上述过程已经足够了。但是翻阅JavaDoc文档发现除了以上接口外,还有另外的初始化过程涉及的接口:

    摘自org.springframework.beans.factory.BeanFactory, 全部相关接口如下,上述已有的就不用着重标注,把额外的相关接口着重标注下

    ​ Bean 完整的生命周期

    文字解释如下:

    ————————————初始化————————————

    • BeanNameAware.setBeanName() 在创建此bean的bean工厂中设置bean的名称,在普通属性设置之后调用,在InitializinngBean.afterPropertiesSet()方法之前调用
    • BeanClassLoaderAware.setBeanClassLoader(): 在普通属性设置之后,InitializingBean.afterPropertiesSet()之前调用
    • BeanFactoryAware.setBeanFactory() : 回调提供了自己的bean实例工厂,在普通属性设置之后,在InitializingBean.afterPropertiesSet()或者自定义初始化方法之前调用
    • EnvironmentAware.setEnvironment(): 设置environment在组件使用时调用
    • EmbeddedValueResolverAware.setEmbeddedValueResolver(): 设置StringValueResolver 用来解决嵌入式的值域问题
    • ResourceLoaderAware.setResourceLoader(): 在普通bean对象之后调用,在afterPropertiesSet 或者自定义的init-method 之前调用,在 ApplicationContextAware 之前调用。
    • ApplicationEventPublisherAware.setApplicationEventPublisher(): 在普通bean属性之后调用,在初始化调用afterPropertiesSet 或者自定义初始化方法之前调用。在 ApplicationContextAware 之前调用。
    • MessageSourceAware.setMessageSource(): 在普通bean属性之后调用,在初始化调用afterPropertiesSet 或者自定义初始化方法之前调用,在 ApplicationContextAware 之前调用。
    • ApplicationContextAware.setApplicationContext(): 在普通Bean对象生成之后调用,在InitializingBean.afterPropertiesSet之前调用或者用户自定义初始化方法之前。在ResourceLoaderAware.setResourceLoader,ApplicationEventPublisherAware.setApplicationEventPublisher,MessageSourceAware之后调用。
    • ServletContextAware.setServletContext(): 运行时设置ServletContext,在普通bean初始化后调用,在InitializingBean.afterPropertiesSet之前调用,在 ApplicationContextAware 之后调用注:是在WebApplicationContext 运行时
    • BeanPostProcessor.postProcessBeforeInitialization() : 将此BeanPostProcessor 应用于给定的新bean实例 在任何bean初始化回调方法(像是InitializingBean.afterPropertiesSet或者自定义的初始化方法)之前调用。这个bean将要准备填充属性的值。返回的bean示例可能被普通对象包装,默认实现返回是一个bean。
    • BeanPostProcessor.postProcessAfterInitialization() : 将此BeanPostProcessor 应用于给定的新bean实例 在任何bean初始化回调方法(像是InitializingBean.afterPropertiesSet或者自定义的初始化方法)之后调用。这个bean将要准备填充属性的值。返回的bean示例可能被普通对象包装
    • InitializingBean.afterPropertiesSet(): 被BeanFactory在设置所有bean属性之后调用(并且满足BeanFactory 和 ApplicationContextAware)。

    ————————————销毁————————————

    在BeanFactory 关闭的时候,Bean的生命周期会调用如下方法:

    • DestructionAwareBeanPostProcessor.postProcessBeforeDestruction(): 在销毁之前将此BeanPostProcessor 应用于给定的bean实例。能够调用自定义回调,像是DisposableBean 的销毁和自定义销毁方法,这个回调仅仅适用于工厂中的单例bean(包括内部bean)
    • 实现了自定义的destory()方法

    二、Bean 的生命周期验证

    为了验证Bean生命周期的过程,有两种形式:一种是为面试而准备的,一种是为了解全过程而准备的,下面来看代码:

    • Book.class
    public class Book implements BeanNameAware,BeanFactoryAware,
            ApplicationContextAware,InitializingBean,DisposableBean {
    
        private String bookName;
        public Book(){
            System.out.println("Book Initializing ");
        }
    
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            System.out.println("Book.setBeanFactory invoke");
        }
    
        public void setBeanName(String name) {
            System.out.println("Book.setBeanName invoke");
        }
    
        public void destroy() throws Exception {
            System.out.println("Book.destory invoke");
        }
    
        public void afterPropertiesSet() throws Exception {
            System.out.println("Book.afterPropertiesSet invoke");
        }
    
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            System.out.println("Book.setApplicationContext invoke");
        }
    
        public String getBookName() {
            return bookName;
        }
    
        public void setBookName(String bookName) {
            this.bookName = bookName;
            System.out.println("setBookName: Book name has set.");
        }
    
        public void myPostConstruct(){
            System.out.println("Book.myPostConstruct invoke");
        }
    
         // 自定义初始化方法
        @PostConstruct
        public void springPostConstruct(){
            System.out.println("@PostConstruct");
        }
    
        public void myPreDestory(){
            System.out.println("Book.myPreDestory invoke");
            System.out.println("---------------destroy-----------------");
        }
    
        // 自定义销毁方法
        @PreDestroy
        public void springPreDestory(){
            System.out.println("@PreDestory");
        }
    
        @Override
        protected void finalize() throws Throwable {
            System.out.println("------inside finalize-----");
        }
    }
    
    • 自定义实现BeanPostProcessor 的MyBeanPostProcessor:
    public class MyBeanPostProcessor implements BeanPostProcessor {
    
        // 容器加载的时候会加载一些其他的bean,会调用初始化前和初始化后方法
        // 这次只关注book(bean)的生命周期
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if(bean instanceof Book){
                System.out.println("MyBeanPostProcessor.postProcessBeforeInitialization");
            }
            return bean;
        }
    
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            if(bean instanceof Book){
                System.out.println("MyBeanPostProcessor.postProcessAfterInitialization");
            }
            return bean;
        }
    }
    
    • 在resources 目录下新建Bean-Lifecycle.xml
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    
      	<!-- 扫描bean -->
        <context:component-scan base-package="com.bean.lifecycle"/>
      
        <!-- 实现了用户自定义初始化和销毁方法 -->
        <bean id="book" class="com.bean.lifecycle.Book" init-method="myPostConstruct" destroy-method="myPreDestory">
          	<!-- 注入bean 属性名称 -->
            <property name="bookName" value="thingking in java" />
        </bean>
    
      	<!--引入自定义的BeanPostProcessor-->
        <bean class="com.bean.lifecycle.MyBeanPostProcessor"/>
    
    </beans>
    
    • 做一个启动类的测试,新建SpringBeanLifecycleApplication
    public class SpringBeanLifecycleApplication {
    
        public static void main(String[] args) throws InterruptedException {
            // 为面试而准备的Bean生命周期加载过程
            ApplicationContext context = new ClassPathXmlApplicationContext("Bean-Lifecycle.xml");
            Book book = (Book)context.getBean("book");
            System.out.println("Book name = " + book.getBookName());
            ((ClassPathXmlApplicationContext) context).destroy();
    
        }
    
    }
    

    启动测试,输出结果如下:

    Book Initializing
    setBookName: Book name has set.
    Book.setBeanName invoke
    Book.setBeanFactory invoke
    Book.setApplicationContext invoke
    MyBeanPostProcessor.postProcessBeforeInitialization
    @PostConstruct
    Book.afterPropertiesSet invoke
    Book.myPostConstruct invoke
    MyBeanPostProcessor.postProcessAfterInitialization
    Book name = thingking in java

    @PreDestory
    Book.destory invoke
    Book.myPreDestory invoke
    ---------------destroy-----------------

    • 为了验证Bean完整的生命周期,需要新建一个SubBookClass 继承Book类
    public class SubBookClass extends Book implements BeanClassLoaderAware,
            EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware,
            ApplicationEventPublisherAware,MessageSourceAware{
    
        private String bookSystem;
    
        public String getBookSystem() {
            return bookSystem;
        }
    
        public void setBookSystem(String bookSystem) {
            System.out.println("设置BookSystem 的属性值");
            this.bookSystem = bookSystem;
        }
    
        public void setBeanClassLoader(ClassLoader classLoader) {
            System.out.println("SubBookClass.setBeanClassLoader() 方法被调用了");
        }
    
        public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
            System.out.println("SubBookClass.setApplicationEventPublisher() 方法被调用了");
        }
    
        public void setEmbeddedValueResolver(StringValueResolver resolver) {
            System.out.println("SubBookClass.setEmbeddedValueResolver() 方法被调用了");
        }
    
        public void setEnvironment(Environment environment) {
            System.out.println("SubBookClass.setEnvironment() 方法被调用了");
        }
    
        public void setMessageSource(MessageSource messageSource) {
            System.out.println("SubBookClass.setMessageSource() 方法被调用了");
        }
    
        public void setResourceLoader(ResourceLoader resourceLoader) {
            System.out.println("SubBookClass.setResourceLoader() 方法被调用了");
        }
    
    }
    

    上述SubBookClass类与Book是互补关系。

    • 新建一个SubBean-Lifecycle.xml,注入SubBookClass
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    
    
        <bean id="bookClass" class="com.bean.lifecycle.SubBookClass" init-method="myPostConstruct" destroy-method="myPreDestory">
            <property name="bookSystem" value="Java System" />
        </bean>
    
        <bean class="com.bean.lifecycle.MyBeanPostProcessor"/>
    
    </beans>
    
    • 完整的SpringBeanLifecycleApplication 如下:
    public class SpringBeanLifecycleApplication {
    
        public static void main(String[] args) throws InterruptedException {
            // 为面试而准备的Bean生命周期加载过程
            ApplicationContext context = new ClassPathXmlApplicationContext("Bean-Lifecycle.xml");
            Book book = (Book)context.getBean("book");
            System.out.println("Book name = " + book.getBookName());
            ((ClassPathXmlApplicationContext) context).destroy();
    
            // 完整的加载过程,当然了解的越多越好
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("SubBean-Lifecycle.xml");
            SubBookClass subBookClass = (SubBookClass) applicationContext.getBean("bookClass");
            System.out.println("BookSystemName = " + subBookClass.getBookSystem());
            ((ClassPathXmlApplicationContext) applicationContext).registerShutdownHook();
        }
    
    }
    

    输出完整的结果:

    Book Initializing
    setBookName: Book name has set.
    Book.setBeanName invoke
    Book.setBeanFactory invoke
    Book.setApplicationContext invoke
    MyBeanPostProcessor.postProcessBeforeInitialization
    @PostConstruct
    Book.afterPropertiesSet invoke
    Book.myPostConstruct invoke
    MyBeanPostProcessor.postProcessAfterInitialization
    Book name = thingking in java
    @PreDestory
    Book.destory invoke
    Book.myPreDestory invoke
    ---------------destroy-----------------

    Book Initializing
    设置BookSystem 的属性值
    Book.setBeanName invoke
    SubBookClass.setBeanClassLoader() 方法被调用了
    Book.setBeanFactory invoke
    SubBookClass.setEnvironment() 方法被调用了
    SubBookClass.setEmbeddedValueResolver() 方法被调用了
    SubBookClass.setResourceLoader() 方法被调用了
    SubBookClass.setApplicationEventPublisher() 方法被调用了
    SubBookClass.setMessageSource() 方法被调用了
    Book.setApplicationContext invoke
    MyBeanPostProcessor.postProcessBeforeInitialization
    Book.afterPropertiesSet invoke
    Book.myPostConstruct invoke
    MyBeanPostProcessor.postProcessAfterInitialization
    BookSystemName = Java System
    Book.destory invoke
    Book.myPreDestory invoke
    ---------------destroy-----------------

    后记:这篇文章是我翻阅各种书籍和从网上查找资料,包括国外一些网站从而得到的结论,记录下来,但是我没有发现Spring Bean的生命周期(非常详细) 这篇文章中InstantiationAwareBeanPostProcessorAdapter 这个类和工厂后置处理器接口方法,知道的大佬欢迎指教谢谢。

    另外,添加我的微信 becomecxuan,加入每日一题群,每天一道面试题分享,更多内容请参见我的 Github,成为最好的 bestJavaer

    我自己肝了六本 PDF,微信搜索「程序员cxuan」关注公众号后,在后台回复 cxuan ,领取全部 PDF,这些 PDF 如下

    六本 PDF 链接

    展开全文
  • JAVA面试题:Spring中bean生命周期
    展开全文
  • 关于Bean生命周期,是面试中非常容易被问到的知识点了,同时也十分考验面试者对Spring的理解够不够深入。 下面我们就来说一下Bean生命周期到底是怎么个流程吧。 首先,Bean一定是从创建,经历中间很多的过程,...

    关于Bean的生命周期,是面试中非常容易被问到的知识点了,同时也十分考验面试者对Spring的理解够不够深入。

    下面我们就来说一下Bean的生命周期到底是怎么个流程吧。

    首先,Bean一定是从创建,经历中间很多的过程,然后被使用,最后执行销毁方法来走完它的一生。

    那么我们就将Bean的生命周期大概分为三个大点来说明。

    一. 创建Bean,并且准备Bean的一些附属方法

    二. 使用Bean

    三. 销毁Bean

    让我们来围绕这三点说一下吧。

    一. 创建Bean,并且准备Bean的一些附属方法

    首先,Bean会由程序来调用其构造函数进行初步构造。

    然后,通过依赖注入方式对Bean的各属性,或者说是各setter方法进行注入信息。

    其实如果没有其他的特殊实现的话,上面两步就已经创建Bean完成了;不过其中还会存在几个接口的实现,如果Bean实现了特定的几个接口,这个时候也会在创建Bean的过程中多出几步操作。

    当Bean本身实现了BeanNameAware接口,这个时候会根据接口方法,来设置Bean的name。

    当Bean本身实现了BeanFactoryAware接口,这个时候会根据接口方法,将BeanFactory设置给Bean。

    当Bean本身实现了ApplicationContextAware接口,这个时候Spring会将当前Bean引入到应用上下文中,也就是说可以通过ApplicationContext获取到当前Bean。

    当Bean本身实现了BeanPostProcessor接口时,则执行程序中的前置处理方法。

    当Bean本身实现了InitializingBean接口时,这个时候还会执行afterPropertiesSet方法,进行配置的一个加载。

    随后,就是执行自身的init方法,进行Bean的初始化。

    最后,执行BeanPostProcessor中的后置处理方法,即创建完成。

    二. 使用Bean

    使用Bean就没有什么技术含量了,这个就是业务层面上的使用过程了。

    三. 销毁Bean

    当使用完成后要销毁时,这个时候会第一时间执行DisposableBean接口的destroy方法,随后再执行自身Bean自定义的destroy方法。

    展开全文
  • Spring Bean生命周期简单易懂。在一个bean实例被初始化时,需要执行一系列的初始化操作以达到可用的状态。同样的,当一个bean不在被调用时需要进行相关的析构操作,并从bean容器中移除。 Spring bean factory ...

    Spring Bean的生命周期简单易懂。在一个bean实例被初始化时,需要执行一系列的初始化操作以达到可用的状态。同样的,当一个bean不在被调用时需要进行相关的析构操作,并从bean容器中移除。

    Spring bean factory 负责管理在spring容器中被创建的bean的生命周期。Bean的生命周期由两组回调(call back)方法组成。

    • 1.初始化之后调用的回调方法。
    • 2.销毁之前调用的回调方法。
      Spring框架提供了以下四种方式来管理bean的生命周期事件:
    • InitializingBean和DisposableBean回调接口
    • 针对特殊行为的其他Aware接口
    • Bean配置文件中的Custom init()方法和destroy()方法
    • @PostConstruct@PreDestroy注解方式

    使用customInit()customDestroy()方法管理bean生命周期的代码样例如下:

    <beans>
        <bean id="demoBean" class="com.howtodoinjava.task.DemoBean"
                init-method="customInit" destroy-method="customDestroy"></bean>
    </beans>
    

    更多内容请参考:Spring生命周期Spring Bean Life Cycle。

    展开全文
  • 生命周期 1.实例化得到java对象,也就是像我们平时new一个对象一样; 2.属性填充,比如我们的bean中有一个属性,这个属性添加了@Autowired自动装配注解。 3.初始化,这个怎么理解呢,不是说初始化构造函数哦,比如,...
  • 1. Bean 容器找到配置文件中 Spring Bean 的定义。 2. Bean 容器利用反射创建 Bean 的实例。 3. 为 Bean 的属性设置值和du
  • 面试题积累-Spring-bean生命周期

    千次阅读 2020-03-12 16:32:38
    基本生命周期就如下图所示了: 如果还想详细一点如下: Spring支持五个作用域:singleton、prototype、request、session、global session singleton :默认的作用域 spring IoC容器仅存在一个Bean实例,Bean以...
  • 面试必备:Spring的Bean生命周期

    千次阅读 2019-06-07 12:49:12
    这也就是ioc(控制反转)的体现,抛弃我们之前主动创建的模式,但是我们也可以自定义,初始化,和销毁方法,容器在bean执行到当前声明周期的时候就会调用我们自定义的方法,这样给了我们空间,在当前生命周期做一些...
  • 谈谈你对Spring Bean生命周期的理解【面试

    千次阅读 多人点赞 2020-05-16 17:08:59
    前言 面试中经常会被问到Spring Bean生命周期,有些人说记不住,看了一遍源码也是云里雾里的,那是因为只看理论,没有自己实践,如果自己亲自写代码验证一下,不管是对Spring的宏观感受,还是微观的感觉,都会有...
  • spring bean生命周期: 1.实例化 实例化一个Bean ,也就是我们常说的new。 2.IOC依赖注入 按照Spring上下文对实例化的Bean进行配置,也就是IOC注入。 3.setBeanName实现 如果这个Bean已经实现了BeanNameAware接口...
  • Bean生命周期Bean的定义——Bean的初始化——Bean的使用——Bean的销毁 Bean的定义 Bean 是 spring 装配的组件模型,一切实体类都可以配置成一个 Bean ,进而就可以在任何其他的 Bean 中使用,一个 Bean 也...
  • 描述一下bean生命周期 背图: 记住图中的流程 在表述的时候不要只说图中的有的关键点,要学会拓展描述。 1.实例化bean:反射的方式生成对象 2.填充bean的属性:populateBean(),循环依赖的问题(三级缓存) 3.调用...
  • bean生命周期主要有以下几个阶段,深色底的5个是比较重要的阶段。 BeanFactory:Spring 容器最核心也是最基础的接口,本质是个工厂类,用于管理 bean 的工厂,最核心的功能是加载 bean,也就是 getBean 方法,...
  • Spring Bean生命周期

    2021-03-29 15:50:35
    去一些企业面试时,经常会被问到Spring的问题,有一次就被问到关于Spring中Bean生命周期是怎样的?其实这也是在业务中经常会遇到的,但容易遗忘,所以专门总结一下。 提示:可以借鉴Servlet的生命周期,实例化、...
  • 生命周期 1、实例化一个Bean--也就是我们常说的new一个对象; 2、按照Spring上下文对实例化的Bean进行配置--也就是IOC注入; 3、如果这个Bean已经实现了BeanNameAware接口,会调用它实现的setBeanName(String)...
  • https://blog.csdn.net/w_linux/article/details/80086950
  • 1、解析类得到BeanDefinition。 2、如果有多个构造方法,则要推断构造方法。 3、确定好构造方法后,进行实例化得到一个对象。 4、对对象中加了@Autowired注解的属性进行属性填充。 5、回调Aware方法,比如...
  • springbean生命周期及创建流程 1、 启动spring容器,也就是创建beanFactory(bean工厂), 一般用的是beanFactory的子类applicationcontext, applicationcontext比一般的beanFactory要多很多功能,比如aop、事件等。 ...
  • 面试题 来自面试官发自灵魂深处的拷问:谈谈你对spring的理解; 一脸懵逼的求职者的内心活动:啥? 具体的问题是什么?现在的面试都不按套路出牌了吗? 抛出一个这么大的问题,你让我怎么回答? 一脸懵逼的求职者...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,367
精华内容 6,546
关键字:

bean的生命周期面试题