Spring中bean的作用域与生命周期

港控/mmm° 2023-10-01 08:38 21阅读 0赞

在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象，除此之外，bean就与应用程序中的其他对象没有什么区别了。而bean的定义以及bean相互间的依赖关系将通过配置元数据来描述。

Spring中的bean默认都是单例的，对于Web应用来说，Web容器对于每个用户请求都创建一个单独的Sevlet线程来处理请求，引入Spring框架之后，每个Action都是单例的，那么对于Spring托管的单例Service Bean，Spring的单例是基于BeanFactory也就是Spring容器的，单例Bean在此容器内只有一个，Java的单例是基于JVM，每个JVM内只有一个实例。

### **1、bean的作用域** ###

创建一个bean定义，其实质是用该bean定义对应的类来创建真正实例的“配方”。把bean定义看成一个配方很有意义，它与class很类似，只根据一张“处方”就可以创建多个实例。不仅可以控制注入到对象中的各种依赖和配置值，还可以控制该对象的作用域。这样可以灵活选择所建对象的作用域，而不必在Java Class级定义作用域。Spring Framework支持五种作用域，分别阐述如下表。

![img][]

(1)当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton，可以这样配置：

(2)当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype，可以这样配置：

(3)当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

(4)当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

(5)当一个bean的作用域为Global Session，表示在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

global session作用域类似于标准的HTTP Session作用域，不过仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。

### **2、bean的生命周期** ###

Spring中Bean的实例化过程：

![img][img 1]![img][img 2]

Bean实例生命周期的执行过程如下：

*  Spring对bean进行实例化，默认bean是单例；
 *  Spring对bean进行依赖注入；
 *  如果bean实现了BeanNameAware接口，Spring将bean的名称传给setBeanName()方法；
 *  如果bean实现了BeanFactoryAware接口，Spring将调用setBeanFactory()方法，将BeanFactory实例传进来；
 *  如果bean实现了ApplicationContextAware接口，它的setApplicationContext()方法将被调用，将应用上下文的引用传入到bean中；
 *  如果bean实现了BeanPostProcessor接口，它的postProcessBeforeInitialization()方法将被调用；
 *  如果bean中有方法添加了@PostConstruct注解，那么该方法将被调用；
 *  如果bean实现了InitializingBean接口，spring将调用它的afterPropertiesSet()接口方法，类似的如果bean使用了init-method属性声明了初始化方法，该方法也会被调用；
 *  如果在xml文件中通过标签的init-method元素指定了初始化方法，那么该方法将被调用；
 *  如果bean实现了BeanPostProcessor接口，它的postProcessAfterInitialization()接口方法将被调用；
 *  此时bean已经准备就绪，可以被应用程序使用了，他们将一直驻留在应用上下文中，直到该应用上下文被销毁；
 *  如果bean中有方法添加了@PreDestroy注解，那么该方法将被调用；
 *  若bean实现了DisposableBean接口，spring将调用它的distroy()接口方法。同样的，如果bean使用了destroy-method属性声明了销毁方法，则该方法被调用；

这里特别说明一下Aware接口，Spring的依赖注入最大亮点就是所有的Bean对Spring容器的存在是没有意识的。但是在实际项目中，我们有时不可避免的要用到Spring容器本身提供的资源，这时候要让 Bean主动意识到Spring容器的存在，才能调用Spring所提供的资源，这就是Spring的Aware接口，Aware接口是个标记接口，标记这一类接口是用来“感知”属性的，Aware的众多子接口则是表征了具体要“感知”什么属性。例如BeanNameAware接口用于“感知”自己的名称，ApplicationContextAware接口用于“感知”自己所处的上下文。其实Spring的Aware接口是Spring设计为框架内部使用的，在大多数情况下，我们不需要使用任何Aware接口，除非我们真的需要它们，实现了这些接口会使应用层代码耦合到Spring框架代码中。

