1. IT分享知识网首页
  2. 开发框架
  3. Spring

Spring源码分析(3)——IOC 源码深度剖析（下）

老牧童 • • Spring, 未分类

Spring源码分析(3)——IOC 源码深度剖析（下）7 IOC 源码深度剖析 7 初始化消息源 initMessageS 方法概述 initMessageS 方法用来设置国际化资源相关的调用 将实现了 MessageSourc 接口的 bean 存放在 A

大家好，欢迎来到IT知识分享网。

7. IOC 源码深度剖析

【7. 初始化消息源】initMessageSource();

方法概述

initMessageSource()方法用来设置国际化资源相关的调用,将实现了MessageSource接口的bean存放在ApplicationContext的成员变量中,先看是否有此配置,如果有就实例化,否则就创建一个DelegatingMessageSource实例的bean

源码剖析

initMessageSource();

 / * Initialize the MessageSource. * Use parent's if none defined in this context. * 初始化消息源,如果没有默认定义则使用父类的消息源 */ protected void initMessageSource() { 
    ConfigurableListableBeanFactory beanFactory = getBeanFactory(); // 如果BeanFactory含有messageSource类型的bean,则将bean消息源使用父消息源 if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) { 
    this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class); // Make MessageSource aware of parent MessageSource. if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) { 
    HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource; if (hms.getParentMessageSource() == null) { 
    // Only set parent context as parent MessageSource if no parent MessageSource // registered already. // 如果已经注册的父上下文没有消息源,则只能将父上下文设置为父消息源 hms.setParentMessageSource(getInternalParentMessageSource()); } } if (logger.isTraceEnabled()) { 
    logger.trace("Using MessageSource [" + this.messageSource + "]"); } } else { 
    // Use empty MessageSource to be able to accept getMessage calls. // 如果BeanFactory不含有messageSource类型的bean,则使用一个空的消息源来接收getMessage()方法的调用 DelegatingMessageSource dms = new DelegatingMessageSource(); // 其实就是获取到父容器的 messageSource 字段（否则就是 getParent() 上下文自己） dms.setParentMessageSource(getInternalParentMessageSource()); // 给当前的 messageSource 赋值 this.messageSource = dms; // 把 messageSource 作为一个单例的 Bean 注册进 beanFactory 工厂里 beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource); if (logger.isTraceEnabled()) { 
    logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]"); } } }

方法总结

初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；

  • 获取BeanFactory
  • 判断容器中是否有id为messageSource的，类型是MessageSource的组件； 如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource； MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
  • 将创建完成的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；

【8. 初始化事件广播器】initApplicationEventMulticaster();

方法概述

初始化应用的事件广播器 ApplicationEventMulticaster。

什么是 Spring 事件？

image-20230814222539742

这块的介绍在官网 1.15.2. Standard and Custom Events[1] 部分有介绍。

” Spring 通过 ApplicationEvent 类和 ApplicationListener 接口提供 ApplicationContext 中的事件处理。如果将实现 ApplicationListener 接口的 bean 部署到上下文中，则每次将 ApplicationEvent 发布到 ApplicationContext 时，都会通知该 bean。本质上，这是标准的观察者设计模式。

归纳下来主要就是三个部分: 事件、事件发布者、事件监听器。

1.1、Spring中的事件(ApplicationEvent)

spring中的事件有一个抽象父类ApplicationEvent，该类包含有当前ApplicationContext的引用，这样就可以确认每个事件是从哪一个Spring容器中发生的。

1.2、Spring中的事件监听器(ApplicationListener)

spring中的事件监听器同样有一个顶级接口ApplicationListener,只有一个onApplicationEvent(E event)方法，当该监听器所监听的事件发生时，就会执行该方法

1.3、Spring中的事件发布者(ApplicationEventPublisher)

spring中的事件发布者同样有一个顶级接口ApplicationEventPublisher，只有一个方法publishEvent(Object event)方法，调用该方法就可以发生spring中的事件

1.4、Spring中的事件广播器（ApplicationEventMulticaster）

spring中的事件核心控制器叫做事件广播器,接口为ApplicationEventMulticaster，广播器的作用主要有两个：

作用一：将事件监听器注册到广播器中，这样广播器就知道了每个事件监听器分别监听什么事件，且知道了每个事件对应哪些事件监听器在监听

作用二：将事件广播给事件监听器，当有事件发生时，需要通过广播器来广播给所有的事件监听器，因为生产者只需要关心事件的生产，而不需要关心该事件都被哪些监听器消费。

使用监听器

简单来说主要分为以下几个部分：

  1. 注册事件
  2. 注册监听器
  3. 发布事件

在接口调用发布事件时，监听器就会做出相应的操作。

源码剖析

protected void initApplicationEventMulticaster() { 
    ConfigurableListableBeanFactory beanFactory = getBeanFactory(); //如果用户配置了自定义事件广播器，就使用用户的（名称必须是 "applicationEventMulticaster"） if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { 
    this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class); if (logger.isTraceEnabled()) { 
    logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]"); } } else { 
    //否则注册一个系统默认的 SimpleApplicationEventMulticaster this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory); beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster); if (logger.isTraceEnabled()) { 
    logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " + "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]"); } } }

方法总结

  • 如果用户配置了自定义事件广播器，就使用用户的（名称必须是 “applicationEventMulticaster”）
  • 否则注册一个系统默认的 SimpleApplicationEventMulticaster

【9.刷新:拓展方法】onRefresh()；

方法描述

空方法，模板设计模式;子类重写该方法并在容器刷新的时候自定义逻辑；

例：springBoot在onRefresh() 完成内置Tomcat的创建及启动

源码剖析

 protected void onRefresh() throws BeansException { 
    // For subclasses: do nothing by default. }

【10.注册监听器】registerListeners();

方法描述

  • 通过addApplicationListener(listen)注册监听器
  • 自定义实现ApplicationListen接口的bd
  • 发布早期的监听器

源码剖析

 protected void registerListeners() { 
    // Register statically specified listeners first. // 查出所有通过addApplicationListener方法添加的ApplicationListener（静态指定的），然后注册到事件广播器上 for (ApplicationListener<?> listener : getApplicationListeners()) { 
    getApplicationEventMulticaster().addApplicationListener(listener); } // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let post-processors apply to them! // 查出ioc容器中的所有ApplicationListener，只把他们注册到事件分发器的ApplicationListenerBean上， // 待使用时再进行实例化 String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false); for (String listenerBeanName : listenerBeanNames) { 
    getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); } // Publish early application events now that we finally have a multicaster... // 这一步需要注意：如果存在早期应用事件，这里就直接发布了(同时就把 earlyApplicationEvents 字段置为 null) Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents; this.earlyApplicationEvents = null; if (!CollectionUtils.isEmpty(earlyEventsToProcess)) { 
    for (ApplicationEvent earlyEvent : earlyEventsToProcess) { 
    getApplicationEventMulticaster().multicastEvent(earlyEvent); } } }

例子：

通过addApplicationListener(listen)注册监听器

其中listen为实现ApplicationListen接口的bd，且该bd不需要注册进容器

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Test.class); // 注册监听器 context.addApplicationListener(listen); // 注册配置类 context.register(Test.class); // 刷新上下文 context.refresh();

方法总结

注册监听器分为两部分:

  1. 向事件分发器注册硬编码设置的applicationListener
  2. 向事件分发器注册一个IOC中的事件监听器（并不实例化）

注意：只是将一些特殊的监听器注册到广播组中,那些在bean配置文件中实现了ApplicationListener接口的类还没有实例化,所以此时只是将name保存到了广播组中,将这些监听器注册到广播组中的操作时在bean的后置处理器中完成的,那时候bean的实例化已经完成了

【11.实例化所有（非惰性初始化）单例Bean】 finishBeanFactoryInitialization(beanFactory);

方法概述

finishBeanFactoryInitialization 是整个 Spring IoC 核心中的核心。

该方法会实例化所有剩余的非懒加载单例 bean。

除了一些内部的 bean、实现了 BeanFactoryPostProcessor 接口的 bean、实现了 BeanPostProcessor 接口的 bean，其他的非懒加载单例 bean 都会在这个方法中被实例化，并且 BeanPostProcessor 的触发也是在这个方法中。

