Spring源码解析(五)-Bean的实例化流程(上)

程序バ鱼仔

已于 2022-03-20 23:05:36 修改

阅读量692

点赞数 10

文章标签： spring java 算法

于 2022-03-20 23:05:14 首次发布

本文链接：https://blog.csdn.net/qq_38677263/article/details/123623671

版权

Spring 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

在前面已经完成了对需要实例化bean的收集并封装成BeanDefinition，并且将BeanPostProcess等组件进行了提前实例化。接下来就到了容器启动的最后一步，也是最复杂的一步—实例化bean。实例化bean的步骤比较的长，所以分为两个小节，由于是相互关联的，希望大家能够耐心看完，下面直接开始上代码，入口就是refresh方法中调用的finishBeanFactoryInitialization方法。

AbstractApplicationContext - 460 - N301
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    	//如果容器中存在类型转换器则赋值到工厂中
        if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
            beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
        }

        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver((strVal) -> {
                return this.getEnvironment().resolvePlaceholders(strVal);
            });
        }

        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        String[] var3 = weaverAwareNames;
        int var4 = weaverAwareNames.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String weaverAwareName = var3[var5];
            this.getBean(weaverAwareName);
        }

        beanFactory.setTempClassLoader((ClassLoader)null);
        beanFactory.freezeConfiguration();
    	//N302   主要往这里走
        beanFactory.preInstantiateSingletons();
    }

DefaultListableBeanFactory - 606 - N302
public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Pre-instantiating singletons in " + this);
        }
		//在xml解析的时候重点提到的两个集合，一个是存bd的Name，一个是存bd实例，这里拿到存name的List
        List<String> beanNames = new ArrayList(this.beanDefinitionNames);
        Iterator var2 = beanNames.iterator();

        while(true) {
            String beanName;
            Object bean;
            do {
                while(true) {
                    RootBeanDefinition bd;
                    do {
                        do {
                            do {
                                if (!var2.hasNext()) {
                                    var2 = beanNames.iterator();

                                    while(var2.hasNext()) {
                                        beanName = (String)var2.next();
                                        Object singletonInstance = this.getSingleton(beanName);
                                        if (singletonInstance instanceof SmartInitializingSingleton) {
                                            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                            if (System.getSecurityManager() != null) {
                                                AccessController.doPrivileged(() -> {
                                                    smartSingleton.afterSingletonsInstantiated();
                                                    return null;
                                                }, this.getAccessControlContext());
                                            } else {
                                                smartSingleton.afterSingletonsInstantiated();
                                            }
                                        }
                                    }

                                    return;
                                }

                                beanName = (String)var2.next();
                                //把父BeanDefinition里面的属性拿到子BeanDefinition中
                                bd = this.getMergedLocalBeanDefinition(beanName);
                  //判断是否为抽象的，单例的，非懒加载的
                            } while(bd.isAbstract());
                        } while(!bd.isSingleton());
                    } while(bd.isLazyInit());

                    if (this.isFactoryBean(beanName)) {
                        bean = this.getBean("&" + beanName);
                        break;
                    }
					//N303  主要走进这里面
                    this.getBean(beanName);
                }
            } while(!(bean instanceof FactoryBean));

            FactoryBean<?> factory = (FactoryBean)bean;
            boolean isEagerInit;
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                SmartFactoryBean var10000 = (SmartFactoryBean)factory;
                ((SmartFactoryBean)factory).getClass();
                isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
            } else {
                isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
            }

            if (isEagerInit) {
                this.getBean(beanName);
            }
        }
    }

AbstractBeanFactory - 100 - N303
public Object getBean(String name) throws BeansException {
    	//N304   这个就是实例化的重要方法
        return this.doGetBean(name, (Class)null, (Object[])null, false);
    }

AbstractBeanFactory - 116 - N304
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
        String beanName = this.transformedBeanName(name);
    	//N305   从缓存中拿实例
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
    	//如果缓存中可以拿到实例，说明之前加载过就不需要重新实例化
        if (sharedInstance != null && args == null) {
            if (this.logger.isTraceEnabled()) {
                if (this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
			//N307   调用factoryBean接口的入口  这个方法在每次拿到了bean后都会进行，因为他要判断是否为FactoryBean的实现类，如果是则要特殊处理，如何处理请看下面分析 
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
            
            //如果singletonObjects缓存里面没有，则走下来
            //如果是scope 是Prototype的，校验是否有出现循环依赖，如果有则直接报错
            //prototype或者是构造器@autowire循环依赖都是会报错的。
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String nameToLookup = this.originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                }

                if (args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }

                if (requiredType != null) {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }

                return parentBeanFactory.getBean(nameToLookup);
            }

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

            try {
                //父子BeanDefinition合并
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                //获取依赖对象属性，依赖对象要先实例化
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                if (dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;

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

                        this.registerDependentBean(dep, beanName);

                        try {
                            //实例化
                            this.getBean(dep);
                        } catch (NoSuchBeanDefinitionException var24) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                        }
                    }
                }
				//这里是重点中的重点，大部分是单例的情况
                if (mbd.isSingleton()) {
                   //N311  这里public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory)
                   //第二个参数是一个函数是接口，这个接口只有一个抽象方法（除了静态和default方法）。
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            //N312  这个方法在N311中调用
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    //该方法是FactoryBean接口的调用入口
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    var11 = null;

                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }
					//该方法是FactoryBean接口的调用入口
                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
                    String scopeName = mbd.getScope();
                    Scope scope = (Scope)this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }

                    try {
                        Object scopedInstance = scope.get(beanName, () -> {
                            this.beforePrototypeCreation(beanName);

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

                            return var4;
                        });
                        //该方法是FactoryBean接口的调用入口
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var23) {
                        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", var23);
                    }
                }
            } catch (BeansException var26) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var26;
            }
        }

        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                } else {
                    return convertedBean;
                }
            } catch (TypeMismatchException var25) {
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
                }

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

DefaultSingletonBeanRegistry - 87 - N305
public Object getSingleton(String beanName) {
    	//N306
        return this.getSingleton(beanName, true);
    }

DefaultSingletonBeanRegistry - 87 - N306
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    	//尝试从一级缓存拿到实例
        Object singletonObject = this.singletonObjects.get(beanName);
    	//如果在一级缓存中不存在且bean正在创建但还未完成
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            synchronized(this.singletonObjects) {
                //尝试从二级缓存中拿
                singletonObject = this.earlySingletonObjects.get(beanName);
                //如果还是拿不到，并且是允许提前暴露的（这个在前面已经设置过，刚开始启动容器的时候）
                if (singletonObject == null && allowEarlyReference) {
                    //从三级缓存拿到对象工厂
                    ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        //如果拿到了工厂对象
                        singletonObject = singletonFactory.getObject();
                        //升级到二级缓存
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        //删除三级缓存
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

AbstractBeanFactory - 1115 - N307
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(this.transformedBeanName(name), beanInstance.getClass());
            }
        }
		//如果实例不是FactoryBean类型的，或者name是以&号开头的，则直接返回实例（else中）
        if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
            Object object = null;
            if (mbd == null) {
                //N308   从缓存里面拿FactoryBean类型的实例，factoryBeanObjectCache，这个缓存存的是所有继承了FactoryBean这个接口的类getObject方法返回的对象实例，这个也是我们最终需要的实例。 
                object = this.getCachedObjectForFactoryBean(beanName);
            }

            if (object == null) {
                FactoryBean<?> factory = (FactoryBean)beanInstance;
                if (mbd == null && this.containsBeanDefinition(beanName)) {
                    mbd = this.getMergedLocalBeanDefinition(beanName);
                }

                boolean synthetic = mbd != null && mbd.isSynthetic();
                //N309  这里就是执行factoryBean的getObject类型
                object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);
            }

            return object;
        } else {
            return beanInstance;
        }
    }

FactoryBeanRegistrySupport - 37 - N308
protected Object getCachedObjectForFactoryBean(String beanName) {
    	//factoryBeanObjectCache这个缓存就是存FactoryBean所生成的实例，key为beanName，value为这个BeanName所代表的FactoryBean生成的Bean
        return this.factoryBeanObjectCache.get(beanName);
    }