其实很多时候我们并不会真的去实现上面所描述的那些接口，那么下面我们就除去那些接口，针对bean的单例和非单例来描述下bean的生命周期：

#### **2.1 单例管理的对象** ####

当scope=“singleton”，即默认情况下，会在启动容器时（即实例化容器时）时实例化。但我们可以指定Bean节点的lazy-init="true"来延迟初始化bean，这时候，只有在第一次获取bean时才会初始化bean，即第一次请求该bean时才初始化。如下配置：

如果想对所有的默认单例bean都应用延迟初始化，可以在根节点beans设置default-lazy-init属性为true，如下所示：

默认情况下，Spring在读取xml文件的时候，就会创建对象。在创建对象的时候先调用构造器，然后调用init-method属性值中所指定的方法。对象在被销毁的时候，会调用destroy-method属性值中所指定的方法（例如调用Container.destroy()方法的时候）。写一个测试类，代码如下：

public class LifeBean {
        
    	private String name;  
        
        public LifeBean(){
          
            System.out.println("LifeBean()构造函数");  
        }  
        public String getName() {
          
            return name;  
        }  
      
        public void setName(String name) {
          
            System.out.println("setName()");  
            this.name = name;  
        }  
    
        public void init(){
          
            System.out.println("this is init of lifeBean");  
        }  
          
        public void destory(){
          
            System.out.println("this is destory of lifeBean " + this);  
        }  
    }

life.xml配置如下：

测试代码如下：

public class LifeTest {
        
    	@Test 
    	public void test() {
        
    		AbstractApplicationContext container = 
    		new ClassPathXmlApplicationContext("life.xml");
    		LifeBean life1 = (LifeBean)container.getBean("life");
    		System.out.println(life1);
    		container.close();
    	}
    }

运行结果如下：

LifeBean()构造函数
    this is init of lifeBean
    com.bean.LifeBean@573f2bb1
    ……
    this is destory of lifeBean com.bean.LifeBean@573f2bb1

#### **2.2 非单例管理的对象** ####

当scope="prototype"时，容器也会延迟初始化bean，Spring读取xml文件的时候，并不会立刻创建对象，而是在第一次请求该bean时才初始化（如调用getBean方法时）。在第一次请求每一个prototype的bean时，Spring容器都会调用其构造器创建这个对象，然后调用init-method属性值中所指定的方法。对象销毁的时候，Spring容器不会帮我们调用任何方法，因为是非单例，这个类型的对象有很多个，Spring容器一旦把这个对象交给你之后，就不再管理这个对象了。

为了测试prototype bean的生命周期life.xml配置如下：

测试程序如下：

public class LifeTest {
        
    	@Test 
    	public void test() {
        
    		AbstractApplicationContext container = new ClassPathXmlApplicationContext("life.xml");
    		LifeBean life1 = (LifeBean)container.getBean("life_singleton");
    		System.out.println(life1);
    		
    		LifeBean life3 = (LifeBean)container.getBean("life_prototype");
    		System.out.println(life3);
    		container.close();
    	}
    }

运行结果如下：

LifeBean()构造函数
    this is init of lifeBean
    com.bean.LifeBean@573f2bb1
    LifeBean()构造函数
    this is init of lifeBean
    com.bean.LifeBean@5ae9a829
    ……
    this is destory of lifeBean com.bean.LifeBean@573f2bb1

可以发现，对于作用域为prototype的bean，其destroy方法并没有被调用。如果bean的scope设为prototype时，当容器关闭时，destroy方法不会被调用。对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责：容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法。但对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，都是客户端代码的职责（让Spring容器释放被prototype作用域bean占用资源的一种可行方式是，通过使用bean的后置处理器，该处理器持有要被清除的bean的引用）。谈及prototype作用域的bean时，在某些方面你可以将Spring容器的角色看作是Java new操作的替代者，任何迟于该时间点的生命周期事宜都得交由客户端来处理。