源码剖析_finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
    // Initialize conversion service for this context. // 1、设置此上下文的类型转换器，不是核心，往下 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)); } // Register a default embedded value resolver if no bean post-processor // (such as a PropertyPlaceholderConfigurer bean) registered any before: // at this point, primarily for resolution in annotation attribute values. // 2.如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析 // 不是核心，继续往下 if (!beanFactory.hasEmbeddedValueResolver()) { 
    beanFactory.addEmbeddedValueResolver(new StringValueResolver() { 
    @Override public String resolveStringValue(String strVal) { 
    return getEnvironment().resolvePlaceholders(strVal); } }); } // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. // 3.初始化LoadTimeWeaverAware Bean实例对象 // 处理 @EnableLoadTimeWeaving 或 <context:load-time-weaver/> 标记的类 不是核心，继续往下 String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { 
    getBean(weaverAwareName); } // Stop using the temporary ClassLoader for type matching. //临时类加载器设置为空 beanFactory.setTempClassLoader(null); // Allow for caching all bean definition metadata, not expecting further changes. // 4.冻结所有bean定义，注册的bean定义不会被修改或进一步后处理，因为马上要创建 Bean 实例对象了 // 【冻结配置】：设置冻结属性变量为true beanFactory.freezeConfiguration(); // Instantiate all remaining (non-lazy-init) singletons. // 5.实例化所有剩余（非懒加载）单例对象 beanFactory.preInstantiateSingletons(); }

5.实例化所有剩余（非懒加载）单例对象，见代码块1详解。

MergedBeanDefinition： “合并的 bean 定义”：

之所以称之为 “合并的”，是因为存在 “子定义” 和 “父定义” 的情况。对于一个 bean 定义来说，可能存在以下几种情况：

  1. 该 BeanDefinition 存在 “父定义”：首先使用 “父定义” 的参数构建一个 RootBeanDefinition，然后再使用该 BeanDefinition 的参数来进行覆盖。
  2. 该 BeanDefinition 不存在 “父定义”，并且该 BeanDefinition 的类型是 RootBeanDefinition：直接返回该 RootBeanDefinition 的一个克隆。
  3. 该 BeanDefinition 不存在 “父定义”，但是该 BeanDefinition 的类型不是 RootBeanDefinition：使用该 BeanDefinition 的参数构建一个 RootBeanDefinition。

之所以区分出2和3，是因为通常 BeanDefinition 在之前加载到 BeanFactory 中的时候，通常是被封装成 GenericBeanDefinition 或 ScannedGenericBeanDefinition，但是从这边之后 bean 的后续流程处理都是针对 RootBeanDefinition，因此在这边会统一将 BeanDefinition 转换成 RootBeanDefinition。

在我们日常使用的过程中，通常会是上面的第3种情况 如果我们使用 XML 配置来注册 bean，则该 bean 定义会被封装成：GenericBeanDefinition；如果我们使用注解的方式来注册 bean，也就是<context:component-scan /> + @Compoment，则该 bean 定义会被封装成 ScannedGenericBeanDefinition。

代码块1：preInstantiateSingletons
@Override public void preInstantiateSingletons() throws BeansException { 
    if (this.logger.isDebugEnabled()) { 
    this.logger.debug("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. // 1.创建beanDefinitionNames的副本beanNames用于后续的遍历，以允许init等方法注册新的bean定义 List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... // 2.遍历beanNames，触发所有非懒加载单例bean的初始化 for (String beanName : beanNames) { 
    // 3.获取beanName对应的MergedBeanDefinition RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); // 4.bd对应的Bean实例：不是抽象类 && 是单例 && 不是懒加载 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { 
    // 5.判断beanName对应的bean是否为FactoryBean if (isFactoryBean(beanName)) { 
    // 5.1 通过beanName获取FactoryBean实例 // 通过getBean(&beanName)拿到的是FactoryBean本身；通过getBean(beanName)拿到的是FactoryBean创建的Bean实例 final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName); // 5.2 判断这个FactoryBean是否希望急切的初始化 boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { 
    isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() { 
    @Override public Boolean run() { 
    return ((SmartFactoryBean<?>) factory).isEagerInit(); } }, getAccessControlContext()); } else { 
    isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { 
    // 5.3 如果希望急切的初始化，则通过beanName获取bean实例 getBean(beanName); } } else { 
    // 6.如果beanName对应的bean不是FactoryBean，只是普通Bean，通过beanName获取bean实例 getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... // 7.遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调 for (String beanName : beanNames) { 
    // 7.1 拿到beanName对应的bean实例 Object singletonInstance = getSingleton(beanName); // 7.2 判断singletonInstance是否实现了SmartInitializingSingleton接口 if (singletonInstance instanceof SmartInitializingSingleton) { 
    final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; // 7.3 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法 if (System.getSecurityManager() != null) { 
    AccessController.doPrivileged(new PrivilegedAction<Object>() { 
    @Override public Object run() { 
    smartSingleton.afterSingletonsInstantiated(); return null; } }, getAccessControlContext()); } else { 
    smartSingleton.afterSingletonsInstantiated(); } } } }
  • 3.获取 beanName 对应的 MergedBeanDefinition，见代码块2详解。
  • 5.判断 beanName 对应的 bean 是否为 FactoryBean，见代码块3详解。
  • 5.3 和 6. 通过 beanName 获取 bean 实例，finishBeanFactoryInitialization 方法的核心，单独分析！！。
  • 7.遍历 beanNames，触发所有 SmartInitializingSingleton 的后初始化回调，这是 Spring 提供的一个扩展点，在所有非懒加载单例实例化结束后调用。