FactoryBeanRegistrySupport - 41 - N309
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    	//这个工厂bean是单例的，并且它在singletonObjects这个map中存在，则进入if代码块
    	//singletonObjects是三个缓存中的一级缓存，这个是已完成创建的bean的缓存
        if (factory.isSingleton() && this.containsSingleton(beanName)) {
            synchronized(this.getSingletonMutex()) {
                //获取锁后，需要验证缓存中是否只有存在这个bean（可能在争抢锁的时候其他线程已经创建了这个bean）
                //也就是N107中同一个容器，因为这样次执行之间可能有其他线程创建了该bean并放入缓存，单例是只能存在一个bean的
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                    //N310   调用getObject方法，这里也就是核心的部分，调用接口实现的getObject方法返回我们所需要的bean
                    object = this.doGetObjectFromFactoryBean(factory, beanName);
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) {
                        object = alreadyThere;
                    } else {
                        if (shouldPostProcess) {
                            if (this.isSingletonCurrentlyInCreation(beanName)) {
                                return object;
                            }

                            this.beforeSingletonCreation(beanName);

                            try {
                                object = this.postProcessObjectFromFactoryBean(object, beanName);
                            } catch (Throwable var14) {
                                throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", var14);
                            } finally {
                                this.afterSingletonCreation(beanName);
                            }
                        }

                        if (this.containsSingleton(beanName)) {
                         //把实例缓存到factoryBeanObjectCache map中，这个是单独缓存FactoryBean类型实例的map，也就是前面几步尝试获取bean的那个map
                            this.factoryBeanObjectCache.put(beanName, object);
                        }
                    }
                }

                return object;
            }
        } else {
            Object object = this.doGetObjectFromFactoryBean(factory, beanName);
            if (shouldPostProcess) {
                try {
                    object = this.postProcessObjectFromFactoryBean(object, beanName);
                } catch (Throwable var17) {
                    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", var17);
                }
            }

            return object;
        }
    }

FactoryBeanRegistrySupport - 89 - N310
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
        Object object;
        try {
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = this.getAccessControlContext();

                try {
                    object = AccessController.doPrivileged(factory::getObject, acc);
                } catch (PrivilegedActionException var6) {
                    throw var6.getException();
                }
            } else {
                //调用getObject方法，也就是这里调用了接口实现的getObject方法。
                object = factory.getObject();
            }
        } catch (FactoryBeanNotInitializedException var7) {
            throw new BeanCurrentlyInCreationException(beanName, var7.toString());
        } catch (Throwable var8) {
            throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var8);
        }

        if (object == null) {
            //如果一个FactoryBean返回的bean为null但是它却是正在创建的，则会抛出异常，不允许未完成初始化的FactoryBean返回一个null值。而isSingletonCurrentlyInCreation这个方法就是会在一个Set中去找是否存在beanName，这个Set中存在的都是正在创建的beanName（singletonsCurrentlyInCreation）
            if (this.isSingletonCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");
            }

            object = new NullBean();
        }

        return object;
    }

DefaultSingletonBeanRegistry - 106 - N311
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "Bean name must not be null");
        synchronized(this.singletonObjects) {
            //如果缓存中有，则直接返回
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                if (this.singletonsCurrentlyInDestruction) {
                    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 (this.logger.isDebugEnabled()) {
                    this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }
				//把beanName添加到singletonsCurrentlyInCreation Set容器中，在这个集合里面的bean都是正在实例化的bean
                 //这里和下面的afterSingletonCreation相对应，这里是加入容器，而afterSingletonCreation是从容器移除。
                this.beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = this.suppressedExceptions == null;
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet();
                }

                try {
                    //如果这里有返回值，就代表这个bean已经结束创建了，已经完全创建成功
                    //N312  这个方法就是我们前面的N103函数式接口实现的方法
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                } catch (IllegalStateException var16) {
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        throw var16;
                    }
                } catch (BeanCreationException var17) {
                    BeanCreationException ex = var17;
                    if (recordSuppressedExceptions) {
                        Iterator var8 = this.suppressedExceptions.iterator();

                        while(var8.hasNext()) {
                            Exception suppressedException = (Exception)var8.next();
                            ex.addRelatedCause(suppressedException);
                        }
                    }

                    throw ex;
                } finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
					//bean创建完成后singletonsCurrentlyInCreation要删除该bean
                    this.afterSingletonCreation(beanName);
                }

                if (newSingleton) {
                    //创建对象成功时，把对象缓存到singletonObjects缓存中,bean创建完成时放入一级缓存
                    this.addSingleton(beanName, singletonObject);
                }
            }

            return singletonObject;
        }
    }

AbstractAutowireCapableBeanFactory - 280 - N312
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Creating instance of bean '" + beanName + "'");
        }

        RootBeanDefinition mbdToUse = mbd;
        Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        try {
            mbdToUse.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException var9) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
        }

        Object beanInstance;
        try {
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
            if (beanInstance != null) {
                return beanInstance;
            }
        } catch (Throwable var10) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
        }

        try {
            //N313  主要看这个方法
            beanInstance = this.doCreateBean(beanName, mbdToUse, args);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Finished creating instance of bean '" + beanName + "'");
            }

            return beanInstance;
        } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
            throw var7;
        } catch (Throwable var8) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
        }
    }

AbstractAutowireCapableBeanFactory - 322 - N313
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        //这个BeanWrapper类是将bean封装起来并将一些编辑器也一起封装的类
    	BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }

        if (instanceWrapper == null) {
            //N314     创建实例
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        synchronized(mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    //N329   这一步是对类中注解的装配过程
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable var17) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
                }

                mbd.postProcessed = true;
            }
        }

        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }
			//N340  添加三级缓存
            this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
            });
        }

        Object exposedObject = bean;

        try {
            //N342   ioc di，依赖注入的核心方法，该方法必须看
            this.populateBean(beanName, mbd, instanceWrapper);
            //N350   bean 实例化+ioc依赖注入完以后的调用
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                throw (BeanCreationException)var18;
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = this.getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                    String[] dependentBeans = this.getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                    String[] var12 = dependentBeans;
                    int var13 = dependentBeans.length;

                    for(int var14 = 0; var14 < var13; ++var14) {
                        String dependentBean = var12[var14];
                        if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }

                    if (!actualDependentBeans.isEmpty()) {
                        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.");
                    }
                }
            }
        }

        try {
            //N358   注册bean销毁时的类DisposableBeanAdapter，这个东西会在销毁的时候由tomcat循环调用达到销毁bean
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
        }
    }

AbstractAutowireCapableBeanFactory - 745 - N314
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    	//先反射拿到class对象
        Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        } else {
            Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
            if (instanceSupplier != null) {
                return this.obtainFromSupplier(instanceSupplier, beanName);
            } else if (mbd.getFactoryMethodName() != null) {
                //首先做个小总结，在现在这个方法体里面，首先是检查是否有factoryMethodName属性，如果有则会通过这个属性值的方法去创建实例并返回（@Bean注解就是通过此方式）。如果没有则进入下一种实例化方式，下一种实例化方式是检查是否有带@autowire的构造函数，如果有则调用这个构造函数来实例化bean并返回。如果也没有则到最后一种方式，也是最常见的方式，通过无参构造函数创建实例并返回。
                //N315   如果有FactoryMethodName属性，则通过下面的方法来创建实例并返回
                return this.instantiateUsingFactoryMethod(beanName, mbd, args);
            } else {
                boolean resolved = false;
                boolean autowireNecessary = false;
                if (args == null) {
                    synchronized(mbd.constructorArgumentLock) {
                        if (mbd.resolvedConstructorOrFactoryMethod != null) {
                            resolved = true;
                            autowireNecessary = mbd.constructorArgumentsResolved;
                        }
                    }
                }

                if (resolved) {
                    return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
                } else {
                    //N319   收集当前正在实例化的bean中有@Autowired注解的构造函数
                    Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
                    if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
                        ctors = mbd.getPreferredConstructors();
                        //327  无参构造函数的实例化,大部分的实例是采用的无参构造函数的方式实例化
                        return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
                    } else {
                        //324   如果前面收集到的ctors不为空，就说明构造函数上有@Autowired注解，所以通过选中的构造函数来实例化bean
                        return this.autowireConstructor(beanName, mbd, ctors, args);
                    }
                }
            }
        }
    }