Spring容器可以管理singleton作用域下bean的生命周期，在此作用域下，Spring能够精确地知道bean何时被创建，何时初始化完成，以及何时被销毁。而对于prototype作用域的bean，Spring只负责创建，当容器创建了bean的实例后，bean的实例就交给了客户端的代码管理，Spring容器将不再跟踪其生命周期，并且不会管理那些被配置成prototype作用域的bean的生命周期。

#### **2.3 引申** ####

在学习Spring IoC过程中发现，每次产生ApplicationContext工厂的方式是：

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

这样产生ApplicationContext就有一个弊端，每次访问加载bean的时候都会产生这个工厂，所以这里需要解决这个问题。

ApplicationContext是一个接口，它继承自BeanFactory接口，除了包含BeanFactory的所有功能之外，在国际化支持、资源访问（如URL和文件）、事件传播等方面进行了良好的支持。

解决问题的方法很简单，在web容器启动的时候将ApplicationContext转移到ServletContext中，因为在web应用中所有的Servlet都共享一个ServletContext对象。那么我们就可以利用ServletContextListener去监听ServletContext事件，当web应用启动的是时候，我们就将ApplicationContext装载到ServletContext中。 Spring容器底层已经为我们想到了这一点，在spring-web-xxx-release.jar包中有一个已经实现了ServletContextListener接口的类ContextLoader，其源码如下：

public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
        
    	private ContextLoader contextLoader;
    
    	public ContextLoaderListener() {
        
    
    	}
    
    	public ContextLoaderListener(WebApplicationContext context) {
        
    		super(context);
    	}
    
    	public void contextInitialized(ServletContextEvent event) {
        
    		this.contextLoader = createContextLoader();
    		if (this.contextLoader == null) {
        
    			this.contextLoader = this;
    		}
    		this.contextLoader.initWebApplicationContext(event.getServletContext());
    	}
    
    	@Deprecated
    	protected ContextLoader createContextLoader() {
        
    		return null;
    	}
    
    	@Deprecated
    	public ContextLoader getContextLoader() {
        
    		return this.contextLoader;
    	}
    
    	public void contextDestroyed(ServletContextEvent event) {
        
    		if (this.contextLoader != null) {
        
    		this.contextLoader.closeWebApplicationContext(event.getServletContext());
    		}
    		ContextCleanupListener.cleanupAttributes(event.getServletContext());
    	}
    }

这里就监听到了servletContext的创建过程, 那么 这个类又是如何将applicationContext装入到serveletContext容器中的呢?

this.contextLoader.initWebApplicationContext(event.getServletContext())方法的具体实现中：

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
        
         if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
        
             throw new IllegalStateException(
                     "Cannot initialize context because there is already a root application context present - " +
                     "check whether you have multiple ContextLoader* definitions in your web.xml!");
         }
    
         Log logger = LogFactory.getLog(ContextLoader.class);
         servletContext.log("Initializing Spring root WebApplicationContext");
         if (logger.isInfoEnabled()) {
        
             logger.info("Root WebApplicationContext: initialization started");
         }
         long startTime = System.currentTimeMillis();
    
         try {
        
         	  // Store context in local instance variable, to guarantee that
              // it is available on ServletContext shutdown.
             if (this.context == null) {
        
                 this.context = createWebApplicationContext(servletContext);
             }
             if (this.context instanceof ConfigurableWebApplicationContext) {
        
                 ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
                 if (!cwac.isActive()) {
        
                     // The context has not yet been refreshed -> provide services such as
                     // setting the parent context, setting the application context id, etc
                     if (cwac.getParent() == null) {
        
                         // The context instance was injected without an explicit parent ->
                         // determine parent for root web application context, if any.
                         ApplicationContext parent = loadParentContext(servletContext);
                         cwac.setParent(parent);
                     }
                     configureAndRefreshWebApplicationContext(cwac, servletContext);
                 }
             }
             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
    
             ClassLoader ccl = Thread.currentThread().getContextClassLoader();
             if (ccl == ContextLoader.class.getClassLoader()) {
        
                 currentContext = this.context;
             }
             else if (ccl != null) {
        
                 currentContextPerThread.put(ccl, this.context);
             }
    
             if (logger.isDebugEnabled()) {
        
                 logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
                         WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
             }
             if (logger.isInfoEnabled()) {
        
                 long elapsedTime = System.currentTimeMillis() - startTime;
                 logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
             }
    
             return this.context;
         }
         catch (RuntimeException ex) {
        
             logger.error("Context initialization failed", ex);
             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
             throw ex;
         }
         catch (Error err) {
        
             logger.error("Context initialization failed", err);
             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
             throw err;
         }
     }