代码块2：getMergedLocalBeanDefinition
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException { 
    // Quick check on the concurrent map first, with minimal locking. // 1.检查beanName对应的MergedBeanDefinition是否存在于缓存中 RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName); if (mbd != null) { 
    // 2.如果存在于缓存中则直接返回 return mbd; } // 3.如果不存在于缓存中 // 3.1 getBeanDefinition(beanName)： 获取beanName对应的BeanDefinition，从beanDefinitionMap缓存中获取 // 3.2 getMergedBeanDefinition: 根据beanName和对应的BeanDefinition，获取MergedBeanDefinition return getMergedBeanDefinition(beanName, getBeanDefinition(beanName)); }
代码块3：isFactoryBean
@Override public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException { 
    // 1.拿到真正的beanName（去掉&前缀、解析别名） String beanName = transformedBeanName(name); // 2.尝试从缓存获取Bean实例对象 Object beanInstance = getSingleton(beanName, false); if (beanInstance != null) { 
    // 3.beanInstance存在，则直接判断类型是否为FactoryBean return (beanInstance instanceof FactoryBean); } else if (containsSingleton(beanName)) { 
    // 4.如果beanInstance为null，并且beanName在单例对象缓存中，则代表beanName对应的单例对象为空对象，返回false // null instance registered return false; } // No singleton instance found -> check bean definition. if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) { 
    // 5.如果缓存中不存在此beanName && 父beanFactory是ConfigurableBeanFactory，则调用父BeanFactory判断是否为FactoryBean // No bean definition found in this factory -> delegate to parent. return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name); } // 6.通过MergedBeanDefinition来检查beanName对应的Bean是否为FactoryBean return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName)); }

2.尝试从缓存获取 bean 实例对象，见代码块4详解

代码块4：getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) { 
    // 1.从单例对象缓存中获取beanName对应的单例对象 Object singletonObject = this.singletonObjects.get(beanName); // 2.如果单例对象缓存中没有，并且该beanName对应的单例bean正在创建中 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
    // 3.加锁进行操作 synchronized (this.singletonObjects) { 
    // 4.从早期单例对象缓存中获取单例对象（之所称成为早期单例对象，是因为earlySingletonObjects里 // 的对象的都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作） singletonObject = this.earlySingletonObjects.get(beanName); // 5.如果在早期单例对象缓存中也没有，并且允许创建早期单例对象引用 if (singletonObject == null && allowEarlyReference) { 
    // 6.从单例工厂缓存中获取beanName的单例工厂 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { 
    // 7.如果存在单例对象工厂，则通过工厂创建一个单例对象 singletonObject = singletonFactory.getObject(); // 8.将通过单例对象工厂创建的单例对象，放到早期单例对象缓存中 this.earlySingletonObjects.put(beanName, singletonObject); // 9.移除该beanName对应的单例对象工厂，因为该单例工厂已经创建了一个实例对象，并且放到earlySingletonObjects缓存了， // 因此，后续获取beanName的单例对象，可以通过earlySingletonObjects缓存拿到，不需要在用到该单例工厂 this.singletonFactories.remove(beanName); } } } } // 10.返回单例对象 return (singletonObject != NULL_OBJECT ? singletonObject : null); } public boolean isSingletonCurrentlyInCreation(String beanName) { 
    return this.singletonsCurrentlyInCreation.contains(beanName); }

这段代码很重要，在正常情况下，该代码很普通，只是正常的检查下我们要拿的 bean 实例是否存在于缓存中，如果有就返回缓存中的 bean 实例，否则就返回 null。

这段代码之所以重要，是因为该段代码是 Spring 解决循环引用的核心代码。

解决循环引用逻辑：使用构造函数创建一个 “不完整” 的 bean 实例（之所以说不完整，是因为此时该 bean 实例还未初始化），并且提前曝光该 bean 实例的 ObjectFactory（提前曝光就是将 ObjectFactory 放到 singletonFactories 缓存），通过 ObjectFactory 我们可以拿到该 bean 实例的引用，如果出现循环引用，我们可以通过缓存中的 ObjectFactory 来拿到 bean 实例，从而避免出现循环引用导致的死循环。这边通过缓存中的 ObjectFactory 拿到的 bean 实例虽然拿到的是 “不完整” 的 bean 实例，但是由于是单例，所以后续初始化完成后，该 bean 实例的引用地址并不会变，所以最终我们看到的还是完整 bean 实例。

另外这个代码块中引进了4个重要缓存：

  • singletonObjects 缓存：beanName -> 单例 bean 对象。
  • earlySingletonObjects 缓存：beanName -> 单例 bean 对象，该缓存存放的是早期单例 bean 对象，可以理解成还未进行属性填充、初始化。
  • singletonFactories 缓存：beanName -> ObjectFactory。

【singletonObjects、earlySingletonObjects、singletonFactories 在这边构成了一个类似于 “一、二、三级缓存” 的概念。】

  • singletonsCurrentlyInCreation 缓存：当前正在创建单例 bean 对象的 beanName 集合。

源码剖析_getBean

@Override public Object getBean(String name) throws BeansException { 
    // 获取name对应的bean实例，如果不存在，则创建一个 return doGetBean(name, null, null, false); }

见 doGetBean 方法详解。

doGetBean
protected <T> T doGetBean( final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException { 
    // 1.解析beanName，主要是解析别名、去掉FactoryBean的前缀“&” final String beanName = transformedBeanName(name); Object bean; // Eagerly check singleton cache for manually registered singletons. // 2.尝试从缓存中获取beanName对应的实例 Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { 
    // 3.如果beanName的实例存在于缓存中 if (logger.isDebugEnabled()) { 
    if (isSingletonCurrentlyInCreation(beanName)) { 
    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { 
    logger.debug("Returning cached instance of singleton bean '" + beanName + "'"); } } // 3.1 返回beanName对应的实例对象（主要用于FactoryBean的特殊处理，普通Bean会直接返回sharedInstance本身） bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { 
    // Fail if we're already creating this bean instance: // We're assumably within a circular reference. // 4.scope为prototype的循环依赖校验：如果beanName已经正在创建Bean实例中，而此时我们又要再一次创建beanName的实例，则代表出现了循环依赖，需要抛出异常。 // 例子：如果存在A中有B的属性，B中有A的属性，那么当依赖注入的时候，就会产生当A还未创建完的时候因为对于B的创建再次返回创建A，造成循环依赖 if (isPrototypeCurrentlyInCreation(beanName)) { 
    throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. // 5.获取parentBeanFactory BeanFactory parentBeanFactory = getParentBeanFactory(); // 5.1 如果parentBeanFactory存在，并且beanName在当前BeanFactory不存在Bean定义，则尝试从parentBeanFactory中获取bean实例 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 
    // Not found -> check parent. // 5.2 将别名解析成真正的beanName String nameToLookup = originalBeanName(name); // 5.3 尝试在parentBeanFactory中获取bean对象实例 if (args != null) { 
    // Delegation to parent with explicit args. return (T) parentBeanFactory.getBean(nameToLookup, args); } else { 
    // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup, requiredType); } } if (!typeCheckOnly) { 
    // 6.如果不是仅仅做类型检测，而是创建bean实例，这里要将beanName放到alreadyCreated缓存 markBeanAsCreated(beanName); } try { 
    // 7.根据beanName重新获取MergedBeanDefinition（步骤6将MergedBeanDefinition删除了，这边获取一个新的） final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 7.1 检查MergedBeanDefinition checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. // 8.拿到当前bean依赖的bean名称集合，在实例化自己之前，需要先实例化自己依赖的bean String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { 
    // 8.1 遍历当前bean依赖的bean名称集合 for (String dep : dependsOn) { 
    // 8.2 检查dep是否依赖于beanName，即检查是否存在循环依赖 if (isDependent(beanName, dep)) { 
    // 8.3 如果是循环依赖则抛异常 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } // 8.4 将dep和beanName的依赖关系注册到缓存中 registerDependentBean(dep, beanName); // 8.5 获取dep对应的bean实例，如果dep还没有创建bean实例，则创建dep的bean实例 getBean(dep); } } // Create bean instance. // 9.针对不同的scope进行bean的创建 if (mbd.isSingleton()) { 
    // 9.1 scope为singleton的bean创建（新建了一个ObjectFactory，并且重写了getObject方法） sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() { 
    @Override public Object getObject() throws BeansException { 
    // try { 
    // 9.1.1 创建Bean实例 return createBean(beanName, mbd, args); } catch (BeansException ex) { 
    // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process, to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; } } }); // 9.1.2 返回beanName对应的实例对象 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { 
    // 9.2 scope为prototype的bean创建 // It's a prototype -> create a new instance. Object prototypeInstance = null; try { 
    // 9.2.1 创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中） beforePrototypeCreation(beanName); // 9.2.2 创建Bean实例 prototypeInstance = createBean(beanName, mbd, args); } finally { 
    // 9.2.3 创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除） afterPrototypeCreation(beanName); } // 9.2.4 返回beanName对应的实例对象 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { 
    // 9.3 其他scope的bean创建，可能是request之类的 // 9.3.1 根据scopeName，从缓存拿到scope实例 String scopeName = mbd.getScope(); final Scope scope = this.scopes.get(scopeName); if (scope == null) { 
    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { 
    // 9.3.2 其他scope的bean创建（新建了一个ObjectFactory，并且重写了getObject方法） Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() { 
    @Override public Object getObject() throws BeansException { 
    // 9.3.3 创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中） beforePrototypeCreation(beanName); try { 
    // 9.3.4 创建bean实例 return createBean(beanName, mbd, args); } finally { 
    // 9.3.5 创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除） afterPrototypeCreation(beanName); } } }); // 9.3.6 返回beanName对应的实例对象 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { 
    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", ex); } } } catch (BeansException ex) { 
    // 如果创建bean实例过程中出现异常，则将beanName从alreadyCreated缓存中移除 cleanupAfterBeanCreationFailure(beanName); throw ex; } } // Check if required type matches the type of the actual bean instance. // 10.检查所需类型是否与实际的bean对象的类型匹配 if (requiredType != null && bean != null && !requiredType.isInstance(bean)) { 
    try { 
    // 10.1 类型不对，则尝试转换bean类型 return getTypeConverter().convertIfNecessary(bean, requiredType); } catch (TypeMismatchException ex) { 
    if (logger.isDebugEnabled()) { 
    logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } } // 11.返回创建出来的bean实例对象 return (T) bean; }
    1. 尝试从缓存中获取 beanName 对应的实例，见代码块1详解
  • 3.1 返回 beanName 对应的实例对象（主要用于 FactoryBean 的特殊处理，普通 bean 会直接返回 sharedInstance 本身），见代码块2详解。
  • 9.1 scope 为 singleton 的 bean 创建（新建了一个 ObjectFactory，并且重写了 getObject 方法），见代码块6详解。
  • 9.1.1、9.2.2、9.3.4 创建 bean 实例，单独解析！！。
  • 9.1.2、9.2.4、9.3.6 返回 beanName 对应的实例对象，见代码块7详解。
  • 9.2.1 scope 为 prototype 时创建实例前的操作、9.2.3 scope 为 prototype 时 创建实例后的操作，相对应的两个方法，见代码块5详解。
代码块1：getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) { 
    // 1.从单例对象缓存中获取beanName对应的单例对象 Object singletonObject = this.singletonObjects.get(beanName); // 2.如果单例对象缓存中没有，并且该beanName对应的单例bean正在创建中 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
    // 3.加锁进行操作 synchronized (this.singletonObjects) { 
    // 4.从早期单例对象缓存中获取单例对象（之所称成为早期单例对象，是因为earlySingletonObjects里 // 的对象的都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作） singletonObject = this.earlySingletonObjects.get(beanName); // 5.如果在早期单例对象缓存中也没有，并且允许创建早期单例对象引用 if (singletonObject == null && allowEarlyReference) { 
    // 6.从单例工厂缓存中获取beanName的单例工厂 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { 
    // 7.如果存在单例对象工厂，则通过工厂创建一个单例对象 singletonObject = singletonFactory.getObject(); // 8.将通过单例对象工厂创建的单例对象，放到早期单例对象缓存中 this.earlySingletonObjects.put(beanName, singletonObject); // 9.移除该beanName对应的单例对象工厂，因为该单例工厂已经创建了一个实例对象，并且放到earlySingletonObjects缓存了， // 因此，后续获取beanName的单例对象，可以通过earlySingletonObjects缓存拿到，不需要在用到该单例工厂 this.singletonFactories.remove(beanName); } } } } // 10.返回单例对象 return (singletonObject != NULL_OBJECT ? singletonObject : null); } public boolean isSingletonCurrentlyInCreation(String beanName) { 
    return this.singletonsCurrentlyInCreation.contains(beanName); }

这段代码很重要，在正常情况下，该代码很普通，只是正常的检查下我们要拿的 bean 实例是否存在于缓存中，如果有就返回缓存中的 bean 实例，否则就返回 null。

这段代码之所以重要，是因为该段代码是 Spring 解决循环引用的核心代码。

解决循环引用逻辑：使用构造函数创建一个 “不完整” 的 bean 实例（之所以说不完整，是因为此时该 bean 实例还未初始化），并且提前曝光该 bean 实例的 ObjectFactory（提前曝光就是将 ObjectFactory 放到 singletonFactories 缓存），通过 ObjectFactory 我们可以拿到该 bean 实例的引用，如果出现循环引用，我们可以通过缓存中的 ObjectFactory 来拿到 bean 实例，从而避免出现循环引用导致的死循环。这边通过缓存中的 ObjectFactory 拿到的 bean 实例虽然拿到的是 “不完整” 的 bean 实例，但是由于是单例，所以后续初始化完成后，该 bean 实例的引用地址并不会变，所以最终我们看到的还是完整 bean 实例。

另外这个代码块中引进了4个重要缓存：

  • singletonObjects 缓存：beanName -> 单例 bean 对象。
  • earlySingletonObjects 缓存：beanName -> 单例 bean 对象，该缓存存放的是早期单例 bean 对象，可以理解成还未进行属性填充、初始化。
  • singletonFactories 缓存：beanName -> ObjectFactory。

【singletonObjects、earlySingletonObjects、singletonFactories 在这边构成了一个类似于 “一、二、三级缓存” 的概念。】

  • singletonsCurrentlyInCreation 缓存：当前正在创建单例 bean 对象的 beanName 集合。
代码块2：getObjectForBeanInstance
protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { 
    // Don't let calling code try to dereference the factory if the bean isn't a factory. // 1 如果name以“&”为前缀（以“&”为前缀代表想获取的是FactoryBean本身） if (BeanFactoryUtils.isFactoryDereference(name)) { 
    if (beanInstance instanceof NullBean) { 
    return beanInstance; } // 1.1.如果name以“&”为前缀，但是beanInstance不是FactoryBean，则抛异常 if (!(beanInstance instanceof FactoryBean)) { 
    throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass()); } if (mbd != null) { 
    mbd.isFactoryBean = true; } // 1.2 如果beanInstance是FactoryBean，并且name以“&”为前缀，则直接返回beanInstance（以“&”为前缀代表想获取的是FactoryBean本身） return beanInstance; } // Now we have the bean instance, which may be a normal bean or a FactoryBean. // If it's a FactoryBean, we use it to create a bean instance, unless the // caller actually wants a reference to the factory. if (!(beanInstance instanceof FactoryBean)) { 
    return beanInstance; } Object object = null; if (mbd != null) { 
    mbd.isFactoryBean = true; } else { 
    // 2.如果mbd为空，则尝试从factoryBeanObjectCache缓存中获取该FactoryBean创建的对象实例 object = getCachedObjectForFactoryBean(beanName); } if (object == null) { 
    // Return bean instance from factory. // 3.只有beanInstance是FactoryBean才能走到这边，因此直接强转 FactoryBean<?> factory = (FactoryBean<?>) beanInstance; // Caches object obtained from FactoryBean if it is a singleton. if (mbd == null && containsBeanDefinition(beanName)) { 
    // 4.mbd为空，但是该bean的BeanDefinition在缓存中存在，则获取该bean的MergedBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); } // 5.mbd是否是合成的（这个字段比较复杂，mbd正常情况都不是合成的，也就是false) boolean synthetic = (mbd != null && mbd.isSynthetic()); // 6.从FactoryBean获取对象实例 object = getObjectFromFactoryBean(factory, beanName, !synthetic); } // 7.返回对象实例 return object; }

6.从 FactoryBean 获取对象实例，见代码块2详解。

代码块3：getObjectFromFactoryBean
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) { 
    // 1.如果是单例，并且已经存在于单例对象缓存中 if (factory.isSingleton() && containsSingleton(beanName)) { 
    synchronized (getSingletonMutex()) { 
    // 2.从FactoryBean创建的单例对象的缓存中获取该bean实例 Object object = this.factoryBeanObjectCache.get(beanName); if (object == null) { 
    // 3.调用FactoryBean的getObject方法获取对象实例 object = doGetObjectFromFactoryBean(factory, beanName); // Only post-process and store if not put there already during getObject() call above // (e.g. because of circular reference processing triggered by custom getBean calls) Object alreadyThere = this.factoryBeanObjectCache.get(beanName); // 4.如果该beanName已经在缓存中存在，则将object替换成缓存中的 if (alreadyThere != null) { 
    object = alreadyThere; } else { 
    if (object != null && shouldPostProcess) { 
    try { 
    // 5.对bean实例进行后置处理，执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法 object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwable ex) { 
    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", ex); } } // 6.将beanName和object放到factoryBeanObjectCache缓存中 this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT)); } } // 7.返回object对象实例 return (object != NULL_OBJECT ? object : null); } } else { 
    // 8.调用FactoryBean的getObject方法获取对象实例 Object object = doGetObjectFromFactoryBean(factory, beanName); if (object != null && shouldPostProcess) { 
    try { 
    // 9.对bean实例进行后置处理，执行所有已注册的BeanPostProcessor的postProcessAfterInitialization方法 object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwable ex) { 
    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex); } } // 10.返回object对象实例 return object; } }

3.调用 FactoryBean 的 getObject 方法获取对象实例，见代码块3详解。

5.对 bean 实例进行后续处理，执行所有已注册的 BeanPostProcessor 的 postProcessAfterInitialization 方法，见代码块4详解。

代码块4：doGetObjectFromFactoryBean
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName) throws BeanCreationException { 
    Object object; try { 
    // 1.调用FactoryBean的getObject方法获取bean对象实例 if (System.getSecurityManager() != null) { 
    AccessControlContext acc = getAccessControlContext(); try { 
    object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() { 
    @Override public Object run() throws Exception { 
    // 1.1 带有权限验证的 return factory.getObject(); } }, acc); } catch (PrivilegedActionException pae) { 
    throw pae.getException(); } } else { 
    // 1.2 不带权限 object = factory.getObject(); } } catch (FactoryBeanNotInitializedException ex) { 
    throw new BeanCurrentlyInCreationException(beanName, ex.toString()); } catch (Throwable ex) { 
    throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex); } // Do not accept a null value for a FactoryBean that's not fully // initialized yet: Many FactoryBeans just return null then. // 2.getObject返回的是空值，并且该FactoryBean正在初始化中，则直接抛异常，不接受一个尚未完全初始化的FactoryBean的getObject返回的空值 if (object == null && isSingletonCurrentlyInCreation(beanName)) { 
    throw new BeanCurrentlyInCreationException( beanName, "FactoryBean which is currently in creation returned null from getObject"); } // 3.返回创建好的bean对象实例 return object; }

很简单的方法，就是直接调用 FactoryBean 的 getObject 方法来获取到对象实例。

细心的同学可以发现，该方法是以 do 开头，通常以 do 开头的方法是最终进行实际操作的方法

例如本方法就是 FactoryBean 最终实际进行创建 bean 对象实例的方法。

代码块5：postProcessObjectFromFactoryBean
@Override protected Object postProcessObjectFromFactoryBean(Object object, String beanName) { 
    return applyBeanPostProcessorsAfterInitialization(object, beanName); } @Override public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException { 
    Object result = existingBean; // 1.遍历所有注册的BeanPostProcessor实现类，调用postProcessAfterInitialization方法 for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { 
    // 2.在bean初始化后，调用postProcessAfterInitialization方法 result = beanProcessor.postProcessAfterInitialization(result, beanName); if (result == null) { 
    // 3.如果返回null，则不会调用后续的BeanPostProcessors return result; } } return result; }

在创建完 bean 实例后，会执行 BeanPostProcessor 的 postProcessAfterInitialization 方法。

代码块6：getSingleton
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { 
    Assert.notNull(beanName, "'beanName' must not be null"); // 1.加锁，避免重复创建单例对象 synchronized (this.singletonObjects) { 
    // 2.首先检查beanName对应的bean实例是否在缓存中存在，如果已经存在，则直接返回 Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { 
    // 3.beanName对应的bean实例不存在于缓存中，则进行Bean的创建 if (this.singletonsCurrentlyInDestruction) { 
    // 4.当bean工厂的单例处于destruction状态时，不允许进行单例bean创建，抛出异常 throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); } if (logger.isDebugEnabled()) { 
    logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); } // 5.创建单例前的操作 beforeSingletonCreation(beanName); boolean newSingleton = false; // suppressedExceptions用于记录异常相关信息 boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { 
    this.suppressedExceptions = new LinkedHashSet<Exception>(); } try { 
    // 6.执行singletonFactory的getObject方法获取bean实例 singletonObject = singletonFactory.getObject(); // 标记为新的单例对象 newSingleton = true; } catch (IllegalStateException ex) { 
    // Has the singleton object implicitly appeared in the meantime -> // if yes, proceed with it since the exception indicates that state. singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { 
    throw ex; } } catch (BeanCreationException ex) { 
    if (recordSuppressedExceptions) { 
    for (Exception suppressedException : this.suppressedExceptions) { 
    ex.addRelatedCause(suppressedException); } } throw ex; } finally { 
    if (recordSuppressedExceptions) { 
    this.suppressedExceptions = null; } // 7.创建单例后的操作 afterSingletonCreation(beanName); } if (newSingleton) { 
    // 8.如果是新的单例对象，将beanName和对应的bean实例添加到缓存中（singletonObjects、registeredSingletons） addSingleton(beanName, singletonObject); } } // 9.返回创建出来的单例对象 return (singletonObject != NULL_OBJECT ? singletonObject : null); } }

5.创建单例前的操作，7.创建单例后的操作，这两个方法是对应的，见代码块7详解。

6.执行 singletonFactory 的 getObject 方法获取 bean 实例，该方法会走 doGetBean 方法的注释 9.1.1。

8.如果是新的单例对象，将 beanName 和对应的单例对象添加到缓存中，见代码块8详解

代码块7：beforeSingletonCreation、afterSingletonCreation
protected void beforeSingletonCreation(String beanName) { 
    // 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是， // 则将beanName加入到正在创建bean的缓存中（Set），如果beanName已经存在于该缓存，会返回false抛出异常（这种情况出现在构造器的循环依赖） if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) { 
    throw new BeanCurrentlyInCreationException(beanName); } } protected void afterSingletonCreation(String beanName) { 
    // 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是， // 则将beanName从正在创建bean的缓存中（Set）移除，如果beanName不存在于该缓存，会返回false抛出异常 if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) { 
    throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation"); } }

inCreationCheckExclusions 是要在创建检查排除掉的 beanName 集合，正常为空，可以不管。这边主要是引入了 singletonsCurrentlyInCreation 缓存：当前正在创建的 bean 的 beanName 集合。在 beforeSingletonCreation 方法中，通过添加 beanName 到该缓存，可以预防出现构造器循环依赖的情况。

为什么无法解决构造器循环依赖？

  • 在finishBeanFactoryInitialization详解 中的代码块7提过，getSingleton 方法是解决循环引用的核心代码。
  • 解决逻辑的第一句话：“我们先用构造函数创建一个 “不完整” 的 bean 实例”，从这句话可以看出，构造器循环依赖是无法解决的，因为当构造器出现循环依赖，我们连 “不完整” 的 bean 实例都构建不出来。
  • Spring 能解决的循环依赖有：通过 setter 注入的循环依赖、通过属性注入的循环依赖。
代码块8：addSingleton
protected void addSingleton(String beanName, Object singletonObject) { 
    synchronized (this.singletonObjects) { 
    // 1.添加到单例对象缓存 this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT)); // 2.将单例工厂缓存移除（已经不需要） this.singletonFactories.remove(beanName); // 3.将早期单例对象缓存移除（已经不需要） this.earlySingletonObjects.remove(beanName); // 4.添加到已经注册的单例对象缓存 this.registeredSingletons.add(beanName); } }

源码剖析_createBean

【实例化】createBean
@Override protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException { 
    if (logger.isDebugEnabled()) { 
    logger.debug("Creating instance of bean '" + beanName + "'"); } RootBeanDefinition mbdToUse = mbd; // Make sure bean class is actually resolved at this point, and // clone the bean definition in case of a dynamically resolved Class // which cannot be stored in the shared merged bean definition. // 1.解析beanName对应的Bean的类型，例如：com.itheima.open.demo.service.impl.UserServiceImpl Class<?> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 
    // 如果resolvedClass存在，并且mdb的beanClass类型不是Class，并且mdb的beanClass不为空（则代表beanClass存的是Class的name）, // 则使用mdb深拷贝一个新的RootBeanDefinition副本，并且将解析的Class赋值给拷贝的RootBeanDefinition副本的beanClass属性， // 该拷贝副本取代mdb用于后续的操作 mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // Prepare method overrides. try { 
    // 2.验证及准备覆盖的方法（对override属性进行标记及验证） mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { 
    throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex); } try { 
    // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. // 3.实例化前的处理，给InstantiationAwareBeanPostProcessor一个机会返回代理对象来替代真正的bean实例，达到“短路”效果 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); // 4.如果bean不为空，则会跳过Spring默认的实例化过程，直接使用返回的bean if (bean != null) { 
    return bean; } } catch (Throwable ex) { 
    throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); } // 5.创建Bean实例（真正创建Bean的方法） Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isDebugEnabled()) { 
    logger.debug("Finished creating instance of bean '" + beanName + "'"); } // 6.返回创建的Bean实例 return beanInstance; }

5.创建 bean 实例，见代码块1详解

代码块1：doCreateBean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) throws BeanCreationException { 
    // Instantiate the bean. // 1.新建Bean包装类 BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { 
    // 2.如果是FactoryBean，则需要先移除未完成的FactoryBean实例的缓存 instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { 
    // 3.根据beanName、mbd、args，使用对应的策略创建Bean实例，并返回包装类BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args); } // 4.拿到创建好的Bean实例 final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null); // 5.拿到Bean实例的类型 Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null); mbd.resolvedTargetType = beanType; // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { 
    if (!mbd.postProcessed) { 
    try { 
    // 6.应用后置处理器MergedBeanDefinitionPostProcessor，允许修改MergedBeanDefinition， // Autowired注解正是通过此方法实现注入类型的预解析 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { 
    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. // 7.判断是否需要提早曝光实例：单例 && 允许循环依赖 && 当前bean正在创建中 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { 
    if (logger.isDebugEnabled()) { 
    logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } // 8.提前曝光beanName的ObjectFactory，用于解决循环引用 addSingletonFactory(beanName, new ObjectFactory<Object>() { 
    @Override public Object getObject() throws BeansException { 
    // 8.1 应用后置处理器SmartInstantiationAwareBeanPostProcessor，允许返回指定bean的早期引用，若没有则直接返回bean return getEarlyBeanReference(beanName, mbd, bean); } }); } // Initialize the bean instance. 初始化bean实例。 Object exposedObject = bean; try { 
    // 9.对bean进行属性填充；其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean实例 populateBean(beanName, mbd, instanceWrapper); if (exposedObject != null) { 
    // 10.对bean进行初始化 exposedObject = initializeBean(beanName, exposedObject, mbd); } } catch (Throwable ex) { 
    if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { 
    throw (BeanCreationException) ex; } else { 
    throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } if (earlySingletonExposure) { 
    // 11.如果允许提前曝光实例，则进行循环依赖检查 Object earlySingletonReference = getSingleton(beanName, false); // 11.1 earlySingletonReference只有在当前解析的bean存在循环依赖的情况下才会不为空 if (earlySingletonReference != null) { 
    if (exposedObject == bean) { 
    // 11.2 如果exposedObject没有在initializeBean方法中被增强，则不影响之前的循环引用 exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
    // 11.3 如果exposedObject在initializeBean方法中被增强 && 不允许在循环引用的情况下使用注入原始bean实例 // && 当前bean有被其他bean依赖 // 11.4 拿到依赖当前bean的所有bean的beanName数组 String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length); for (String dependentBean : dependentBeans) { 
    // 11.5 尝试移除这些bean的实例，因为这些bean依赖的bean已经被增强了，他们依赖的bean相当于脏数据 if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
    // 11.6 移除失败的添加到 actualDependentBeans actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { 
    // 11.7 如果存在移除失败的，则抛出异常，因为存在bean依赖了“脏数据” throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example."); } } } } // Register bean as disposable. try { 
    // 12.注册用于销毁的bean，执行销毁操作的有三种：自定义destroy方法、DisposableBean接口、DestructionAwareBeanPostProcessor registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { 
    throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } // 13.完成创建并返回 return exposedObject; }

3.根据 beanName、mbd、args，使用对应的策略创建 bean 实例，并返回包装类 BeanWrapper，见代码块2详解。

代码块2：createBeanInstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) { 
    // Make sure bean class is actually resolved at this point. // 解析bean的类型信息 Class<?> beanClass = resolveBeanClass(mbd, beanName); if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { 
    // beanClass不为空 && beanClass不是公开类（不是public修饰） && 该bean不允许访问非公共构造函数和方法，则抛异常 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName()); } // 1.如果存在工厂方法则使用工厂方法实例化bean对象 if (mbd.getFactoryMethodName() != null) { 
    return instantiateUsingFactoryMethod(beanName, mbd, args); } // Shortcut when re-creating the same bean... // resolved: 构造函数或工厂方法是否已经解析过 boolean resolved = false; // autowireNecessary: 是否需要自动注入（即是否需要解析构造函数参数） boolean autowireNecessary = false; if (args == null) { 
    // 2.加锁 synchronized (mbd.constructorArgumentLock) { 
    if (mbd.resolvedConstructorOrFactoryMethod != null) { 
    // 2.1 如果resolvedConstructorOrFactoryMethod缓存不为空，则将resolved标记为已解析 resolved = true; // 2.2 根据constructorArgumentsResolved判断是否需要自动注入 autowireNecessary = mbd.constructorArgumentsResolved; } } } if (resolved) { 
    // 3.如果已经解析过，则使用resolvedConstructorOrFactoryMethod缓存里解析好的构造函数方法 if (autowireNecessary) { 
    // 3.1 需要自动注入，则执行构造函数自动注入 return autowireConstructor(beanName, mbd, null, null); } else { 
    // 3.2 否则使用默认的构造函数进行bean的实例化 return instantiateBean(beanName, mbd); } } // Need to determine the constructor... // 4.应用后置处理器SmartInstantiationAwareBeanPostProcessor，拿到bean的候选构造函数 Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { 
    // 5.如果ctors不为空 || mbd的注入方式为AUTOWIRE_CONSTRUCTOR || mdb定义了构造函数的参数值 || args不为空，则执行构造函数自动注入 return autowireConstructor(beanName, mbd, ctors, args); } // No special handling: simply use no-arg constructor. // 6.没有特殊处理，则使用默认的构造函数进行bean的实例化 return instantiateBean(beanName, mbd); }
instantiateBean(beanName, mbd);
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) { 
    try { 
    Object beanInstance; if (System.getSecurityManager() != null) { 
    // 是不是有java安全管理之类的设置，没有，跳过 beanInstance = AccessController.doPrivileged( (PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this), getAccessControlContext()); } else { 
    // 实例化（ 进入），ctor.newInstance！ // 对象诞生在这里！！！ beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this); } // 包装一下，返回 BeanWrapper bw = new BeanWrapperImpl(beanInstance); initBeanWrapper(bw); return bw; } catch (Throwable ex) { 
    throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex); } }

单例对象实例化完成，回到doCreateBean()方法，对象实例化完成后要存入三级缓存（为了后面解决循环依赖）：详见代码块3

代码块3：addSingletonFactory
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) { 
    Assert.notNull(singletonFactory, "Singleton factory must not be null"); synchronized (this.singletonObjects) { 
    // 1.如果beanName不存在于singletonObjects缓存 if (!this.singletonObjects.containsKey(beanName)) { 
    // 2.将beanName和singletonFactory注册到singletonFactories缓存(三级缓存)（beanName -> 该beanName的单例工厂） this.singletonFactories.put(beanName, singletonFactory); // 3.移除earlySingletonObjects缓存中的beanName（beanName -> beanName的早期单例对象） this.earlySingletonObjects.remove(beanName); // 4.将beanName注册到registeredSingletons缓存（已经注册的单例集合） this.registeredSingletons.add(beanName); } } }
【属性注入】populateBean
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) { 
    // 1.返回此bean的属性值 PropertyValues pvs = mbd.getPropertyValues(); // 2.bw为空时的处理 if (bw == null) { 
    if (!pvs.isEmpty()) { 
    // 2.1 如果bw为空，属性不为空，抛异常，无法将属性值应用于null实例 throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance"); } else { 
    // Skip property population phase for null instance. // 2.2 如果bw为空，属性也为空，则跳过 return; } } // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the // state of the bean before properties are set. This can be used, for example, // to support styles of field injection. // 用于标识是否继续之后的属性填充 boolean continueWithPropertyPopulation = true; if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { 
    // 3.1 如果mbd不是合成的 && 存在InstantiationAwareBeanPostProcessor，则遍历处理InstantiationAwareBeanPostProcessor for (BeanPostProcessor bp : getBeanPostProcessors()) { 
    if (bp instanceof InstantiationAwareBeanPostProcessor) { 
    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; // 3.2 在bean实例化后，属性填充之前被调用，允许修改bean的属性，如果返回false，则跳过之后的属性填充 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { 
    // 3.3 如果返回false，将continueWithPropertyPopulation赋值为false，代表要跳过之后的属性填充 continueWithPropertyPopulation = false; break; } } } } // 3.4 如果continueWithPropertyPopulation为false，则跳过之后的属性填充 if (!continueWithPropertyPopulation) { 
    return; } // 4.解析自动装配模式为AUTOWIRE_BY_NAME和AUTOWIRE_BY_TYPE（现在几乎不用） if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
    MutablePropertyValues newPvs = new MutablePropertyValues(pvs); if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { 
    // 4.1 解析autowireByName的注入 autowireByName(beanName, mbd, bw, newPvs); } if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
    // 4.2 解析autowireByType的注入 autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } // 5.BeanFactory是否注册过InstantiationAwareBeanPostProcessors boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); // 6.是否需要依赖检查 boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE); // 7.注册过InstantiationAwareBeanPostProcessors 或者 需要依赖检查 if (hasInstAwareBpps || needsDepCheck) { 
    PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); if (hasInstAwareBpps) { 
    // 7.1 应用后置处理器InstantiationAwareBeanPostProcessor for (BeanPostProcessor bp : getBeanPostProcessors()) { 
    if (bp instanceof InstantiationAwareBeanPostProcessor) { 
    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; // 7.1.1 应用后置处理器InstantiationAwareBeanPostProcessor的方法postProcessPropertyValues， // 进行属性填充前的再次处理。例子：现在最常用的@Autowire属性注入就是这边注入依赖的bean实例对象 pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvs == null) { 
    return; } } } } if (needsDepCheck) { 
    // 7.2 依赖检查，对应depends-on属性 checkDependencies(beanName, mbd, filteredPds, pvs); } } // 8.将所有PropertyValues中的属性填充到bean中 applyPropertyValues(beanName, mbd, bw, pvs); }

populateBean(...)是根据BeanDefinition将属性赋值到刚创建的对象中，主要的逻辑在applyPropertyValues(...)中执行，详见代码1

代码1：applyPropertyValues
 protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { 
    // 若没有要注入的属性，直接返回 if (pvs.isEmpty()) { 
    return; } if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) { 
    ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext()); } MutablePropertyValues mpvs = null; List<PropertyValue> original; // 1.获取属性值列表 if (pvs instanceof MutablePropertyValues) { 
    mpvs = (MutablePropertyValues) pvs; // 1.1 如果mpvs中的值已经被转换为对应的类型，那么可以直接设置到BeanWrapper中 if (mpvs.isConverted()) { 
    // Shortcut: use the pre-converted values as-is. try { 
    bw.setPropertyValues(mpvs); return; } catch (BeansException ex) { 
    throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Error setting property values", ex); } } original = mpvs.getPropertyValueList(); } else { 
    // 1.2 如果pvs并不是使用MutablePropertyValues封装的类型，那么直接使用原始的属性获取方法 original = Arrays.asList(pvs.getPropertyValues()); } // 显然，若调用者没有自定义转换器，那就使用BeanWrapper本身~~~（因为BeanWrapper实现了TypeConverter 接口~~） TypeConverter converter = getCustomTypeConverter(); if (converter == null) { 
    converter = bw; } // 2.1 创建属性解析器(主要完成属性值的处理，包括依赖其他bean的创建) BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter); // Create a deep copy, resolving any references for values. // 2.2 创建深层拷贝副本，用于存放解析后的属性值 List<PropertyValue> deepCopy = new ArrayList<>(original.size()); boolean resolveNecessary = false; // 3.遍历属性，将属性转换为对应类的对应属性的类型 for (PropertyValue pv : original) { 
    if (pv.isConverted()) { 
    // 3.1 如果pv已经包含转换的值，则直接添加到deepCopy deepCopy.add(pv); } else { 
    // 3.2 否则，进行转换 // 3.2.1 获取属性名称 String propertyName = pv.getName(); // 3.2.2 使用解析器解析不同类型的值 Object originalValue = pv.getValue(); // AutowiredPropertyMarker.INSTANCE 自动生成标记的规范实例（不进入） if (originalValue == AutowiredPropertyMarker.INSTANCE) { 
    Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod(); if (writeMethod == null) { 
    throw new IllegalArgumentException("Autowire marker for property without write method: " + pv); } originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true); } /* * 【重点】使用解析器解析不同类型的值（包括循环依赖的解决） */ Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); // 将值包装到deepCopy的list中 Object convertedValue = resolvedValue; boolean convertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName); // 属性类型转换器，如果有定义的类型转换，就发生在这里 convertForProperty if (convertible) { 
    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter); } // Possibly store converted value in merged bean definition, // in order to avoid re-conversion for every created bean instance. if (resolvedValue == originalValue) { 
    if (convertible) { 
    pv.setConvertedValue(convertedValue); } deepCopy.add(pv); } else if (convertible && originalValue instanceof TypedStringValue && !((TypedStringValue) originalValue).isDynamic() && !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) { 
    pv.setConvertedValue(convertedValue); deepCopy.add(pv); } else { 
    resolveNecessary = true; deepCopy.add(new PropertyValue(pv, convertedValue)); } } } if (mpvs != null && !resolveNecessary) { 
    mpvs.setConverted(); } // Set our (possibly massaged) deep copy. try { 
    // 最后通过反射setXXXX()来设置属性值!!!【关键点】 bw.setPropertyValues(new MutablePropertyValues(deepCopy)); } catch (BeansException ex) { 
    throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Error setting property values", ex); } }