AbstractAutowireCapableBeanFactory - 855 - N315
protected BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
    	//N316
        return (new ConstructorResolver(this)).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
    }

 ConstructorResolver 275 N316
public BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
     	//这个BeanWrapperImpl bw就是这个方法返回值
        BeanWrapperImpl bw = new BeanWrapperImpl();
        this.beanFactory.initBeanWrapper(bw);
        String factoryBeanName = mbd.getFactoryBeanName();
        Object factoryBean;
        Class factoryClass;
        boolean isStatic;
    	//下面这个if-else是确定反射的对象是哪个
        if (factoryBeanName != null) {
            //如果factoryBeanName不为null，说明是指定了一个bean，只能是非静态方法
            if (factoryBeanName.equals(beanName)) {
                throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName, "factory-bean reference points back to the same bean definition");
            }
			//这个就是那个将要被调用的bean，也就是在xml配置bean时，factory-bean这个属性所指向的bean
            factoryBean = this.beanFactory.getBean(factoryBeanName);
            if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
                throw new ImplicitlyAppearedSingletonException();
            }

            factoryClass = factoryBean.getClass();
            isStatic = false;
        } else {
            //如果factoryBeanName为null，说明是当前的这个bean中的方法，只能是非静态方法
            if (!mbd.hasBeanClass()) {
                throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName, "bean definition declares neither a bean class nor a factory-bean reference");
            }
			//进到这里就说明是调用当前实例化bean中的方法来创建实例
            factoryBean = null;
            //静态方法，因为当前实例还没有实例化，只能调用静态方法
            factoryClass = mbd.getBeanClass();
            isStatic = true;
        }
		//下面的很长很长的一段代码，都是在处理参数，这个过程比较繁琐就不做讲解，咱们直接看看进行实例化的方法。
        Method factoryMethodToUse = null;
        ConstructorResolver.ArgumentsHolder argsHolderToUse = null;
        Object[] argsToUse = null;
        if (explicitArgs != null) {
            argsToUse = explicitArgs;
        } else {
            Object[] argsToResolve = null;
            synchronized(mbd.constructorArgumentLock) {
                factoryMethodToUse = (Method)mbd.resolvedConstructorOrFactoryMethod;
                if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) {
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }

            if (argsToResolve != null) {
                argsToUse = this.resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
            }
        }

        if (factoryMethodToUse == null || argsToUse == null) {
            //首先拿到factory-bean所指的bean的class对象，接下来拿到该class所有方法
            factoryClass = ClassUtils.getUserClass(factoryClass);
            //拿到所有的方法
            Method[] rawCandidates = this.getCandidateMethods(factoryClass, mbd);
            List<Method> candidateList = new ArrayList();
            Method[] candidates = rawCandidates;
            int var15 = rawCandidates.length;
			//循环遍历所有的方法，对比是否为静态，且方法名与factory-method属性一致
            for(int var16 = 0; var16 < var15; ++var16) {
                Method candidate = candidates[var16];
                if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
                    candidateList.add(candidate);
                }
            }
		//如果只有一个方法名与factory-method属性一致，则直接调用
            if (candidateList.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
                Method uniqueCandidate = (Method)candidateList.get(0);
                if (uniqueCandidate.getParameterCount() == 0) {
                    mbd.factoryMethodToIntrospect = uniqueCandidate;
                    synchronized(mbd.constructorArgumentLock) {
                        mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                        mbd.constructorArgumentsResolved = true;
                        mbd.resolvedConstructorArguments = EMPTY_ARGS;
                    }
					//N317   这个方法就是实例化bean并且封装进bw中返回的
                    bw.setBeanInstance(this.instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
                    return bw;
                }
            }
	//如果有多个方法名与factory-method属性一致，出现了重载，则需要进一步确认是那个方法然后调用
            candidates = (Method[])candidateList.toArray(new Method[0]);
          //这里会将收集到的FactoryMethod进行排序，规则就是判断是否为public和参数的长度进行排序
            AutowireUtils.sortFactoryMethods(candidates);
            ConstructorArgumentValues resolvedValues = null;
            boolean autowiring = mbd.getResolvedAutowireMode() == 3;
            int minTypeDiffWeight = 2147483647;
            Set<Method> ambiguousFactoryMethods = null;
            int minNrOfArgs;
            if (explicitArgs != null) {
                minNrOfArgs = explicitArgs.length;
            } else if (mbd.hasConstructorArgumentValues()) {
                ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                resolvedValues = new ConstructorArgumentValues();
                minNrOfArgs = this.resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
            } else {
                minNrOfArgs = 0;
            }

            LinkedList<UnsatisfiedDependencyException> causes = null;
            Method[] var21 = candidates;
            int var22 = candidates.length;

            int var23;
            //这里会遍历收集到的FactoryMethod，上面已经进行了排序
            for(var23 = 0; var23 < var22; ++var23) {
                Method candidate = var21[var23];
                Class<?>[] paramTypes = candidate.getParameterTypes();
                if (paramTypes.length >= minNrOfArgs) {
                    ConstructorResolver.ArgumentsHolder argsHolder;
                    if (explicitArgs != null) {
                        if (paramTypes.length != explicitArgs.length) {
                            continue;
                        }

                        argsHolder = new ConstructorResolver.ArgumentsHolder(explicitArgs);
                    } else {
                        try {
                            String[] paramNames = null;
                            ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                            if (pnd != null) {
                                paramNames = pnd.getParameterNames(candidate);
                            }
			//在这里获取参数所需要的bean，后续将构造函数会讲到具体流程，最后其实就是调用了getBean方法
                            argsHolder = this.createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring, candidates.length == 1);
                        } catch (UnsatisfiedDependencyException var30) {
                            if (this.logger.isTraceEnabled()) {
                                this.logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + var30);
                            }

                            if (causes == null) {
                                causes = new LinkedList();
                            }

                            causes.add(var30);
                            continue;
                        }
                    }

                    int typeDiffWeight = mbd.isLenientConstructorResolution() ? argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes);
                    if (typeDiffWeight < minTypeDiffWeight) {
                        factoryMethodToUse = candidate;
                        argsHolderToUse = argsHolder;
                        argsToUse = argsHolder.arguments;
                        minTypeDiffWeight = typeDiffWeight;
                        ambiguousFactoryMethods = null;
                    } else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight && !mbd.isLenientConstructorResolution() && paramTypes.length == factoryMethodToUse.getParameterCount() && !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
                        if (ambiguousFactoryMethods == null) {
                            ambiguousFactoryMethods = new LinkedHashSet();
                            ambiguousFactoryMethods.add(factoryMethodToUse);
                        }

                        ambiguousFactoryMethods.add(candidate);
                    }
                }
            }

            if (factoryMethodToUse == null) {
                if (causes != null) {
                    UnsatisfiedDependencyException ex = (UnsatisfiedDependencyException)causes.removeLast();
                    Iterator var43 = causes.iterator();

                    while(var43.hasNext()) {
                        Exception cause = (Exception)var43.next();
                        this.beanFactory.onSuppressedException(cause);
                    }

                    throw ex;
                }

                List<String> argTypes = new ArrayList(minNrOfArgs);
                if (explicitArgs != null) {
                    Object[] var40 = explicitArgs;
                    var23 = explicitArgs.length;

                    for(int var45 = 0; var45 < var23; ++var45) {
                        Object arg = var40[var45];
                        argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
                    }
                } else if (resolvedValues != null) {
                    Set<ValueHolder> valueHolders = new LinkedHashSet(resolvedValues.getArgumentCount());
                    valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
                    valueHolders.addAll(resolvedValues.getGenericArgumentValues());
                    Iterator var44 = valueHolders.iterator();

                    while(var44.hasNext()) {
                        ValueHolder value = (ValueHolder)var44.next();
                        String argType = value.getType() != null ? ClassUtils.getShortName(value.getType()) : (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null");
                        argTypes.add(argType);
                    }
                }

                String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "No matching factory method found: " + (mbd.getFactoryBeanName() != null ? "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") + "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. Check that a method with the specified name " + (minNrOfArgs > 0 ? "and arguments " : "") + "exists and that it is " + (isStatic ? "static" : "non-static") + ".");
            }

            if (Void.TYPE == factoryMethodToUse.getReturnType()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid factory method '" + mbd.getFactoryMethodName() + "': needs to have a non-void return type!");
            }

            if (ambiguousFactoryMethods != null) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Ambiguous factory method matches found in bean '" + beanName + "' (hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " + ambiguousFactoryMethods);
            }

            if (explicitArgs == null && argsHolderToUse != null) {
                mbd.factoryMethodToIntrospect = factoryMethodToUse;
                argsHolderToUse.storeCache(mbd, factoryMethodToUse);
            }
        }

        Assert.state(argsToUse != null, "Unresolved factory method arguments");
     	//N317    这个方法就是实例化bean并且封装进bw中返回的
        bw.setBeanInstance(this.instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
        return bw;
    }

