所有分类
  • 所有分类
  • 未分类

Spring–Bean的创建过程/获取流程

简介

说明

本文介绍Spring中Bean是如何创建出来的。

Spring的核心模块是IOC和AOP,而IOC中创建Bean又是十分重要的一环。在Spring的启动过程中,会在refresh()方法中调用finishBeanFactoryInitialization()。在finishBeanFactoryInitialization中完成了非懒加载的单例bean的创建。所以要搞清楚bean的创建过程,就要从finishBeanFactoryInitialization()方法的源码入手。

总体流程

AbstractApplicationContext#refresh()
    finishBeanFactoryInitialization(beanFactory); //AbstractApplicationContext抽象类
        beanFactory.preInstantiateSingletons(); //DefaultListableBeanFactory类。(实现的ConfigurableListableBeanFactory接口)
            preInstantiateSingletons() //DefaultListableBeanFactory类。(实现的ConfigurableListableBeanFactory接口)
                getBean(beanName) //AbstractBeanFactory抽象类(实现的BeanFactory接口)
                    doGetBean(name, null, null, false) //AbstractBeanFactory抽象类。自己的方法。
                        // 先从单例的缓存中取,取不到则创建,下边只展示缓存中没有而进行创建时的流程。
                        createBean(beanName, mbd, args) //AbstractAutowireCapableBeanFactory抽象类(实现的AbstractBeanFactory)
                            doCreateBean(beanName, mbdToUse, args)//AbstractAutowireCapableBeanFactory抽象类。以下为此类方法
                                createBeanInstance(beanName, mbd, args);  //创建实例
                                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName) //post-processors修改bean的定义
                                addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); //解决循环依赖
                                populateBean(beanName, mbd, instanceWrapper); //填充属性
                                initializeBean(beanName, exposedObject, mbd); //初始化bean

finishBeanFactoryInitialization

位于:AbstractApplicationContext抽象类。

概述

该方法十分重要,它完成了所有非懒加载的单例Bean的实例化和初始化属性的填充以及解决了循环依赖等问题。

这里特意将对象的实例化和初始化过程分开了,因为在Spring创建Bean的过程中,是先将Bean通过反射创建对象,然后通过后置处理器(BeanPostProcessor)来为对象的属性赋值。所以这里的实例化时指将Bean创建出来,初始化是指为bean的属性赋值。

源码

finishBeanFactoryInitialization()方法的代码如下,bean的创建和初始化均在beanFactory.preInstantiateSingletons()中实现。

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));
    }
    // 如果前面没有注册一个类似于PropertyPlaceholderConfigurer后置处理器的bean,那么在这儿会注册一个内置的属性后置处理器
    // 这儿主要是处理被加了注解的属性
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }
    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }
    beanFactory.setTempClassLoader(null);
    // 将BeanFactory的configurationFrozen属性设置为true,给frozenBeanDefinitionNames属性赋值
    // 目的是为了不让在其他的地方在修改bean的BeanDefinition
    beanFactory.freezeConfiguration();

    // Instantiate all remaining (non-lazy-init) singletons.
    // 实例化剩下所有的非懒加载的单例
    beanFactory.preInstantiateSingletons();
}

preInstantiateSingletons

位于:DefaultListableBeanFactory类。(实现的ConfigurableListableBeanFactory接口)

概述

该方法会先判断bean是否是一个FactoryBean,以及是否立即实例化FactoryBean的getObject()返回的对象,但最终均是调用getBean()方法去实例化对象。在Bean实例化、初始化完成后,会判断Bean是否实现了SmartSingletonInitializing接口,如果实现了,则会调用该接口的afterSingletonInstantiated()方法。

Tips:这里提到了FactoryBean,不是BeanFactory。这两者名字很像,但作用却是天差地别。后续会单独写一篇文章介绍FactoryBean,并通过FactoryBean去解析Spring与MyBatis整合的原理。

FactoryBean是一个接口,该接口的实现类会向容器中注册两个bean,一个是实现类本身所代表类型的对象,一个是通过重写FactoryBean接口中getObject()方法所返回的bean。如下例子中:会向容器中注册两个bean,一个是MapperFactoryBean本身,一个是UserMapper。

@Component
public class MapperFactoryBean implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        return new UserMapper();
    }

    @Override
    public Class<?> getObjectType() {
        return UserMapper.class;
    }
}