主要逻辑是如下：

  1. 创建属性解析器valueResolver， 之后循环BeanDefinition中的属性列表，使用解析器对每个property进行实际值的解析(保存创建依赖bean对象)
  2. 根据属性的名称将属性值赋值到对象中

4.涉及到循环依赖的逻辑是valueResolver.resolveValueIfNecessary(pv, originalValue),使用属性解析器获取property的实际内容，下面我们看下如何解析property的(只看依赖其他bean的property)：详见代码块2

代码块2：resolveValueIfNecessary
//org.springframework.beans.factory.support.BeanDefinitionValueResolver#resolveValueIfNecessary @Nullable public Object resolveValueIfNecessary(Object argName, @Nullable Object value) { 
    // We must check each value to see whether it requires a runtime reference // to another bean to be resolved. //处理依赖其他bean的property if (value instanceof RuntimeBeanReference) { 
    RuntimeBeanReference ref = (RuntimeBeanReference) value; return resolveReference(argName, ref); } //省略... } //详细处理逻辑 @Nullable private Object resolveReference(Object argName, RuntimeBeanReference ref) { 
    try { 
    Object bean; //获取依赖bean名称 String refName = ref.getBeanName(); refName = String.valueOf(doEvaluate(refName)); //依赖是否属于父容器 if (ref.isToParent()) { 
    if (this.beanFactory.getParentBeanFactory() == null) { 
    throw new BeanCreationException( this.beanDefinition.getResourceDescription(), this.beanName, "Can't resolve reference to bean '" + refName + "' in parent factory: no parent factory available"); } bean = this.beanFactory.getParentBeanFactory().getBean(refName); } else { 
    //嵌套调用IOC容器的getBean方法 bean = this.beanFactory.getBean(refName); this.beanFactory.registerDependentBean(refName, this.beanName); } if (bean instanceof NullBean) { 
    bean = null; } return bean; } catch (BeansException ex) { 
    throw new BeanCreationException( this.beanDefinition.getResourceDescription(), this.beanName, "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex); } }

上述逻辑比较清晰简单，就是根据依赖的beanName嵌套调用this.beanFactory.getBean(refName)去创建所依赖对象，创建完成后返回该bean信息。

【初始化】initializeBean
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) { 
    // 1.激活Aware方法 if (System.getSecurityManager() != null) { 
    AccessController.doPrivileged(new PrivilegedAction<Object>() { 
    @Override public Object run() { 
    invokeAwareMethods(beanName, bean); return null; } }, getAccessControlContext()); } else { 
    invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { 
    // 2.在初始化前应用BeanPostProcessor的postProcessBeforeInitialization方法，允许对bean实例进行包装 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { 
    // 3.调用初始化方法 invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { 
    throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } if (mbd == null || !mbd.isSynthetic()) { 
    // 4.在初始化后应用BeanPostProcessor的postProcessAfterInitialization方法，允许对bean实例进行包装 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } // 5.返回wrappedBean return wrappedBean; }

1.激活 Aware方法，见代码块1详解。

2.在初始化前应用后置处理器 BeanPostProcessor 的 postProcessBeforeInitialization 方法，允许对 bean 实例进行包装，见代码块2详解。

3.调用初始化方法，见代码块3详解。

4.在初始化后应用后置处理器 BeanPostProcessor 的 postProcessAfterInitialization 方法，允许对 bean 实例进行包装，见代码块5详解。

代码块1：invokeAwareMethods
private void invokeAwareMethods(final String beanName, final Object bean) { 
    if (bean instanceof Aware) { 
    // BeanNameAware: 实现此接口的类想要拿到beanName，因此我们在这边赋值给它 if (bean instanceof BeanNameAware) { 
    ((BeanNameAware) bean).setBeanName(beanName); } // BeanClassLoaderAware：实现此接口的类想要拿到beanClassLoader，因此我们在这边赋值给它 if (bean instanceof BeanClassLoaderAware) { 
    ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader()); } // BeanFactoryAware: 实现此接口的类想要拿到 BeanFactory，因此我们在这边赋值给它 if (bean instanceof BeanFactoryAware) { 
    ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this); } } }