ConstructorResolver 487 N317
private Object instantiate(String beanName, RootBeanDefinition mbd, @Nullable Object factoryBean, Method factoryMethod, Object[] args) {
        try {
            //这个是权限校验的，很多地方都会有但是一般不会走进去。
            return System.getSecurityManager() != null ? AccessController.doPrivileged(() -> {
                return this.beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args);
            }, this.beanFactory.getAccessControlContext()) : 
            //N318  这里面就是真正的实例化过程，其实就一个反射调用的过程，前面拿到了factoryBean, factoryMethod, args
            this.beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args);
        } catch (Throwable var7) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean instantiation via factory method failed", var7);
        }
    }

SimpleInstantiationStrategy 88 N318
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner, @Nullable Object factoryBean, Method factoryMethod, Object... args) {
        try {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(() -> {
                    ReflectionUtils.makeAccessible(factoryMethod);
                    return null;
                });
            } else {
                ReflectionUtils.makeAccessible(factoryMethod);
            }

            Method priorInvokedFactoryMethod = (Method)currentlyInvokedFactoryMethod.get();

            Object var9;
            try {
                currentlyInvokedFactoryMethod.set(factoryMethod);
                //这里通过反射实例化了bean实例。然后返回这个实例
                Object result = factoryMethod.invoke(factoryBean, args);
                if (result == null) {
                    result = new NullBean();
                }

                var9 = result;
            } finally {
                if (priorInvokedFactoryMethod != null) {
                    currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
                } else {
                    currentlyInvokedFactoryMethod.remove();
                }

            }

            return var9;
        } catch (IllegalArgumentException var16) {
            throw new BeanInstantiationException(factoryMethod, "Illegal arguments to factory method '" + factoryMethod.getName() + "'; args: " + StringUtils.arrayToCommaDelimitedString(args), var16);
        } catch (IllegalAccessException var17) {
            throw new BeanInstantiationException(factoryMethod, "Cannot access factory method '" + factoryMethod.getName() + "'; is it public?", var17);
        } catch (InvocationTargetException var18) {
            String msg = "Factory method '" + factoryMethod.getName() + "' threw exception";
            if (bd.getFactoryBeanName() != null && owner instanceof ConfigurableBeanFactory && ((ConfigurableBeanFactory)owner).isCurrentlyInCreation(bd.getFactoryBeanName())) {
                msg = "Circular reference involving containing bean '" + bd.getFactoryBeanName() + "' - consider declaring the factory method as static for independence from its containing instance. " + msg;
            }

            throw new BeanInstantiationException(factoryMethod, msg, var18.getTargetException());
        }
    }

AbstractAutowireCapableBeanFactory 817 N319
protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName) throws BeansException {
    //这里会先确认是否存在InstantiationAwareBeanPostProcessors这个类型的beanPostProcessor,这个hasInstantiationAwareBeanPostProcessors方法就是验证hasInstantiationAwareBeanPostProcessors变量true还是false，这个变量在所有beanPostProcessor注册和实例化时如果有这种类型的InstantiationAwareBeanPostProcessors就会设为true。
    	//N320
        if (beanClass != null && this.hasInstantiationAwareBeanPostProcessors()) {
            Iterator var3 = this.getBeanPostProcessors().iterator();

            while(var3.hasNext()) {
                BeanPostProcessor bp = (BeanPostProcessor)var3.next();
                //遍历所有的BeanPostProcessor,判断是否为SmartInstantiationAwareBeanPostProcessor
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor)bp;
                    //调用determineCandidateConstructors方法，然后这个方法只有在AutowiredAnnotationBeanPostProcessor
                      //这个类中有实现，其他几个InstantiationAwareBeanPostProcessor类中都是空实现返回null，所以下面进入到										//AutowiredAnnotationBeanPostProcessor中的determineCandidateConstructors()方法
                    //N321   主要是收集这个beanClass内的所有候选构造函数（也就是带@autowired的构造函数）
                    Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
                    if (ctors != null) {
                        return ctors;
                    }
                }
            }
        }

        return null;
    }

AbstractBeanFactory 651 N320
protected boolean hasInstantiationAwareBeanPostProcessors() {
    //这个变量在所有beanPostProcessor注册和实例化时如果有这种类型的InstantiationAwareBeanPostProcessors就设为true。
        return this.hasInstantiationAwareBeanPostProcessors;
    }

