Spring中bean的生命周期

电玩女神 2022-03-09 06:38 330阅读 0赞

## bean的生命周期 ##

## **一、生命周期流程图：** ##

Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点。  
![在这里插入图片描述][181453414212066.png]  
若容器注册了以上各种接口，程序那么将会按照以上的流程进行。下面将仔细讲解各接口作用。

## **二、各种接口方法分类** ##

Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：

1、Bean自身的方法　　：　　这个包括了Bean本身调用的方法和通过配置文件中的init-method和destroy-method指定的方法

2、Bean级生命周期接口方法　　：　　这个包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法

3、容器级生命周期接口方法　　：　　这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。

4、工厂后处理器接口方法　　：　　这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

**Spring中bean的实例化过程：**  
![在这里插入图片描述][Center]

**bean的生命周期流程图**：  
![在这里插入图片描述][1240]

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

1.  Spring对bean进行实例化，默认bean是单例；
2.  Spring对bean进行依赖注入；
3.  如果bean实现了BeanNameAware接口，spring将bean的id传给setBeanName()方法；
4.  如果bean实现了BeanFactoryAware接口，spring将调用setBeanFactory方法，将BeanFactory实例传进来；
5.  如果bean实现了ApplicationContextAware接口，它的setApplicationContext()方法将被调用，将应用上下文的引用传入到bean中；
6.  如果bean实现了BeanPostProcessor接口，它的postProcessBeforeInitialization方法将被调用；
7.  如果bean实现了InitializingBean接口，spring将调用它的afterPropertiesSet接口方法，类似的如果bean使用了init-method属性声明了初始化方法，该方法也会被调用；
8.  如果bean实现了BeanPostProcessor接口，它的postProcessAfterInitialization接口方法将被调用；
9.  此时bean已经准备就绪，可以被应用程序使用了，他们将一直驻留在应用上下文中，直到该应用上下文被销毁；
10. 若bean实现了DisposableBean接口，spring将调用它的distroy()接口方法。
11. 如果bean使用了destroy-method属性声明了销毁方法，则该方法被调用；

## 三、演示 ##

下面用一个示例程序来验证：  
1、首先是一个简单的Spring Bean，调用Bean自身的方法和Bean级生命周期接口方法，为了方便演示，它实现了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这4个接口，同时有2个方法，对应配置文件中的init-method和destroy-method。如下：

package springBeanTest;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.BeanFactoryAware;
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    
    /**
     * @author qsk
     */
    public class Person implements BeanFactoryAware, BeanNameAware,
            InitializingBean, DisposableBean {
    
        private String name;
        private String address;
        private int phone;
    
        private BeanFactory beanFactory;
        private String beanName;
    
        public Person() {
            System.out.println("【构造器】调用Person的构造器实例化");
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            System.out.println("【注入属性】注入属性name");
            this.name = name;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            System.out.println("【注入属性】注入属性address");
            this.address = address;
        }
    
        public int getPhone() {
            return phone;
        }
    
        public void setPhone(int phone) {
            System.out.println("【注入属性】注入属性phone");
            this.phone = phone;
        }
    
        @Override
        public String toString() {
            return "Person [address=" + address + ", name=" + name + ", phone="
                    + phone + "]";
        }
    
        // 这是BeanFactoryAware接口方法
        @Override
        public void setBeanFactory(BeanFactory arg0) throws BeansException {
            System.out
                    .println("【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
            this.beanFactory = arg0;
        }
    
        // 这是BeanNameAware接口方法
        @Override
        public void setBeanName(String arg0) {
            System.out.println("【BeanNameAware接口】调用BeanNameAware.setBeanName()");
            this.beanName = arg0;
        }
    
        // 这是InitializingBean接口方法
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out
                    .println("【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
        }
    
        // 这是DiposibleBean接口方法
        @Override
        public void destroy() throws Exception {
            System.out.println("【DiposibleBean接口】调用DiposibleBean.destory()");
        }
    
        // 通过<bean>的init-method属性指定的初始化方法
        public void myInit() {
            System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");
        }
    
        // 通过<bean>的destroy-method属性指定的初始化方法
        public void myDestory() {
            System.out.println("【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
        }
    }

2、接下来是演示BeanPostProcessor接口的方法，如下：

package springBeanTest;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    
    public class MyBeanPostProcessor implements BeanPostProcessor {
    
        public MyBeanPostProcessor() {
            super();
            System.out.println("这是BeanPostProcessor实现类构造器！！");
            // TODO Auto-generated constructor stub
        }
    
        @Override
        public Object postProcessAfterInitialization(Object arg0, String arg1)
                throws BeansException {
            System.out
            .println("BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！");
            return arg0;
        }
    
        @Override
        public Object postProcessBeforeInitialization(Object arg0, String arg1)
                throws BeansException {
            System.out
            .println("BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！");
            return arg0;
        }
    }

如上，BeanPostProcessor接口包括2个方法postProcessAfterInitialization和postProcessBeforeInitialization，这两个方法的第一个参数都是要处理的Bean对象，第二个参数都是Bean的name。返回值也都是要处理的Bean对象。这里要注意。

3.InstantiationAwareBeanPostProcessor 接口本质是BeanPostProcessor的子接口，一般我们继承Spring为其提供的适配器类InstantiationAwareBeanPostProcessor Adapter来使用它，如下：

package springBeanTest;
    
    import java.beans.PropertyDescriptor;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.PropertyValues;
    import org.springframework.beans.factory.config.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调用postProcessBeforeInstantiation方法");
            return null;
        }
    
        // 接口方法、实例化Bean之后调用
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName)
                throws BeansException {
            System.out
                    .println("InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法");
            return bean;
        }
    
        // 接口方法、设置某个属性时调用
        @Override
        public PropertyValues postProcessPropertyValues(PropertyValues pvs,
                PropertyDescriptor[] pds, Object bean, String beanName)
                throws BeansException {
            System.out
                    .println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
            return pvs;
        }
    }