如果对 Spring 比较熟悉的同学应该知道，以 Aware 为结尾的类都是一些扩展接口，用于提供给开发者获取到 BeanFactory 中的一些属性或对象。

代码块2：applyBeanPostProcessorsBeforeInitialization
@Override public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException { 
    Object result = existingBean; // 1.遍历所有注册的BeanPostProcessor实现类，调用postProcessBeforeInitialization方法 for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { 
    // 2.在bean初始化方法执行前，调用postProcessBeforeInitialization方法 result = beanProcessor.postProcessBeforeInitialization(result, beanName); if (result == null) { 
    return result; } } return result; }

在 bean 初始化前，调用所有 BeanPostProcessors 的 postProcessBeforeInitialization 方法

代码块3：invokeInitMethods
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd) throws Throwable { 
    // 1.首先检查bean是否实现了InitializingBean接口，如果是的话调用afterPropertiesSet方法 boolean isInitializingBean = (bean instanceof InitializingBean); if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) { 
    if (logger.isDebugEnabled()) { 
    logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'"); } // 2.调用afterPropertiesSet方法 if (System.getSecurityManager() != null) { 
    try { 
    AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() { 
    @Override public Object run() throws Exception { 
    ((InitializingBean) bean).afterPropertiesSet(); return null; } }, getAccessControlContext()); } catch (PrivilegedActionException pae) { 
    throw pae.getException(); } } else { 
    ((InitializingBean) bean).afterPropertiesSet(); } } if (mbd != null) { 
    String initMethodName = mbd.getInitMethodName(); if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) { 
    // 3.调用自定义初始化方法 invokeCustomInitMethod(beanName, bean, mbd); } } }

2.调用自定义初始化方法，见代码块4详解。

代码块4：invokeCustomInitMethod
protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd) throws Throwable { 
    // 1.拿到初始化方法的方法名 String initMethodName = mbd.getInitMethodName(); // 2.根据方法名拿到方法 final Method initMethod = (mbd.isNonPublicAccessAllowed() ? BeanUtils.findMethod(bean.getClass(), initMethodName) : ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName)); if (initMethod == null) { 
    // 3.如果不存在initMethodName对应的方法，并且是强制执行初始化方法(默认为强制), 则抛出异常 if (mbd.isEnforceInitMethod()) { 
    throw new BeanDefinitionValidationException("Couldn't find an init method named '" + initMethodName + "' on bean with name '" + beanName + "'"); } else { 
    // 如果设置了非强制，找不到则直接返回 if (logger.isDebugEnabled()) { 
    logger.debug("No default init method named '" + initMethodName + "' found on bean with name '" + beanName + "'"); } // Ignore non-existent default lifecycle methods. return; } } if (logger.isDebugEnabled()) { 
    logger.debug("Invoking init method '" + initMethodName + "' on bean with name '" + beanName + "'"); } // 4.调用初始化方法 if (System.getSecurityManager() != null) { 
    AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() { 
    @Override public Object run() throws Exception { 
    ReflectionUtils.makeAccessible(initMethod); return null; } }); try { 
    AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() { 
    @Override public Object run() throws Exception { 
    initMethod.invoke(bean); return null; } }, getAccessControlContext()); } catch (PrivilegedActionException pae) { 
    InvocationTargetException ex = (InvocationTargetException) pae.getException(); throw ex.getTargetException(); } } else { 
    try { 
    ReflectionUtils.makeAccessible(initMethod); initMethod.invoke(bean); } catch (InvocationTargetException ex) { 
    throw ex.getTargetException(); } } }