AutowiredAnnotationBeanPostProcessor 126 N321
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeanCreationException {
    	//这个if是将在这个bean有@Lookup的方法加入到bd中，功能与xml中的lookup-method属性一致，只是换成了注解形式
    	//这个缓存里的beanName都是已经处理过的，if块尾部会将当前处理的beanName放进来，每次判断是否处理过，防止重复处理
        if (!this.lookupMethodsChecked.contains(beanName)) {
            try {
             //首先会进入到这个方法里面，这里依旧是一个函数式接口的使用，然后内部会调用到传入的函数式接口实现的代码。
             //这里可以发现，当我们需要遍历某个类中的方法，并且对所有方法进行遍历单独处理，就可以用这种函数式接口回调的方式。
                //N322
                ReflectionUtils.doWithMethods(beanClass, (method) -> {
                    //从N122中调用此处，在N122中获取beanclass中所有方法，并且遍历每个方法传入到此处
                    //对注解Lookup的支持，检查该方法是否有Lookup这个注解，如果没有则不需要处理，如果有则需要处理
                    Lookup lookup = (Lookup)method.getAnnotation(Lookup.class);
                    if (lookup != null) {
                        //进到这里就说明该方法有@Lookup注解
                        Assert.state(this.beanFactory != null, "No BeanFactory available");
                        //将注解标记的方法和注解信息封装成LookupOverride
                        LookupOverride override = new LookupOverride(method, lookup.value());

                        try {
                            RootBeanDefinition mbd = (RootBeanDefinition)this.beanFactory.getMergedBeanDefinition(beanName);
                            //将封装好的LookupOverride存进到mbd中
                            mbd.getMethodOverrides().addOverride(override);
                        } catch (NoSuchBeanDefinitionException var6) {
                            throw new BeanCreationException(beanName, "Cannot apply @Lookup to beans without corresponding bean definition");
                        }
                    }

                });
            } catch (IllegalStateException var21) {
                throw new BeanCreationException(beanName, "Lookup method resolution failed", var21);
            }

            this.lookupMethodsChecked.add(beanName);
        }
		//这里才开始处理构造函数，首先尝试从缓存获取这个beanclass的候选构造器（这些候选构造器就是我们要的带@autowire构造器）
    	//如果没有获取到则需要进入if块，获取到了就直接返回候选构造器
        Constructor<?>[] candidateConstructors = (Constructor[])this.candidateConstructorsCache.get(beanClass);
        if (candidateConstructors == null) {
            synchronized(this.candidateConstructorsCache) {
                //上锁之后重新获取候选构造器，如果为空则继续，否则直接返回获取到的构造器
                candidateConstructors = (Constructor[])this.candidateConstructorsCache.get(beanClass);
                if (candidateConstructors == null) {
                    //进入这里就说明没有获取到我们需要的候选构造器，我们需要遍历所有构造器来寻找候选的构造器
                    Constructor[] rawCandidates;
                    try {
                        //获取bean对应的所有构造器
                        rawCandidates = beanClass.getDeclaredConstructors();
                    } catch (Throwable var20) {
                        throw new BeanCreationException(beanName, "Resolution of declared constructors on bean Class [" + beanClass.getName() + "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", var20);
                    }

                    List<Constructor<?>> candidates = new ArrayList(rawCandidates.length);
                    Constructor<?> requiredConstructor = null;
                    Constructor<?> defaultConstructor = null;
                    Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
                    int nonSyntheticConstructors = 0;
                    Constructor[] var11 = rawCandidates;
                    int var12 = rawCandidates.length;
                    int var13 = 0;
				//遍历所有的构造函数
                    while(true) {
                //如果var13 >= var12成立，则表示所有的构造函数检查扫描完了，现在进入这个if块跳出while循环
                        if (var13 >= var12) {
                        //如果candidates不为空，表示收集到了带@autowired的候选构造函数，放入返回集合中
                            if (!candidates.isEmpty()) {
                                if (requiredConstructor == null) {
                                    if (defaultConstructor != null) {
                                        candidates.add(defaultConstructor);
                                    } else if (candidates.size() == 1 && this.logger.isInfoEnabled()) {
                                        this.logger.info("Inconsistent constructor declaration on bean with name '" + beanName + "': single autowire-marked constructor flagged as optional - this constructor is effectively required since there is no default constructor to fall back to: " + candidates.get(0));
                                    }
                                }

                                candidateConstructors = (Constructor[])candidates.toArray(new Constructor[0]);
                         //如果candidates为空，表示没有带@autowired的构造函数，然后判断类中只有一个构造函数且是有参构造函数，则也会收集该构造函数到返回集合。这一点是比较容易被忽略的。但是如果有多个不带@autowired的构造参数，则会收集不到任何构造函数，后续会使用默认的无参构造函数实例化，如果我们写了有参构造函数且不带autowired注解而没有重写无参构造函数，此时就会JDK错误。
                            } else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
                                candidateConstructors = new Constructor[]{rawCandidates[0]};
                            } else if (nonSyntheticConstructors == 2 && primaryConstructor != null && defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
                                candidateConstructors = new Constructor[]{primaryConstructor, defaultConstructor};
                            } else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
                                candidateConstructors = new Constructor[]{primaryConstructor};
                            } else {
                                candidateConstructors = new Constructor[0];
                            }

                            this.candidateConstructorsCache.put(beanClass, candidateConstructors);
                            break;
                        }

                        label133: {
                            Constructor<?> candidate = var11[var13];
                            if (!candidate.isSynthetic()) {
                                ++nonSyntheticConstructors;
                            } else if (primaryConstructor != null) {
                                break label133;
                            }

                            AnnotationAttributes ann = this.findAutowiredAnnotation(candidate);
                            if (ann == null) {
                                Class<?> userClass = ClassUtils.getUserClass(beanClass);
                                if (userClass != beanClass) {
                                    try {
                                        Constructor<?> superCtor = userClass.getDeclaredConstructor(candidate.getParameterTypes());
                                        ann = this.findAutowiredAnnotation(superCtor);
                                    } catch (NoSuchMethodException var19) {
                                    }
                                }
                            }
						//这个if块就限制了我们如果要用多个带有@autowire注解的构造函数，那么所有的required必须设置为false
                          //如果想要将required设置为true，那么就只能有一个构造函数带有@autowire注解。
                            if (ann != null) {
                                //首先检测是否有required=true的构造器，有则抛异常
                                if (requiredConstructor != null) {
                                    throw new BeanCreationException(beanName, "Invalid autowire-marked constructor: " + candidate + ". Found constructor with 'required' Autowired annotation already: " + requiredConstructor);
                                }
							 //获取到@Autowired里面的required方法的值
                                boolean required = this.determineRequiredStatus(ann);
                                if (required) {
                        //如果当前的构造方法是required=true，则不能存在其它带有@autowired注解的构造方法
                                    if (!candidates.isEmpty()) {
                                        throw new BeanCreationException(beanName, "Invalid autowire-marked constructors: " + candidates + ". Found constructor with 'required' Autowired annotation: " + candidate);
                                    }

                                    requiredConstructor = candidate;
                                }
							 //所有的候选构造器暂时存在这个集合中
                                candidates.add(candidate);
                            } else if (candidate.getParameterCount() == 0) {
                                //类的无参默认构造器
                                defaultConstructor = candidate;
                            }
                        }

                        ++var13;
                    }
                }
            }
        }

        return candidateConstructors.length > 0 ? candidateConstructors : null;
    }

ReflectionUtils 305 N322
public static void doWithMethods(Class<?> clazz, ReflectionUtils.MethodCallback mc) {
    	//N323
        doWithMethods(clazz, mc, (ReflectionUtils.MethodFilter)null);
    }

ReflectionUtils 309 N323
public static void doWithMethods(Class<?> clazz, ReflectionUtils.MethodCallback mc, @Nullable ReflectionUtils.MethodFilter mf) {
    	//获取到该类中的所有方法然后遍历
        Method[] methods = getDeclaredMethods(clazz);
        Method[] var4 = methods;
        int var5 = methods.length;

        int var6;
        for(var6 = 0; var6 < var5; ++var6) {
            Method method = var4[var6];
            if (mf == null || mf.matches(method)) {
                try {
                    //这里就是调用了N120里函数式接口实现中的方法代码。所以我们回到N120
                    mc.doWith(method);
                } catch (IllegalAccessException var9) {
                    throw new IllegalStateException("Not allowed to access method '" + method.getName() + "': " + var9);
                }
            }
        }

        if (clazz.getSuperclass() != null) {
            doWithMethods(clazz.getSuperclass(), mc, mf);
        } else if (clazz.isInterface()) {
            Class[] var10 = clazz.getInterfaces();
            var5 = var10.length;

            for(var6 = 0; var6 < var5; ++var6) {
                Class<?> superIfc = var10[var6];
                doWithMethods(superIfc, mc, mf);
            }
        }

    }

AbstractAutowireCapableBeanFactory 859 N324
protected BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
     	//N325
        return (new ConstructorResolver(this)).autowireConstructor(beanName, mbd, ctors, explicitArgs);
    }

