Spring生命周期-CFANZ编程社区

文章目录

bean生命周期流程图

在这里插入图片描述

测试方法及步骤

创建一个bean

package cn.test.springbean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

public class Person implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {
    /**
     * 首先是一个简单的Spring Bean，调用Bean自身的方法和Bean级生命周期接口方法，
     * 为了方便演示，它实现了BeanNameAware、BeanFactoryAware、InitializingBean
     * 和DiposableBean这4个接口，同时有2个方法，对应配置文件中<bean>的init-method和destroy-method
     */
    private String name;
    private String address;
    private String 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" + name);
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        System.out.println("第九步:【注入属性】注入属性address" + address);
        this.address = address;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        System.out.println("第十一步:【注入属性】注入属性phone" + phone);
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "Person [address=" + address + ", name=" + name + ", phone=" + phone + "]";
    }

    // 这是BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("第十二步:调用BeanFactoryAware接口的实现类方法setBeanFactory()");
        this.beanFactory = beanFactory;
    }

    // 这是BeanNameAware接口方法
    @Override
    public void setBeanName(String s) {
        System.out.println("第十步:调用BeanNameAware接口实现类的setBeanName()");
        this.beanName = s;
    }

    // 这是DiposibleBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("【DiposibleBean接口】调用DiposibleBean.destory()");
    }

    // 这是InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("第十四步:调用InitializingBean接口的afterPropertiesSet()");
    }

    // 通过<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属性指定的初始化方法");
    }

}

创建BeanFactoryPostProcessor 的实现类实例

package cn.test.springbean;


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");
    }

}

创建BeanPostProcessor实现实例

package cn.test.springbean;


import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.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接口方法postProcessAfterInitialization对属性进行更改！");
        return arg0;
    }

    @Override
    public Object postProcessBeforeInitialization(Object arg0, String arg1)
            throws BeansException {
        System.out.println("第十三步:调用BeanPostProcessor接口实现类的postProcessBeforeInitialization()对属性进行更改");
        return arg0;
    }
}

创建InstantiationAwareBeanPostProcessorAdapter实现实例

package cn.test.springbean;


import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

import java.beans.PropertyDescriptor;

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 boolean postProcessAfterInstantiation(Object o, String s) throws BeansException {
        boolean resule = true;
        System.out.println("第七步:调用InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation(),[" + s + "], 返回: " + resule);
        return resule;
    }

    //设置某个属性之前调用
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs,
                                                    PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        System.out.println("第八步:调用InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
        return pvs;
    }
}

将实例注册到Spring中

<?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="cn.test.springbean.MyBeanPostProcessor"></bean>

    <bean id="instantiationAwareBeanPostProcessor"
          class="cn.test.springbean.MyInstantiationAwareBeanPostProcessor"></bean>

    <bean id="beanFactoryPostProcessor" class="cn.test.springbean.MyBeanFactoryPostProcessor"></bean>

    <bean id="person" class="cn.test.springbean.Person" init-method="myInit"
          destroy-method="myDestory" scope="singleton" p:name="张三" p:address="杭州" p:phone="15000000000"/>

</beans>

测试代码

package cn.test.springbean;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {
    public static void main(String[] args) {
        System.out.println("现在开始初始化容器");
        ApplicationContext factory = new ClassPathXmlApplicationContext("/WEB-INF/beans.xml");
        System.out.println("容器初始化成功");
        //得到Preson，并使用
        Person person = factory.getBean("person",Person.class);
        System.out.println(person);
        System.out.println("现在开始关闭容器！");
        ((ClassPathXmlApplicationContext)factory).registerShutdownHook();
        System.out.println("结束");
    }
}

执行结果

现在开始初始化容器
第一步:调用BeanFactoryPostProcessor实例化
第二步:调用BeanFactoryPostProcessor实现类的postProcessBeanFactory方法
第三步:调用BeanPostProcessor实例化
第四步:调用InstantiationAwareBeanPostProcessorAdapter实现类构造器
第五步:调用InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法
第六步:调用Person的构造器实例化
第七步:调用InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation(),[person], 返回: true
第八步:调用InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
第九步:【注入属性】注入属性address杭州
第十步:【注入属性】注入属性name张三
第十一步:【注入属性】注入属性phone110
第十步:调用BeanNameAware接口实现类的setBeanName()
第十二步:调用BeanFactoryAware接口的实现类方法setBeanFactory()
第十三步:调用BeanPostProcessor接口实现类的postProcessBeforeInitialization()对属性进行更改
第十四步:调用InitializingBean接口的afterPropertiesSet()
第十五步:调用init-method调用<bean>的init-method属性指定的初始化方法
第十六步:调用BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！
容器初始化成功
Person [address=杭州, name=张三, phone=110]
现在开始关闭容器！
结束
【DiposibleBean接口】调用DiposibleBean.destory()
【destroy-method】调用<bean>的destroy-method属性指定的初始化方法