由于bean的实例化过程太过复杂,后面会结合流程图去分析源码。preInstantiatedSingletons()方法的执行流程图如下

不论是FactoryBean还是普通Bean,最终都是调用getBean()方法去创建bean。

源码

public void preInstantiateSingletons() throws BeansException {
    if (logger.isDebugEnabled()) {
        logger.debug("Pre-instantiating singletons in " + this);
    }
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    // Trigger initialization of all non-lazy singleton beans...
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 判断是否是factoryBean,如果是FactoryBean,则进行FactoryBean原生的实例化(非getObject()方法对应的对象)。
            // 还需要判断它是否立即实例化getObject()返回的对象,根据SmartFactoryBean的isEagerInit()的返回值判断是否需要立即实例化
            if (isFactoryBean(beanName)) {
                // 首先实例化BeanFactory的原生对象,然后再根据isEagerInit()判断是否实例化BeanFactory中getObject()返回的类型的对象
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final FactoryBean<?> factory = (FactoryBean<?>) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                        ((SmartFactoryBean<?>) factory)::isEagerInit,
                                getAccessControlContext());
                    } else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    // 如果isEagerInit为true,则立即实例化FactoryBean所返回的类型的对象
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            } else {
                getBean(beanName);
            }
        }
    }
    // 在bean实例化以及属性赋值完成后,如果bean实现了SmartInitializingSingleton接口,则回调该接口的方法
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            } else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

getBean()

位于:AbstractBeanFactory抽象类(实现的BeanFactory接口)

概述

调用doGetBean(name, null, null, false) //AbstractBeanFactory抽象类。自己的方法

源码

public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

doGetBean

位于:AbstractBeanFactory抽象类。自己的方法

概述

doGetBean 中有两个 getSingleton 方法会先后执行,本文用 getSingleton-C 和 getSingleton-F 来区分。第一个是尝试从缓存中获取,若缓存中没有 A,则执行第二个,通过工厂获得。

public Object getSingleton(String beanName)   //简记为:getSingleton-C。
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory)   //简记为:getSingleton-F。

  1. 从缓存中获取bean:Object sharedInstance = getSingleton(beanName);
    1. 缓存是DefaultSingletonBeanRegistry的singletonObjects这个map(bean的名字为key,bean对象为value)中获取。
    2. 为什么先从缓存中获取呢?因为从Spring容器获取对象/创建对象,都是通过getBean()方法,对于单例对象而言,对象只被创建一次。若缓存中存在,则调用getObjectForBeanInstance()方法,然后返回bean。若缓存中不存在,继续往下执行。
  2. 若缓存中没有,去创建。
    1. 然后获取到Bean所对应的BeanDefinition对象。接着判断bean有没有依赖,String[] dependsOn = mbd.getDependsOn(),如果有依赖的对象,那么会先去实例化依赖的对象。
  3. 依赖的对象创建完成后,会调用getSingleton(beanName,lambda)方法
    1. 这个方法的第二个参数是一个lambda表达式,真正创建bean的逻辑是在表达式的方法体中,即createBean()方法
    2. createBean()方法会创建完成bean,然后在getSingleton(beanName,lambda)方法中会将创建完成的bean存入到singletonObjects属性中。createBean()后面分析。
  4. 在上一步创建完bean后,最终仍会调用getObjectForBeanInstance()。这个方法的逻辑比较简单,先判断bean是否是一个FactoryBean,若不是,则直接返回bean;若是,则再判断beanName是否是以&符号开头,如果是,表示获取的是FactoryBean的原生对象,则直接返回bean;若不是以&符号开头,则会返回FactoryBean的getObject()方法的返回值对象。

源码

