Spring--Bean的创建过程/获取流程--SpringBoot

古城微笑少年丶 2022-09-17 03:19 177阅读 0赞

原文网址：[Spring--Bean的创建过程/获取流程--SpringBoot\_IT利刃出鞘的博客-CSDN博客][Spring--Bean_--SpringBoot_IT_-CSDN]

# 简介 #

**说明**

本文介绍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()方法的执行流程图如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70][]

不论是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()方法的流程图**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1][]

**resolveBeforeInstantiation()**

1.  此方法在bean实例化之前调用
2.  此方法中**第一次执行后置处理器**（BeanPostProcessor）。
    
    1.  此处执行的是：InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation()方法，在bean实例化之前对bean进行处理。
    2.  此扩展点的意义重大。例：Spring的AOP就是在这儿实现的，对应的类：AnnotationAwareAspectJAutoProxyCreator。见：[Spring原理--AOP\_feiying0canglang的博客-CSDN博客][Spring_--AOP_feiying0canglang_-CSDN]
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抽象类。自己的方法。

**流程图**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 2][]

**描述**

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

# 其他网址 #

[通过源码看Bean的创建过程][Bean]

[Spring--Bean_--SpringBoot_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120962057
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70]: /images/20220828/d05aaa36004843ce91c802336bf8af7f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1]: /images/20220828/4d000ffc1844403c84d294a95151da80.png
[Spring_--AOP_feiying0canglang_-CSDN]: https://blog.csdn.net/feiying0canglang/article/details/113886504
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 2]: /images/20220828/a361e157725b42539230dbbcc55aa3db.png
[Bean]: https://mp.weixin.qq.com/s?__biz=MzI4Mjg2NjUzNw==&mid=2247483679&idx=1&sn=03a08c6844397a6d2610d89577eb8558&scene=21#wechat_redirect