git代码下载地址

https://gitee.com/gaozhaoxyz/springbean-master

流程分析

1.首先调用ClassPathXmlApplicationContext的构造方法

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
   this(new String[] {configLocation}, true, null);
}

public ClassPathXmlApplicationContext(
    String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
    throws BeansException {

    //设置父容器，这里parent为null
    super(parent);
    //将传入的配置文件路径存入成员变量String[] configLocations中
    setConfigLocations(configLocations);
    if (refresh) {
        //刷新容器
        refresh();
    }
}

2.Spring的启动流程几乎都在 refresh() 方法中

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // 设置启动日期和一些标志位，初始化Environment，默认为StandardEnvironment
      prepareRefresh();

      // 刷新BeanFactory，如果之前存在则销毁，不存在则创建
      // 在这里会加载配置文件中的BeanDefinition并保存到beanFactory的Map中
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // 配置BeanFactory，比如设置类加载器或添加一些BeanPostProcessor
      prepareBeanFactory(beanFactory);

      try {
         // 可被子类重写的回调，默认空实现
         postProcessBeanFactory(beanFactory);

         // 实例化并有序的调用实现BeanFactoryPostProcessor接口bean的对应方法
         invokeBeanFactoryPostProcessors(beanFactory);

         // 实例化并有序的注册BeanPostProcessor
         registerBeanPostProcessors(beanFactory);

         // 初始化MessageSource消息源
         initMessageSource();

         // 初始化EventMulticaster事件多播器
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         onRefresh();

         // 注册Listener监听器
         registerListeners();

         // 实例化单例bean
         finishBeanFactoryInitialization(beanFactory);

         // 为refresh收尾
         finishRefresh();
      }

      catch (BeansException ex) {
         //省略代码
         //当出现异常时移除所有缓存的bean并停止刷新工厂
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

2.1 记录容器的启动时间, 标记容器为激活，初始化上下文环境如文件路径信息，验证必填属性是否填写

对应refresh()方法中

prepareRefresh();

prepareRefresh()

protected void prepareRefresh() {
       // 设置启动日期
        this.startupDate = System.currentTimeMillis();
        // 设置 context 当前状态
        this.closed.set(false);
        this.active.set(true);

        if (logger.isInfoEnabled()) {
            logger.info("Refreshing " + this);
        }

        // 初始化context environment（上下文环境）中的占位符属性来源
        initPropertySources();

        // 对属性进行必要的验证
        getEnvironment().validateRequiredProperties();

        this.earlyApplicationEvents = new LinkedHashSet<>();
    }

2.2 创建beanFactory以及扫描bean信息(beanDefinition)

对应refresh()方法中

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

在obtainFreshBeanFactory()中调用了refreshBeanFactory()方法

protected final void refreshBeanFactory() throws BeansException {
   //刷新容器之前存在beanFactory则销毁
   if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
   }
   try {
      //直接new一个DefaultListableBeanFactory
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
      //配置是否允许重复beanName的bean被覆盖、是否允许循环引用，默认都是允许
      customizeBeanFactory(beanFactory);
      //加载bean定义信息
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
         this.beanFactory = beanFactory;
      }
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

loadBeanDefinitions(beanFactory)中加载beanDefinition的主要步骤如下：

先创建XmlBeanDefinitionReader（BeanDefinitionReader接口实现类之一）用来从xml配置文件中读取配置信息，并对BeanDefinitionReader进行相关的配置，如设置Environment等。
依据配置文件所在位置将其转换为Resource，获取流之后使用DOM解析xml获取Document。对于标签来说，会先解析该节点的各种属性，如id、name、class等信息，并将其封装为BeanDefinition，然后把所有的BeanDefinition以beanName为key保存到Map中，如果有别名则将beanName和alias的对应关系保存到对应的Map中。

至此，beanFactory中已经加载了配置文件中所有的bean

2.3 配置BeanFactory的相关特性

对应refresh()方法中

// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);

这一步会对BeanFactory做一些配置以满足使用需求

设置类加载器；
设置EL表达式解析器（Bean创建完成填充属性时使用）和属性注册解析器
利用BeanPostProcessor的特性给各种Aware接口的实现类注入ApplicationContext中对应的属性
设置各种Aware接口的实现类为忽略自动装配
设置自动装配的类（BeanFactory，ResourceLoader，ApplicationEventPublisher，ApplicationContext）
如果BeanFactory中存在loadTimeWeaver的bean，那么需要添加动态织入功能
注册各种可用组件（environment，systemProperties，systemEnvironment）

2.4 实例化并有序的调用BeanFactoryPostProcessor

对应refresh()方法中

// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

总体上就是：分类->排序->注册->执行

根据规定的bean生命周期，所有BeanDefinition都被加载到容器中之后会先实例化并调用实现BeanFactoryPostProcessor接口的bean的对应方法，可以对已经加载到容器中的BeanDefinition做修改。

这里总体上分为两部分，一部分是对实现BeanDefinitionRegistryPostProcessor接口的有序调用，另一部分是对实现BeanFactoryPostProcessor接口的有序调用。

BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor，是对其父类的扩展，主要用来执行对BeanDefinition的添加操作，因此在大的执行顺序上来说应该先将额外的BeanDefinition添加到容器中，在加载完所有需要的BeanDefinition后才应该执行对BeanDefinition的修改操作，主要是为了避免修改容器中还未加载进来的BeanDefinition的情况，所以执行顺序上应该有所保证。

流程如下：

找出容器中实现BeanDefinitionRegistryPostProcessor接口的bean。
在这些bean中找出实现了PriorityOrdered接口的bean，实例化并依据指定的优先级顺序执行。
再找出实现了Ordered接口的bean，实例化并依据指定的优先级顺序执行。
将剩下的bean实例化并执行此接口对应的方法。
调用上述所有处理过的bean的BeanFactoryPostProcessor接口对应的方法，因为BeanDefinitionRegistryPostProcessor接口继承了BeanFactoryPostProcessor，所以实现子接口的bean必须实现父接口定义的方法。
找出实现BeanFactoryPostProcessor接口的bean，并且是没有在上一步处理过的，即找出只实现了BeanFactoryPostProcessor接口的bean。下面的步骤类似上一步。
实例化并有序的执行实现了PriorityOrdered接口的bean。
实例化并有序的执行实现了Ordered接口的bean。
实例化并执行剩余的bean。
至此，容器中所有实现了BeanFactoryPostProcessor接口的bean已经全部实例化并调用完毕。

2.5 实例化并有序的注册BeanPostProcessor

对应refresh()方法中

// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

分类->排序->注册。大体上类似上一步，但这一步不会调用BeanPostProcessor实现类。

先将所有实现了BeanPostProcessor接口的bean找出来，并将其分为三类：实现PriorityOrdered接口的bean、实现Ordered接口的bean、剩余的bean。然后将他们内部排序并注册到beanFactory中，本质上是将排序后的bean存到beanFactory的List中，保证了将来的执行顺序。

2.6 初始化MessageSource消息源主要用于国际化/i18n。

对应refresh()方法中

// Initialize message source for this context.
initMessageSource();

如果父容器中已经定义了MessageSource则使用父容器定义的MessageSource，如果父容器未指定则创建默认的空的MessageSource实现。

2.7 初始化EventMulticaster事件多播器

对应refresh()方法中

// Initialize event multicaster for this context.
initApplicationEventMulticaster();

如果之前已经向容器内添加了beanName为applicationEventMulticaster并且实现了ApplicationEventMulticaster接口的bean，则将该bean设置为当前容器的事件多播器，否则创建默认的事件多播器，默认为SimpleApplicationEventMulticaster。

2.8 给子类扩展初始化其他Bean

对应refresh()方法中

onRefresh();

预留给 AbstractApplicationContext 的子类用于初始化其他特殊的 bean，该方法需要在所有单例 bean 初始化之前调用。

2.9 注册Listener监听器

对应refresh()方法中

registerListeners();

将静态指定的ApplicationListener和容器中实现了ApplicationListener接口的bean作为监听器添加到事件多播器applicationEventMulticaster中，如果在这之前添加了earlyApplicationEvents也就是早期事件，则将这些事件多播给对应的ApplicationListener监听器。

2.10 实例化单例bean

对应refresh()方法中

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

在这个方法中会实例化容器中所有非懒加载的单例bean。

首先，会对容器中所有的beanName遍历，调用getBean(beanName)方法

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	    // 初始化转换器
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// 如果之前没有注册 bean 后置处理器（例如PropertyPlaceholderConfigurer），则注册默认的解析器
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// 停止使用临时的 ClassLoader
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		 // 初始化所有剩余的单例（非延迟初始化）
		beanFactory.preInstantiateSingletons();
	}

其中真正的逻辑在doGetBean()中。在此方法中，首先会调用getSingleton()方法尝试从容器中直接获取该bean。

    protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
        final String beanName = this.transformedBeanName(name);
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        if (sharedInstance != null && args == null) {
            if (this.logger.isDebugEnabled()) {
                if (this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }

            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String nameToLookup = this.originalBeanName(name);
                if (args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }

                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }

            if (!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }

            try {
                final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                if (dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;

                    for(int var13 = 0; var13 < var12; ++var13) {
                        String dependsOnBean = var11[var13];
                        if (this.isDependent(beanName, dependsOnBean)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
                        }

                        this.registerDependentBean(dependsOnBean, beanName);
                        this.getBean(dependsOnBean);
                    }
                }

                if (mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
                        public Object getObject() throws BeansException {
                            try {
                                return AbstractBeanFactory.this.createBean(beanName, mbd, args);
                            } catch (BeansException var2) {
                                AbstractBeanFactory.this.destroySingleton(beanName);
                                throw var2;
                            }
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    var11 = null;

                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
                    String scopeName = mbd.getScope();
                    Scope scope = (Scope)this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
                    }

                    try {
                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                            public Object getObject() throws BeansException {
                                AbstractBeanFactory.this.beforePrototypeCreation(beanName);

                                Object var1;
                                try {
                                    var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);
                                } finally {
                                    AbstractBeanFactory.this.afterPrototypeCreation(beanName);
                                }

                                return var1;
                            }
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var21) {
                        throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; " + "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var21);
                    }
                }
            } catch (BeansException var23) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var23;
            }
        }

        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
            try {
                return this.getTypeConverter().convertIfNecessary(bean, requiredType);
            } catch (TypeMismatchException var22) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Failed to convert bean '" + name + "' to required type [" + ClassUtils.getQualifiedName(requiredType) + "]", var22);
                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }

getSingleton(String beanName, boolean allowEarlyReference) 方法

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   //首先从一级缓存中尝试获取，一级缓存中保存的是完全实例化后的bean，即已经实例化+初始化
   Object singletonObject = this.singletonObjects.get(beanName);
   //如果没找到且需要的bean正在创建中，即所需要的bean已经实例化但未填充属性，说明发生了循环依赖
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         //尝试从二级缓存中获取，二级缓存中保存的是通过ObjectFactory产生的提前引用对象
         singletonObject = this.earlySingletonObjects.get(beanName);
         //如果二级缓存中没有并且允许获取提前引用的话
         if (singletonObject == null && allowEarlyReference) {
            //尝试从三级缓存中获取，三级缓存中保存的是用于创建指定bean提前引用的工厂
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               //调用工厂的方法获取该bean的提前引用
               singletonObject = singletonFactory.getObject();
               //将提前引用放入二级缓存，以后可能会用得到
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

2.11 为refresh收尾

对应refresh()方法中

// Last step: publish corresponding event.
finishRefresh();

protected void finishRefresh() {
		// Initialize lifecycle processor for this context.
		initLifecycleProcessor();

		// Propagate refresh to lifecycle processor first.
		getLifecycleProcessor().onRefresh();

		// Publish the final event.
		publishEvent(new ContextRefreshedEvent(this));

		// Participate in LiveBeansView MBean, if active.
		LiveBeansView.registerApplicationContext(this);
	}

1.清除之前缓存的资源
2.初始化LifecycleProcessor生命周期处理器。如果容器中已经存在了实现LifecycleProcessor接口的bean，则将该bean作为容器的LifecycleProcessor，在容器的各个生命周期会调用LifecycleProcessor的相关回调方法。如果不指定LifecycleProcessor实现类则使用默认的LifecycleProcessor实现类，即DefaultLifecycleProcessor。
3.调用LifecycleProcessor的onRefresh()方法。
4.发布ContextRefreshedEvent事件。
5.处理JMX相关