代码块5：applyBeanPostProcessorsAfterInitialization
@Override public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException { 
    Object result = existingBean; // 1.遍历所有注册的BeanPostProcessor实现类，调用postProcessAfterInitialization方法 for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { 
    // 2.在bean初始化方法执行后，调用postProcessAfterInitialization方法 result = beanProcessor.postProcessAfterInitialization(result, beanName); if (result == null) { 
    return result; } } return result; }
【注册销毁方法】registerDisposableBeanIfNecessary

销毁方法有三种：

public class DestroyMethodBean implements DisposableBean { 
    //jdk的注解 @PreDestroy public void preDestroy(){ 
    System.out.println("======@PreDestroy======"); } @Override public void destroy(){ 
    System.out.println("======DisposableBean.destroy()======"); } //基于配置 public void destroyMethod(){ 
    System.out.println("======<destroy-method>======"); } }
registerDisposableBeanIfNecessary
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) { 
    AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null); // 1.mbd的scope不是prototype && 给定的bean需要在关闭时销毁 if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) { 
    if (mbd.isSingleton()) { 
    // 2.单例模式下注册用于销毁的bean到disposableBeans缓存，执行给定bean的所有销毁工作： // DestructionAwareBeanPostProcessors，DisposableBean接口，自定义销毁方法 // 2.1 DisposableBeanAdapter：使用DisposableBeanAdapter来封装用于销毁的bean registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc)); } else { 
    // 3.自定义scope处理 // A bean with a custom scope... Scope scope = this.scopes.get(mbd.getScope()); if (scope == null) { 
    throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'"); } scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc)); } } }

1.requiresDestruction(bean, mbd)：判断给定的 bean 是否需要在关闭时销毁，见代码块1详解。

2.1 使用 DisposableBeanAdapter 来封装用于销毁的 bean，见代码块2详解。

要注册销毁方法，Bean需要至少满足以下三个条件之一：

（1）Bean是DisposableBean的实现类，此时执行DisposableBean的接口方法destroy()

（2）Bean标签中有配置destroy-method属性，此时执行destroy-method配置指定的方法

（3）当前Bean对应的BeanFactory中持有DestructionAwareBeanPostProcessor接口的实现类，此时执行DestructionAwareBeanPostProcessor的接口方法postProcessBeforeDestruction

在满足上面三个条件之一的情况下，容器便会注册销毁该Bean，注册Bean的方法很简单，见registerDisposableBean方法实现：见代码3详解

代码块1：requiresDestruction
protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) { 
    // 1.DisposableBeanAdapter.hasDestroyMethod(bean, mbd)：判断bean是否有destroy方法 // 2.hasDestructionAwareBeanPostProcessors()：判断当前BeanFactory是否注册过DestructionAwareBeanPostProcessor // 3.DisposableBeanAdapter.hasApplicableProcessors：是否存在适用于bean的DestructionAwareBeanPostProcessor return (bean != null && (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || (hasDestructionAwareBeanPostProcessors() && DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors())))); }

1.DisposableBeanAdapter.hasDestroyMethod(bean, mbd)：判断 bean 是否有 destroy 方法，见代码块20详解。

3.DisposableBeanAdapter.hasApplicableProcessors：是否存在适用于 bean 的 DestructionAwareBeanPostProcessor，见代码块21详解。

public static boolean hasDestroyMethod(Object bean, RootBeanDefinition beanDefinition) { 
    if (bean instanceof DisposableBean || closeableInterface.isInstance(bean)) { 
    // 1.如果bean实现了DisposableBean接口 或者 bean是AutoCloseable实例，则返回true return true; } // 2.拿到bean自定义的destroy方法名 String destroyMethodName = beanDefinition.getDestroyMethodName(); if (AbstractBeanDefinition.INFER_METHOD.equals(destroyMethodName)) { 
    // 3.如果自定义的destroy方法名为“(inferred)”（该名字代表需要我们自己去推测destroy的方法名）， // 则检查该bean是否存在方法名为“close”或“shutdown”的方法，如果存在，则返回true return (ClassUtils.hasMethod(bean.getClass(), CLOSE_METHOD_NAME) || ClassUtils.hasMethod(bean.getClass(), SHUTDOWN_METHOD_NAME)); } // 4.如果destroyMethodName不为空，则返回true return StringUtils.hasLength(destroyMethodName); }

1.如果 bean 实现了 DisposableBean 接口或 bean 是 AutoCloseable 实例，则返回 true，因为这两个接口都有关闭的方法。

代码块2：DisposableBeanAdapter
public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition, List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) { 
    Assert.notNull(bean, "Disposable bean must not be null"); this.bean = bean; this.beanName = beanName; this.invokeDisposableBean = //实现了DisposableBean && 没有叫destroy的被@PreDestroy注解的方法 (this.bean instanceof DisposableBean && !beanDefinition.isExternallyManagedDestroyMethod("destroy")); this.nonPublicAccessAllowed = beanDefinition.isNonPublicAccessAllowed(); this.acc = acc; //<destroy-method>设置的值 String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition); //<destroy-method> 有值 && （没有既实现DisposableBean，<destroy-method>值又叫destroy） && 被@PreDestroy注解的方法不叫<destroy-method>值 //其实就是三种方法的名字互相不能相同 if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) && !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) { 
    this.destroyMethodName = destroyMethodName; this.destroyMethod = determineDestroyMethod(destroyMethodName); if (this.destroyMethod == null) { 
    if (beanDefinition.isEnforceDestroyMethod()) { 
    throw new BeanDefinitionValidationException("Could not find a destroy method named '" + destroyMethodName + "' on bean with name '" + beanName + "'"); } } else { 
    Class<?>[] paramTypes = this.destroyMethod.getParameterTypes(); if (paramTypes.length > 1) { 
    throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" + beanName + "' has more than one parameter - not supported as destroy method"); } else if (paramTypes.length == 1 && boolean.class != paramTypes[0]) { 
    throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" + beanName + "' has a non-boolean parameter - not supported as destroy method"); } } } //可以过滤出InitDestroyAnnotationBeanPostProcessor this.beanPostProcessors = filterPostProcessors(postProcessors, bean); }
代码块3：registerDisposableBean
public void registerDisposableBean(String beanName, DisposableBean bean) { 
    synchronized (this.disposableBeans) { 
    this.disposableBeans.put(beanName, bean); } }

容器销毁的时候，会遍历disposableBeans，逐一执行销毁方法。

关闭容器时：会调用DisposableBeanAdapter的destroy()方法

public void destroy() { 
    // 执行@PreDestroy方法 if (!CollectionUtils.isEmpty(this.beanPostProcessors)) { 
    for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) { 
    processor.postProcessBeforeDestruction(this.bean, this.beanName); } } // bean实现了 DisposableBean 接口而且前面通过后置处理器找到的destroyName不是 "destroy" if (this.invokeDisposableBean) { 
    if (logger.isTraceEnabled()) { 
    logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'"); } try { 
    if (System.getSecurityManager() != null) { 
    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> { 
    ((DisposableBean) this.bean).destroy(); return null; }, this.acc); } else { 
    ((DisposableBean) this.bean).destroy(); } } catch (Throwable ex) { 
    String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'"; if (logger.isDebugEnabled()) { 
    logger.warn(msg, ex); } else { 
    logger.warn(msg + ": " + ex); } } } // 在构造函数中 得到的 destroyName if (this.destroyMethod != null) { 
    invokeCustomDestroyMethod(this.destroyMethod); } else if (this.destroyMethodName != null) { 
    Method methodToInvoke = determineDestroyMethod(this.destroyMethodName); if (methodToInvoke != null) { 
    invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke)); } } }