这个有3个方法，其中第二个方法postProcessAfterInitialization就是重写了BeanPostProcessor的方法。第三个方法postProcessPropertyValues用来操作属性，返回值也应该是PropertyValues对象。

4、演示工厂后处理器接口方法，如下：

package springBeanTest;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanDefinition;
    import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    
    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("person");
            bd.getPropertyValues().addPropertyValue("phone", "110");
        }
    
    }

5、配置文件如下beans.xml，很简单，使用ApplicationContext,处理器不用手动注册：

<?xml version="1.0" encoding="UTF-8"?>
    
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
        xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="
                http://www.springframework.org/schema/beans 
                http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
    
        <bean id="beanPostProcessor" class="springBeanTest.MyBeanPostProcessor">
        </bean>
    
        <bean id="instantiationAwareBeanPostProcessor" class="springBeanTest.MyInstantiationAwareBeanPostProcessor">
        </bean>
    
        <bean id="beanFactoryPostProcessor" class="springBeanTest.MyBeanFactoryPostProcessor">
        </bean>
        
        <bean id="person" class="springBeanTest.Person" init-method="myInit"
            destroy-method="myDestory" scope="singleton" p:name="张三" p:address="广州"
            p:phone="15900000000" />
    
    </beans>

6、下面测试一下：

package springBeanTest;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class BeanLifeCycle {
    
        public static void main(String[] args) {
    
            System.out.println("现在开始初始化容器");
            
            ApplicationContext factory = new ClassPathXmlApplicationContext("springBeanTest/beans.xml");
            System.out.println("容器初始化成功");    
            //得到Preson，并使用
            Person person = factory.getBean("person",Person.class);
            System.out.println(person);
            
            System.out.println("现在开始关闭容器！");
            ((ClassPathXmlApplicationContext)factory).registerShutdownHook();
        }
    }

关闭容器使用的是实际是AbstractApplicationContext的钩子方法。

我们来看一下结果：

现在开始初始化容器
    2014-5-18 15:46:20 org.springframework.context.support.AbstractApplicationContext prepareRefresh
    信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@19a0c7c: startup date [Sun May 18 15:46:20 CST 2014]; root of context hierarchy
    2014-5-18 15:46:20 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
    信息: Loading XML bean definitions from class path resource [springBeanTest/beans.xml]
    这是BeanFactoryPostProcessor实现类构造器！！
    BeanFactoryPostProcessor调用postProcessBeanFactory方法
    这是BeanPostProcessor实现类构造器！！
    这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！
    2014-5-18 15:46:20 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
    信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@9934d4: defining beans [beanPostProcessor,instantiationAwareBeanPostProcessor,beanFactoryPostProcessor,person]; root of factory hierarchy
    InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法
    【构造器】调用Person的构造器实例化
    InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
    【注入属性】注入属性address
    【注入属性】注入属性name
    【注入属性】注入属性phone
    【BeanNameAware接口】调用BeanNameAware.setBeanName()
    【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()
    BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！
    【InitializingBean接口】调用InitializingBean.afterPropertiesSet()
    【init-method】调用<bean>的init-method属性指定的初始化方法
    BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！
    InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法
    容器初始化成功
    Person [address=广州, name=张三, phone=110]
    现在开始关闭容器！
    【DiposibleBean接口】调用DiposibleBean.destory()
    【destroy-method】调用<bean>的destroy-method属性指定的初始化方法

其实很多时候**我们并不会真的去实现上面说描述的那些接口**，那么下面我们就除去那些接口，针对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());  
1  
　　接着来看下这个工具类的源码：

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来完成。

--------------------

> [Spring中bean的作用域与生命周期][Spring_bean]  
> [Spring Bean的生命周期（非常详细）][Spring Bean]

[181453414212066.png]: /images/20220309/33eb26a0c3a94d9187235933bcab1645.png
[Center]: /images/20220309/94300e4ba191473aa546a5372f8d589b.png
[1240]: /images/20220309/d233e1af312240949484db019dc4a354.png
[Spring_bean]: https://blog.csdn.net/fuzhongmin05/article/details/73389779
[Spring Bean]: https://www.cnblogs.com/zrtqsk/p/3735273.html