ConstructorResolver 64 N325  
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
        BeanWrapperImpl bw = new BeanWrapperImpl();
        this.beanFactory.initBeanWrapper(bw);
        Constructor<?> constructorToUse = null;
        ConstructorResolver.ArgumentsHolder argsHolderToUse = null;
        Object[] argsToUse = null;
        if (explicitArgs != null) {
            argsToUse = explicitArgs;
        } else {
            Object[] argsToResolve = null;
            synchronized(mbd.constructorArgumentLock) {
                constructorToUse = (Constructor)mbd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse != null && mbd.constructorArgumentsResolved) {
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) {
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }

            if (argsToResolve != null) {
                argsToUse = this.resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
            }
        }

        if (constructorToUse == null || argsToUse == null) {
            Constructor<?>[] candidates = chosenCtors;
            if (chosenCtors == null) {
                Class beanClass = mbd.getBeanClass();

                try {
                    candidates = mbd.isNonPublicAccessAllowed() ? beanClass.getDeclaredConstructors() : beanClass.getConstructors();
                } catch (Throwable var25) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Resolution of declared constructors on bean Class [" + beanClass.getName() + "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", var25);
                }
            }

            if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
                Constructor<?> uniqueCandidate = candidates[0];
                //如果是无参构造函数
                if (uniqueCandidate.getParameterCount() == 0) {
                    synchronized(mbd.constructorArgumentLock) {
                        mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                        mbd.constructorArgumentsResolved = true;
                        mbd.resolvedConstructorArguments = EMPTY_ARGS;
                    }
				//N326   无参构造函数实例化，反射，封装进bw中返回
                    bw.setBeanInstance(this.instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
                    return bw;
                }
            }

            boolean autowiring = chosenCtors != null || mbd.getResolvedAutowireMode() == 3;
            ConstructorArgumentValues resolvedValues = null;
            int minNrOfArgs;
            if (explicitArgs != null) {
                minNrOfArgs = explicitArgs.length;
            } else {
                ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                resolvedValues = new ConstructorArgumentValues();
                minNrOfArgs = this.resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
            }

            AutowireUtils.sortConstructors(candidates);
            int minTypeDiffWeight = 2147483647;
            Set<Constructor<?>> ambiguousConstructors = null;
            LinkedList<UnsatisfiedDependencyException> causes = null;
            Constructor[] var16 = candidates;
            int var17 = candidates.length;

            for(int var18 = 0; var18 < var17; ++var18) {
                Constructor<?> candidate = var16[var18];
                //获取到构造函数的参数类型
                Class<?>[] paramTypes = candidate.getParameterTypes();
                if (constructorToUse != null && argsToUse != null && argsToUse.length > paramTypes.length) {
                    break;
                }

                if (paramTypes.length >= minNrOfArgs) {
                    ConstructorResolver.ArgumentsHolder argsHolder;
                    if (resolvedValues != null) {
                        try {
                            String[] paramNames = ConstructorResolver.ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
                            if (paramNames == null) {
                                ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                                if (pnd != null) {
                                    //获取构造函数中参数的名称
                                    paramNames = pnd.getParameterNames(candidate);
                                }
                            }
							//获取到参数的值，过程十分复杂。
                            argsHolder = this.createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames, this.getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
                        } catch (UnsatisfiedDependencyException var26) {
                            if (this.logger.isTraceEnabled()) {
                                this.logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + var26);
                            }

                            if (causes == null) {
                                causes = new LinkedList();
                            }

                            causes.add(var26);
                            continue;
                        }
                    } else {
                        if (paramTypes.length != explicitArgs.length) {
                            continue;
                        }

                        argsHolder = new ConstructorResolver.ArgumentsHolder(explicitArgs);
                    }

                    int typeDiffWeight = mbd.isLenientConstructorResolution() ? argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes);
                    if (typeDiffWeight < minTypeDiffWeight) {
                        constructorToUse = candidate;
                        argsHolderToUse = argsHolder;
                        argsToUse = argsHolder.arguments;
                        minTypeDiffWeight = typeDiffWeight;
                        ambiguousConstructors = null;
                    } else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
                        if (ambiguousConstructors == null) {
                            ambiguousConstructors = new LinkedHashSet();
                            ambiguousConstructors.add(constructorToUse);
                        }

                        ambiguousConstructors.add(candidate);
                    }
                }
            }

            if (constructorToUse == null) {
                if (causes == null) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Could not resolve matching constructor (hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
                }

                UnsatisfiedDependencyException ex = (UnsatisfiedDependencyException)causes.removeLast();
                Iterator var33 = causes.iterator();

                while(var33.hasNext()) {
                    Exception cause = (Exception)var33.next();
                    this.beanFactory.onSuppressedException(cause);
                }

                throw ex;
            }

            if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Ambiguous constructor matches found in bean '" + beanName + "' (hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " + ambiguousConstructors);
            }

            if (explicitArgs == null && argsHolderToUse != null) {
                argsHolderToUse.storeCache(mbd, constructorToUse);
            }
        }

        Assert.state(argsToUse != null, "Unresolved constructor arguments");
    	//326  有参构造函数的实例化，反射实例化，封装进bw中返回
        bw.setBeanInstance(this.instantiate(beanName, mbd, constructorToUse, argsToUse));
        return bw;
    }

ConstructorResolver 221 N326
private Object instantiate(String beanName, RootBeanDefinition mbd, Constructor constructorToUse, Object[] argsToUse) {
        try {
            InstantiationStrategy strategy = this.beanFactory.getInstantiationStrategy();
            //这个if又出现了，主要做权限校验，一般不会出现
            return System.getSecurityManager() != null ? AccessController.doPrivileged(() -> {
                return strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
            }, this.beanFactory.getAccessControlContext()) : 
            //一般都是进入到这里，通过反射调用构造方法完成实例化bean
            strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
        } catch (Throwable var6) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean instantiation via constructor failed", var6);
        }
    }

AbstractAutowireCapableBeanFactory 836 N327
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
        try {
            Object beanInstance;
            if (System.getSecurityManager() != null) {
                beanInstance = AccessController.doPrivileged(() -> {
                    return thisx.getInstantiationStrategy().instantiate(mbd, beanName, this);
                }, this.getAccessControlContext());
            } else {
                //N328   通过反射调用构造函数的方式实例化bean
                beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
            }
			//封装成了beanWrapper
            BeanWrapper bw = new BeanWrapperImpl(beanInstance);
            this.initBeanWrapper(bw);
            return bw;
        } catch (Throwable var6) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var6);
        }
    }

SimpleInstantiationStrategy 31 N328
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
        if (!bd.hasMethodOverrides()) {
            Constructor constructorToUse;
            synchronized(bd.constructorArgumentLock) {
                constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse == null) {
                    Class<?> clazz = bd.getBeanClass();
                    if (clazz.isInterface()) {
                        throw new BeanInstantiationException(clazz, "Specified class is an interface");
                    }

                    try {
                        if (System.getSecurityManager() != null) {
                            clazz.getClass();
                            constructorToUse = (Constructor)AccessController.doPrivileged(() -> {
                                return clazz.getDeclaredConstructor();
                            });
                        } else {
                            constructorToUse = clazz.getDeclaredConstructor();
                        }

                        bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                    } catch (Throwable var9) {
                        throw new BeanInstantiationException(clazz, "No default constructor found", var9);
                    }
                }
            }
			//通过反射调用构造器方法来实例化bean
            return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
        } else {
            return this.instantiateWithMethodInjection(bd, beanName, owner);
        }
    }

AbstractAutowireCapableBeanFactory 694 N329
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		//获取所有的BeanPostProcessor
        Iterator var4 = this.getBeanPostProcessors().iterator();

        while(var4.hasNext()) {
            BeanPostProcessor bp = (BeanPostProcessor)var4.next();
            //遍历所有的BeanPostProcessor,判断是否为MergedBeanDefinitionPostProcessor
            if (bp instanceof MergedBeanDefinitionPostProcessor) {
                MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor)bp;
                //N330
                //N336
                bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
            }
        }

    }

CommonAnnotationBeanPostProcessor 125 N330
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {		
    	//331   @PostConstruct @PreDestroy
        super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
    	//334   @Resource
        InjectionMetadata metadata = this.findResourceMetadata(beanName, beanType, (PropertyValues)null);
    	//N330*****
        metadata.checkConfigMembers(beanDefinition);
    }

N330*
public AutowiredAnnotationBeanPostProcessor() {
    	//初始化时将Autowired.class和Value.class添加到autowiredAnnotationTypes容器中，这两个属性在N137的处理中会使用到
    	//表示@autowired和@Value两个注解
		this.autowiredAnnotationTypes.add(Autowired.class);
		this.autowiredAnnotationTypes.add(Value.class);
		try {
			this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
					ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
			logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - simply skip.
		}
	}

N330**
public CommonAnnotationBeanPostProcessor() {
		setOrder(Ordered.LOWEST_PRECEDENCE - 3);
    	//初始化initAnnotationType属性，里面存PostConstruct.class
		setInitAnnotationType(PostConstruct.class);
    	//初始化destroyAnnotationType属性，里面存PreDestroy.class，这两个属性在后面N132中会使用，用作判断是否有这两个注解
		setDestroyAnnotationType(PreDestroy.class);
		ignoreResourceType("javax.xml.ws.WebServiceContext");
	}

N330***   //这个对象会存一个bean的类class以及类中带@PostConstruct和@PreDestroy的方法到集合
private class LifecycleMetadata {
		
		private final Class<?> targetClass;
		//N130****   这个集合元素类型LifecycleElement
		private final Collection<LifecycleElement> initMethods;

		private final Collection<LifecycleElement> destroyMethods;

		@Nullable
		private volatile Set<LifecycleElement> checkedInitMethods;

		@Nullable
		private volatile Set<LifecycleElement> checkedDestroyMethods;