这里的重点是servletContext.setAttribute(WebApplicationContext.ROOT\_WEB\_APPLICATION\_CONTEXT\_ATTRIBUTE, this.context)，用key:WebApplicationContext.ROOT\_WEB\_APPLICATION\_CONTEXT\_ATTRIBUTE value: this.context的形式将applicationContext装载到servletContext中了。另外从上面的一些注释我们可以看出： WEB-INF/applicationContext.xml， 如果我们项目中的配置文件不是这么一个路径的话 那么我们使用ContextLoaderListener 就会出问题, 所以我们还需要在web.xml中配置我们的applicationContext.xml配置文件的路径。

<listener>
    	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <context-param>
    	<param-name>contextConfigLocation</param-name>
    	<param-value>classpath:applicationContext.xml</param-value>
    </context-param>

剩下的就是在项目中开始使用 servletContext中装载的applicationContext对象了： 那么这里又有一个问题，装载时的key是 WebApplicationContext.ROOT\_WEB\_APPLICATION\_CONTEXT\_ATTRIBUTE，我们在代码中真的要使用这个吗? 其实Spring为我们提供了一个工具类WebApplicationContextUtils，接着我们先看下如何使用，然后再去看下这个工具类的源码：

WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(request.getServletContext());

接着来看下这个工具类的源码：

public static WebApplicationContext getWebApplicationContext(ServletContext sc) {
        
    	return getWebApplicationContext(sc, WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
    }

这里就能很直观清晰地看到 通过key值直接获取到装载到servletContext中的 applicationContext对象了。

ContextLoaderListener监听器的作用就是启动Web容器时，自动装配ApplicationContext的配置信息，因为它实现了ServletContextListener这个接口，在web.xml配置这个监听器，启动容器时，就会默认执行它实现的方法。在ContextLoaderListener中关联了ContextLoader这个类，整个加载配置过程由ContextLoader来完成。

###  ###

### 一、Bean 的完整生命周期 ###

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

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

![img][img 3]

**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， 全部相关接口如下，上述已有的就不用着重标注，把额外的相关接口着重标注下**

![img][img 4]

**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

做一个启动类的测试，新建SpringBeanLifecycleApplication

public class SpringBeanLifecycleApplication {
        
    
        public static void main(String[] args) throws InterruptedException {
        
           
            ApplicationContext context = new ClassPathXmlApplicationContext("Bean-Lifecycle.xml");
            Book book = (Book)context.getBean("book");
            System.out.println("Book name = " + book.getBookName());
            ((ClassPathXmlApplicationContext) context).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

完整的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-----------------

[img]: https://img-blog.csdn.net/20160417164310654?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[img 1]: https://img-blog.csdnimg.cn/20210510144229675.png
[img 2]: https://img-blog.csdnimg.cn/2021051014425161.png
[img 3]: https://img-blog.csdnimg.cn/img_convert/7d0f2d01cc468a9e3bb08f8944f0c638.png
[img 4]: https://img-blog.csdnimg.cn/img_convert/3bad1fbd3907bfd103c191df2f570348.png