doGetBean()方法代码如下

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    final String beanName = transformedBeanName(name);
    Object bean;
    // Eagerly check singleton cache for manually registered singletons.
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    else {
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        // Check if bean definition exists in this factory.
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
        if (!typeCheckOnly) {
            // 标记bean为已创建
            // 并清除beanDefinition的缓存(mergedBeanDefinitions)
            markBeanAsCreated(beanName);
        }
        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 检查bean是否是抽象类
            checkMergedBeanDefinition(mbd, beanName, args);
            // Guarantee initialization of beans that the current bean depends on.
            // 保证当前bean所依赖的bean初始化
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    // isDependent()方法用来判断dep是否依赖beanName
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // 保存下依赖关系
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }
            // Create bean instance.
            if (mbd.isSingleton()) {
                // 此时在getSingleton方法中传入了一个lambda表达式,
                // 此时不会立即执行lambda表达式,而是在调用这个lambda表达式的getObject()方法时才开始执行lambda的方法体
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }

            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            else {
                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 {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(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) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
        }
        catch (TypeMismatchException ex) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

getObjectForBeanInstance()方法的作用是为了根据beanName来判断是返回FactoryBean原生对象还是getObject()方法所返回的对象.若beanName以&符号开头,则表示返回FactoryBean原生对象,否则返回getObject()方法所返回的对象。

protected Object getObjectForBeanInstance(
        Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
    if (BeanFactoryUtils.isFactoryDereference(name)) {
        if (beanInstance instanceof NullBean) {
            return beanInstance;
        }
        if (!(beanInstance instanceof FactoryBean)) {
            throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
        }
    }

    // 如果不是一个FactoryBean对象或者是获取FactoryBean的原生对象(原生对象指的是beanName是以&开头)
    // 此时可以直接返回bean
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
        return beanInstance;
    }

    // 如果是获取FactoryBean的getObject()方法返回的类型对象,则需要进入到如下逻辑
    // 对于getObject()方法,它返回的对象是在在第一次调用getObject方法时进行实例化的,实例化完成以后,会将结果缓存在factoryBeanObjectCache中
    Object object = null;
    if (mbd == null) {
        object = getCachedObjectForFactoryBean(beanName);
    }
    if (object == null) {
        // Return bean instance from factory.
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        // Caches object obtained from FactoryBean if it is a singleton.
        if (mbd == null && containsBeanDefinition(beanName)) {
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        // 获取FactoryBean返回的对象
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    return object;
}

createBean

位于:AbstractAutowireCapableBeanFactory抽象类(实现的AbstractBeanFactory)

概述

doGetBean()最终会调用createBean()来创建bean。

createBean()方法的代码中,主要有两行核心代码:

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
Object beanInstance = doCreateBean(beanName, mbdToUse, args);

createBean()方法的流程图

resolveBeforeInstantiation()

  1. 此方法在bean实例化之前调用
  2. 此方法中第一次执行后置处理器(BeanPostProcessor)。
    1. 此处执行的是:InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation()方法,在bean实例化之前对bean进行处理。
    2. 此扩展点的意义重大。例:Spring的AOP就是在这儿实现的,对应的类:AnnotationAwareAspectJAutoProxyCreator。见:Spring之AOP的原理(一)–概述 – 自学精灵
  3. 若resolveBeforeInstantiation()的返回值不为null,则直接将结果返回。如果为null,则会继续执行方法doCreateBean()。在doCreateBean()方法中,进行了Bean的实例化、属性赋值、初始化等操作。

createBean()方法的源代码

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {
    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.
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }
    // Prepare method overrides.
    try {
        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.
        // 第一次调用后置处理器(执行所有InstantiationAwareBeanPostProcessor的子类)
        // 如果InstantiationAwareBeanPostProcessor的子类的postProcessBeforeInstantiation()方法返回值不为空,表示bean需要被增强,
        // 此时将不会执行后面的逻辑,AOP的实际应用就是在这儿实现的
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                "BeanPostProcessor before instantiation of bean failed", ex);
    }

    try {
        // 第二次执行后置处理器的入口
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isDebugEnabled()) {
            logger.debug("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    }
}

doCreateBean

位于:AbstractAutowireCapableBeanFactory抽象类。自己的方法。

流程图

描述

  1. createBeanInstance(beanName, mbd, args);  //创建实例。通过反射进行Bean的创建。
    1. 执行第二次后置处理器(BeanPostProcessor):SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors(),作用:推断出Bean应该使用哪一个构造器去实例化对象。典型的类:
      1. AutowiredAnnotationBeanPostProcessor。
    2. 若前边没查找到构造器,反射创建:AbstractAutowireCapableBeanFactory#getInstantiationStrategy().instantiate(mbd, beanName, parent);
      1. 调用的流程如下:
        CglibSubclassingInstantiationStrategy#instantiate(mbd, beanName, parent);
            SimpleInstantiationStrategy#instantiate(mbd, beanName, parent);
                BeanUtils.instantiateClass(constructorToUse)
  2. applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)  //post-processors修改bean的定义
    1. 从所有的后置处理器中找到MergedBeanDefinitionPostProcessor,调用其postProcessMergedBeanDefinition()
      1. 执行第三次后置处理器(BeanPostProcessor):缓存bean的注解元数据信息,在后边进行属性填充时使用。这里会将加了@Autowired、@Resource等注解的属性解析出来并缓存。典型的类:
        1. CommonAnnotationBeanPostProcessor:处理JSR-250中的注解,如@Resource、@PostConstruct、@PreDestroy。
        2. AutowiredAnnotationBeanPostProcessor:@Autowired,@Value,@Inject
        3. RequiredAnnotationBeanPostProcessor
  3. addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); //解决循环引用
    1. 目的:将bean提前暴露出去,解决循环引用的问题。方法的第二个参数是lambda表达式,它会再一次执行后置处理器。
    2. 详解:将半成品的bean(此时还未给bean的属性赋值,未完成自动装配)放入到DefaultSingletonBeanRegistry类的singletonFactories的属性中,singletonFactories是一个Map,key为beanName,值为ObjectFactory类型(实际上就是一个lambda表达式),当调用ObjectFactory的getObject()方法时,会执行lambda表达式的方法体,在当前场景下,实际上就是执行了一次Bean的后置处理器。
  4. populateBean(beanName, mbd, instanceWrapper); //填充属性。会执行两次后置处理器。
    1. 第一次调用后置处理器:InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation():判断bean是否要填充属性,若返回false则本方法直接结束。
    2. 第二次调用后置处理器:InstantiationAwareBeanPostProcessor.postPropertyValues():进行属性填充,完成装配。
      1. 主角:AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostBeanPostProcessor,它们根据前面缓存在injectionMetadataCache中的注解信息来进行自动装配。
  5. initializeBean(beanName, exposedObject, mbd); //初始化bean。对Bean回调初始化相关方法、调用2次后置处理器。
    1. 执行invokeAwareMethods()方法(即执行Aware接口的方法),如:BeanNameAware、BeanClassLoaderAware、BeanFactoryAware。设置bean的名字、bean的类加载器、beanFactory
    2. BeanPostProcessor.postProcessBeforeInilization()。所有Bean都会走到这个后置处理器。
    3. invokeInitMethods()
      1. 给bean指定的afterPropertiesSet()方法。此方法属于InilizaingBean接口
      2. 给bean指定的initMethod()方法。此方法属于InilizaingBean接口
    4. BeanPostProcessor.postProcessAfterInilization()
  6. 至此bean的实例化、初始化过程已经完成,创建好的bean会被返回,若是单例bean,最后会被存放到DefaultSingletonBeanRegistry的singletonObjects中。