		public LifecycleMetadata(Class<?> targetClass, Collection<LifecycleElement> initMethods,
				Collection<LifecycleElement> destroyMethods) {
			//构造函数，类class
			this.targetClass = targetClass;
             //下面两个是类中带@PostConstruct和@PreDestroy的方法集合
			this.initMethods = initMethods;
			this.destroyMethods = destroyMethods;
		}
		//这个方法其实就是把initMethods和destroyMethods处理后放到checkedInitMethods和checkedDestroyMethods
		public void checkConfigMembers(RootBeanDefinition beanDefinition) {
			Set<LifecycleElement> checkedInitMethods = new LinkedHashSet<>(this.initMethods.size());
			for (LifecycleElement element : this.initMethods) {
				String methodIdentifier = element.getIdentifier();
				if (!beanDefinition.isExternallyManagedInitMethod(methodIdentifier)) {
					beanDefinition.registerExternallyManagedInitMethod(methodIdentifier);
					checkedInitMethods.add(element);
					if (logger.isTraceEnabled()) {
						logger.trace("Registered init method on class [" + this.targetClass.getName() + "]: " + element);
					}
				}
			}
			Set<LifecycleElement> checkedDestroyMethods = new LinkedHashSet<>(this.destroyMethods.size());
			for (LifecycleElement element : this.destroyMethods) {
				String methodIdentifier = element.getIdentifier();
				if (!beanDefinition.isExternallyManagedDestroyMethod(methodIdentifier)) {
					beanDefinition.registerExternallyManagedDestroyMethod(methodIdentifier);
					checkedDestroyMethods.add(element);
					if (logger.isTraceEnabled()) {
						logger.trace("Registered destroy method on class [" + this.targetClass.getName() + "]: " + element);
					}
				}
			}
			this.checkedInitMethods = checkedInitMethods;
			this.checkedDestroyMethods = checkedDestroyMethods;
		}

N330****
private static class LifecycleElement {
	//这个就是存方法的属性
	private final Method method;

	private final String identifier;
	}

N330*****  //这个对象会存一个bean的类class以及类中带@Resource的方法和属性到对应集合
public class InjectionMetadata {

	private static final Log logger = LogFactory.getLog(InjectionMetadata.class);
	
	private final Class<?> targetClass;
	//N130******   这个集合元素类型InjectedElement
	private final Collection<InjectedElement> injectedElements;

	@Nullable
	private volatile Set<InjectedElement> checkedElements;


	public InjectionMetadata(Class<?> targetClass, Collection<InjectedElement> elements) {
        //构造函数，类class
		this.targetClass = targetClass;
        //带有目标注解的属性或者方法的集合
		this.injectedElements = elements;
	}
	//这个方法也就是把集合injectedElements的数据处理下放到checkedElements中
	public void checkConfigMembers(RootBeanDefinition beanDefinition) {
		Set<InjectedElement> checkedElements = new LinkedHashSet<>(this.injectedElements.size());
		for (InjectedElement element : this.injectedElements) {
			Member member = element.getMember();
			if (!beanDefinition.isExternallyManagedConfigMember(member)) {
				beanDefinition.registerExternallyManagedConfigMember(member);
				checkedElements.add(element);
				if (logger.isTraceEnabled()) {
					logger.trace("Registered injected element on class [" + this.targetClass.getName() + "]: " + element);
				}
			}
		}
		this.checkedElements = checkedElements;
	}

N330******
public abstract static class InjectedElement {
		//Member这个类是Field和Method的父类，也就表示InjectedElement这个类及其子类可以装下方法或属性
		protected final Member member;
		//表示是否为属性
		protected final boolean isField;
}

InitDestroyAnnotationBeanPostProcessor 64 N331
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    	//N332  这步是拿到这个bean的带有（N130**中构造函数存到initAnnotationType和destroyAnnotationType）这两个属性中的注解的方法（也就是@PostConstruct和@PreDestroy），这些方法会被封装进LifecycleMetadata metadata中返回。
        InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata metadata = this.findLifecycleMetadata(beanType);
    	//N330***
        metadata.checkConfigMembers(beanDefinition);
    }

InitDestroyAnnotationBeanPostProcessor 108 N332
private InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
        if (this.lifecycleMetadataCache == null) {
            return this.buildLifecycleMetadata(clazz);
        } else {
            //首先会查询lifecycleMetadataCache这个缓存中是否有这个类名作为key的metadata
            InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata metadata = (InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata)this.lifecycleMetadataCache.get(clazz);
            //如果缓存里没有，就进行加锁，加锁后再次获取并判断是否为空，避免第一个拿到锁到释放期间，有其他的线程在等待，而第一个			执行完后，他们其实可以直接拿缓存，不需要继续执行。
            if (metadata == null) {
                synchronized(this.lifecycleMetadataCache) {
                    metadata = (InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata)this.lifecycleMetadataCache.get(clazz);
                    if (metadata == null) {
                        //N333  走到这里就说明现在缓存中确实没有该bean的metadata，则进入buildLifecycleMetadata方法进行收集
                        metadata = this.buildLifecycleMetadata(clazz);
                        //收集完毕后添加到缓存，类名作为key。此时第一次创建完成，有可能已经有现成在等待锁，如果获取锁后没有再次判断，则可能出现多次收集并覆盖。
                        this.lifecycleMetadataCache.put(clazz, metadata);
                    }

                    return metadata;
                }
            } else {
                return metadata;
            }
        }
    }

N333
private InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata buildLifecycleMetadata(Class<?> clazz) {
    	//这两个集合List分别存带有@PostConstruct和@PreDestroy的方法
        List<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> initMethods = new ArrayList();
        List<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> destroyMethods = new ArrayList();
        Class targetClass = clazz;
		//do-while循环是找当前类所有方法中带[initAnnotationType和destroyAnnotationType两个属性]存的注解的方法				（@PostConstruct和@PreDestroy）,每次循环都去寻找父类
        do {
            List<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> currInitMethods = new ArrayList();
            List<InitDestroyAnnotationBeanPostProcessor.LifecycleElement> currDestroyMethods = new ArrayList();
            ReflectionUtils.doWithLocalMethods(targetClass, (method) -> {
                if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
                    InitDestroyAnnotationBeanPostProcessor.LifecycleElement element = new InitDestroyAnnotationBeanPostProcessor.LifecycleElement(method);
                    currInitMethods.add(element);
                    if (this.logger.isTraceEnabled()) {
                        this.logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
                    }
                }

                if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
                    currDestroyMethods.add(new InitDestroyAnnotationBeanPostProcessor.LifecycleElement(method));
                    if (this.logger.isTraceEnabled()) {
                        this.logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
                    }
                }

            });
            initMethods.addAll(0, currInitMethods);
            destroyMethods.addAll(currDestroyMethods);
            targetClass = targetClass.getSuperclass();
        } while(targetClass != null && targetClass != Object.class);
		//最后将带有@PostConstruct和@PreDestroy注解的方法封装到LifecycleMetadata类中
        return new InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata(clazz, initMethods, destroyMethods);
    }

CommonAnnotationBeanPostProcessor 160 N334    //类似于N332
private InjectionMetadata findResourceMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
        String cacheKey = StringUtils.hasLength(beanName) ? beanName : clazz.getName();
    	// 首先会查询injectionMetadataCache这个缓存中是否有这个类名作为key的metadata
        InjectionMetadata metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
    	//如果缓存中没有或者metadata中targetClass != class，则会加锁，然后重新判断缓存。依旧不满足则进行收集
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized(this.injectionMetadataCache) {
                metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
					//N335   走到这里就说明现在缓存中确实没有该bean的metadata，则进入buildResourceMetadata方法进行收集
                    metadata = this.buildResourceMetadata(clazz);
                    //收集完毕后添加到缓存，类名作为key。此时第一次创建完成，有可能已经有现成在等待锁，如果获取锁后没有再次判断，则可能出现多次收集并覆盖。
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }

        return metadata;
    }