方法总结

在 finishBeanFactoryInitialization 方法中，我们主要做了以下操作：

  • 将之前解析的 BeanDefinition 进一步处理，将有父 BeanDefinition 的进行合并，获得 MergedBeanDefinition
  • 尝试从缓存获取 bean 实例
  • 处理特殊的 bean —— FactoryBean 的创建
  • 创建 bean 实例
  • 循环引用的处理
  • bean 实例属性填充
  • bean 实例的初始化
  • BeanPostProcessor 的各种扩展应用

finishBeanFactoryInitialization 方法解析的结束，也标志着 Spring IoC 整个构建过程中，重要的内容基本都已经解析完毕

【12. 结束refresh操作】finishRefresh();

方法概述

完成此上下文的刷新，主要是推送上下文刷新完毕事件（ContextRefreshedEvent ）到监听器

源码剖析

 protected void finishRefresh() { 
    // Clear context-level resource caches (such as ASM metadata from scanning). //清除resourceCaches资源缓存中的数据 clearResourceCaches(); // Initialize lifecycle processor for this context. //注释1. 为此上下文初始化生命周期处理器 initLifecycleProcessor(); // Propagate refresh to lifecycle processor first. //注释2. 首先将刷新完毕事件传播到生命周期处理器（触发isAutoStartup方法返回true的SmartLifecycle的start方法） getLifecycleProcessor().onRefresh(); // Publish the final event. //注释3. 推送上下文刷新完毕事件到相应的监听器 publishEvent(new ContextRefreshedEvent(this)); // Participate in LiveBeansView MBean, if active. LiveBeansView.registerApplicationContext(this); }

image-20211019181713150

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://haidsoft.com/141109.html

赞 (0)
老牧童老牧童
0
上一篇 2025-05-21 21:33
下一篇 2025-05-21 22:00

相关推荐

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注微信