doCreateBean()方法的代码

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, 
                              final @Nullable Object[] args) throws BeanCreationException {
    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        // 实例化bean(第二次执行后置处理器的入口),第二次执行后置处理器,主要是为了推断出实例化Bean所需要的构造器
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }
    // 此时bean对象已经创建成功,但是没有设置属性和经过其他后置处理器处理
    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                // 第三次执行后置处理器,缓存bean的注解元数据信息(用于后面在进行属性填充时使用)
                // 这一步对于CommonAnnotationBeanPostProcessor、AutowiredAnnotationBeanPostProcessor、
                //     RequiredAnnotationBeanPostProcessor这一类处理器
                // 主要是将bean的注解信息解析出来,然后缓存到后置处理器中的injectionMetadataCache属性中
                // ApplicationListenerDetector将bean是否是单例的标识存于singletonNames这个Map类型的属性中
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            mbd.postProcessed = true;
        }
    }
    // 判断一个bean是否放入到singletonFactories中(提前暴露出来,可以解决循环依赖的问题)
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // 第四次出现后置处理器
        // 获取提前暴露的对象,可以解决循环引用的问题,实际上提前暴露出来的bean是放入到了singletonFactories中,
        //       key是beanName,value是一个lambda表达式
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 填充属性,第五次、第六次后置处理器入口
        populateBean(beanName, mbd, instanceWrapper);
        // 第七次、第八次执行后置处理器入口
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
    }
    return exposedObject;
}
2

评论0

请先

显示验证码
没有账号?注册  忘记密码?

社交账号快速登录