CommonAnnotationBeanPostProcessor 180 N335   //类似于N333
private InjectionMetadata buildResourceMetadata(Class<?> clazz) {
    	//这个容器存这个类及其父类中满足条件的属性和方法
        List<InjectedElement> elements = new ArrayList();
        Class targetClass = clazz;
		//这里循环找类中的方法和属性，然后找其父类循环下去
        do {
            //这个容器是InjectedElement类型的容器，而InjectedElement中属性Member是method和field的父类，所以可以存放属性				和方法（多态），这个容器存当前类中满足条件的方法和属性，每次循环都会清空
            List<InjectedElement> currElements = new ArrayList();
            //这类方法，获取bean内的所有方法或属性，然后遍历调用回调方法
            ReflectionUtils.doWithLocalFields(targetClass, (field) -> {
                if (webServiceRefClass != null && field.isAnnotationPresent(webServiceRefClass)) {
                    if (Modifier.isStatic(field.getModifiers())) {
                        throw new IllegalStateException("@WebServiceRef annotation is not supported on static fields");
                    }

                    currElements.add(new CommonAnnotationBeanPostProcessor.WebServiceRefElement(field, field, (PropertyDescriptor)null));
                } else if (ejbRefClass != null && field.isAnnotationPresent(ejbRefClass)) {
                    //主要看到这里，@resource注解的收集,ResourceElement是InjectedElement的子类，所以能存属性或者方法
                    if (Modifier.isStatic(field.getModifiers())) {
                        throw new IllegalStateException("@EJB annotation is not supported on static fields");
                    }
                     //将满足条件的属性封装起来放入容器中
                    currElements.add(new CommonAnnotationBeanPostProcessor.EjbRefElement(field, field, (PropertyDescriptor)null));
                } else if (field.isAnnotationPresent(Resource.class)) {
                    if (Modifier.isStatic(field.getModifiers())) {
                        throw new IllegalStateException("@Resource annotation is not supported on static fields");
                    }

                    if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
                        currElements.add(new CommonAnnotationBeanPostProcessor.ResourceElement(field, field, (PropertyDescriptor)null));
                    }
                }

            });
            ReflectionUtils.doWithLocalMethods(targetClass, (method) -> {
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                if (BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                    if (method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                        PropertyDescriptor pdx;
                        if (webServiceRefClass != null && bridgedMethod.isAnnotationPresent(webServiceRefClass)) {
                            if (Modifier.isStatic(method.getModifiers())) {
                                throw new IllegalStateException("@WebServiceRef annotation is not supported on static methods");
                            }

                            if (method.getParameterCount() != 1) {
                                throw new IllegalStateException("@WebServiceRef annotation requires a single-arg method: " + method);
                            }

                            pdx = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                            currElements.add(new CommonAnnotationBeanPostProcessor.WebServiceRefElement(method, bridgedMethod, pdx));
                        } else if (ejbRefClass != null && bridgedMethod.isAnnotationPresent(ejbRefClass)) {
                            if (Modifier.isStatic(method.getModifiers())) {
                                throw new IllegalStateException("@EJB annotation is not supported on static methods");
                            }

                            if (method.getParameterCount() != 1) {
                                throw new IllegalStateException("@EJB annotation requires a single-arg method: " + method);
                            }

                            pdx = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                            currElements.add(new CommonAnnotationBeanPostProcessor.EjbRefElement(method, bridgedMethod, pdx));
                        } else if (bridgedMethod.isAnnotationPresent(Resource.class)) {
                            //主要看到这里，@resource注解的收集,ResourceElement是InjectedElement的子类，所以能存属性或者方法
                            if (Modifier.isStatic(method.getModifiers())) {
                                throw new IllegalStateException("@Resource annotation is not supported on static methods");
                            }

                            Class<?>[] paramTypes = method.getParameterTypes();
                            if (paramTypes.length != 1) {
                                throw new IllegalStateException("@Resource annotation requires a single-arg method: " + method);
                            }
							//将满足条件的方法封装起来放入容器中
                            if (!this.ignoredResourceTypes.contains(paramTypes[0].getName())) {
                                PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                                currElements.add(new CommonAnnotationBeanPostProcessor.ResourceElement(method, bridgedMethod, pd));
                            }
                        }
                    }

                }
            });
            //将当前类满足条件的属性和方法放入到总容器中
            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        } while(targetClass != null && targetClass != Object.class);
		//最后会包装总容器返回
        return new InjectionMetadata(clazz, elements);
    }

AutowiredAnnotationBeanPostProcessor 115 N336
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    	//N337
        InjectionMetadata metadata = this.findAutowiringMetadata(beanName, beanType, (PropertyValues)null);
    	//N130*****
        metadata.checkConfigMembers(beanDefinition);
    }

AutowiredAnnotationBeanPostProcessor 279 N337    //类似于N332和N334
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
        String cacheKey = StringUtils.hasLength(beanName) ? beanName : clazz.getName();
        InjectionMetadata metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized(this.injectionMetadataCache) {
                metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
					//N338  主要看这个方法
                    metadata = this.buildAutowiringMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }

        return metadata;
    }

AutowiredAnnotationBeanPostProcessor 299 N338   //类似N333和N335，不详细讲解了
private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
        List<InjectedElement> elements = new ArrayList();
        Class targetClass = clazz;

        do {
            List<InjectedElement> currElements = new ArrayList();
            ReflectionUtils.doWithLocalFields(targetClass, (field) -> {
                AnnotationAttributes ann = this.findAutowiredAnnotation(field);
                if (ann != null) {
                    if (Modifier.isStatic(field.getModifiers())) {
                        if (this.logger.isInfoEnabled()) {
                            this.logger.info("Autowired annotation is not supported on static fields: " + field);
                        }

                        return;
                    }

                    boolean required = this.determineRequiredStatus(ann);
                    currElements.add(new AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement(field, required));
                }

            });
            ReflectionUtils.doWithLocalMethods(targetClass, (method) -> {
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                if (BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                    AnnotationAttributes ann = this.findAutowiredAnnotation(bridgedMethod);
                    if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                        if (Modifier.isStatic(method.getModifiers())) {
                            if (this.logger.isInfoEnabled()) {
                                this.logger.info("Autowired annotation is not supported on static methods: " + method);
                            }

                            return;
                        }

                        if (method.getParameterCount() == 0 && this.logger.isInfoEnabled()) {
                            this.logger.info("Autowired annotation should only be used on methods with parameters: " + method);
                        }

                        boolean required = this.determineRequiredStatus(ann);
                        PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                        currElements.add(new AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement(method, required, pd));
                    }

                }
            });
            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        } while(targetClass != null && targetClass != Object.class);

        return new InjectionMetadata(clazz, elements);
    }

DefaultSingletonBeanRegistry 69 N340
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
    	//加锁
        synchronized(this.singletonObjects) {
            //一级缓存中不存在则进入if
            if (!this.singletonObjects.containsKey(beanName)) {
                //N341   将(beanName, singletonFactory)映射关系加入到三级缓存中，来看看这个singletonFactory
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }

        }
    }

AbstractAutowireCapableBeanFactory 609 N341
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
            Iterator var5 = this.getBeanPostProcessors().iterator();

            while(var5.hasNext()) {
                BeanPostProcessor bp = (BeanPostProcessor)var5.next();
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor)bp;
                    //拿到所有的beanPostProcess，调用getEarlyBeanReference方法，此方法基本都是直接返回exposedObject对象
                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                }
            }
        }

        return exposedObject;
    }

到这里，先做一个小结，首先是从三级缓存中取对象，如果有则调用factoryBean相关的判断和处理逻辑，然后判断是否循环依赖且非单例，是的话就抛异常。然后来到单例的创建（也是比较重要且核心的地方），首先是创建实例，总共有三种方式创建实例，第一种就是判断是否存在factory-bean和factory-method两个属性，如果存在则通过这两个属性所指的方法去创建bean然后返回。如果第一种不存在，第二种则是收集@autowired的构造函数，这里需要注意不能出现多个required=true的构造函数（如果只有一个有参构造函数且不带@autowired注解，则会将这个构造函数收集），然后调用最终筛选（筛选其实就是排序，通过public+参数最多的规则）出来的构造函数进行实例化并返回。前面两种都不成功则最后调用无参构造函数进行实例化并返回。实例化完成后，收集bean所属类中带有【@PostConstruct、@PreDestroy的方法】【@Resource、@Autowired、@Value的方法和属性】，然后存入到相对应的容器中，方便接下来使用。接着为了解决单例bean循环依赖问题(循环依赖会单独的用一个小节讲点，重点)，需要将bean放入到三级缓存中，以上就是本节源码解析的内容小结，下一小节开始会回到N313的this.populateBean(beanName, mbd, instanceWrapper)方法调用源码解析

程序バ鱼仔

关注

10
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
Spring源码解析(五)-Bean的实例化流程(上)

Bean的实例化流程主要分为了:1.实例化一个空的对象，此时这个Bean内的属性并不完整；2.给Bean中的属性赋值；3.调用Bean中的初始化相关方法及其一些特定步骤，包括生成代理类等。具体的咱们通过代码解析就可以看明白了，学习源码是痛苦的牡但是学会了后就是很爽的，希望大家能体会到最后那种收获的感觉。
复制链接

扫一扫