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

在前面已经完成了对需要实例化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的ListList<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) {//N306return 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生成的Beanreturn 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方法返回我们所需要的beanobject = 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的那个mapthis.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要删除该beanthis.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循环调用达到销毁beanthis.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注解，所以通过选中的构造函数来实例化beanreturn this.autowireConstructor(beanName, mbd, ctors, args);}}}}}

AbstractAutowireCapableBeanFactory - 855 - N315
protected BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {//N316return (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这个属性所指向的beanfactoryBean = 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, argsthis.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。//N320if (beanClass != null && this.hasInstantiationAwareBeanPostProcessors()) {Iterator var3 = this.getBeanPostProcessors().iterator();while(var3.hasNext()) {BeanPostProcessor bp = (BeanPostProcessor)var3.next();//遍历所有的BeanPostProcessor,判断是否为SmartInstantiationAwareBeanPostProcessorif (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 {//首先会进入到这个方法里面，这里依旧是一个函数式接口的使用，然后内部会调用到传入的函数式接口实现的代码。//这里可以发现，当我们需要遍历某个类中的方法，并且对所有方法进行遍历单独处理，就可以用这种函数式接口回调的方式。//N322ReflectionUtils.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");//将注解标记的方法和注解信息封装成LookupOverrideLookupOverride 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) {//N323doWithMethods(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里函数式接口实现中的方法代码。所以我们回到N120mc.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) {//N325return (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()) : //一般都是进入到这里，通过反射调用构造方法完成实例化beanstrategy.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   通过反射调用构造函数的方式实例化beanbeanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);}//封装成了beanWrapperBeanWrapper 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);}}}//通过反射调用构造器方法来实例化beanreturn 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) {//获取所有的BeanPostProcessorIterator var4 = this.getBeanPostProcessors().iterator();while(var4.hasNext()) {BeanPostProcessor bp = (BeanPostProcessor)var4.next();//遍历所有的BeanPostProcessor,判断是否为MergedBeanDefinitionPostProcessorif (bp instanceof MergedBeanDefinitionPostProcessor) {MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor)bp;//N330//N336bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);}}}

CommonAnnotationBeanPostProcessor 125 N330
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {     //331   @PostConstruct @PreDestroysuper.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);//334   @ResourceInjectionMetadata 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.classsetInitAnnotationType(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****   这个集合元素类型LifecycleElementprivate final Collection<LifecycleElement> initMethods;private final Collection<LifecycleElement> destroyMethods;@Nullableprivate volatile Set<LifecycleElement> checkedInitMethods;@Nullableprivate volatile Set<LifecycleElement> checkedDestroyMethods;public LifecycleMetadata(Class<?> targetClass, Collection<LifecycleElement> initMethods,Collection<LifecycleElement> destroyMethods) {//构造函数，类classthis.targetClass = targetClass;//下面两个是类中带@PostConstruct和@PreDestroy的方法集合this.initMethods = initMethods;this.destroyMethods = destroyMethods;}//这个方法其实就是把initMethods和destroyMethods处理后放到checkedInitMethods和checkedDestroyMethodspublic 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******   这个集合元素类型InjectedElementprivate final Collection<InjectedElement> injectedElements;@Nullableprivate volatile Set<InjectedElement> checkedElements;public InjectionMetadata(Class<?> targetClass, Collection<InjectedElement> elements) {//构造函数，类classthis.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的metadataInitDestroyAnnotationBeanPostProcessor.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的metadataInjectionMetadata 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) {//N337InjectionMetadata 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) {//一级缓存中不存在则进入ifif (!this.singletonObjects.containsKey(beanName)) {//N341   将(beanName, singletonFactory)映射关系加入到三级缓存中，来看看这个singletonFactorythis.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)方法调用源码解析

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

Spring源码解析(七)-Bean属性间的循环依赖
首先复习一下前面学习的Spring容器启动的大致流程,首先Spring会先扫描所有需要实例化的Bean,将这些Bean的信息封装成一个个BeanDefinition,然后注册到BeanDefiniti ...
beaninfo详解源码解析 java_【Spring源码分析】Bean加载流程概览
代码入口之前写文章都会啰啰嗦嗦一大堆再开始,进入[Spring源码分析]这个板块就直接切入正题了. 很多朋友可能想看Spring源码,但是不知道应当如何入手去看,这个可以理解:Java开发者通常从事 ...
Spring源码解析之bean的销毁
阅读须知 Spring源码版本:4.3.8 文章中使用/* */注释的方法会做深入分析正文我们来看几个销毁bean的场景,在一些异常情况,例如Spring上下文初始化失败时,会销毁已经创建的单例b ...
【Spring源码分析】Bean加载流程概览
代码入口之前写文章都会啰啰嗦嗦一大堆再开始,进入[Spring源码分析]这个板块就直接切入正题了. 很多朋友可能想看Spring源码,但是不知道应当如何入手去看,这个可以理解:Java开发者通常从事 ...
Spring源码分析：Bean加载流程概览及配置文件读取
很多朋友可能想看Spring源码,但是不知道应当如何入手去看,这个可以理解:Java开发者通常从事的都是Java Web的工作,对于程序员来说,一个Web项目用到Spring,只是配置一下配置文件而已 ...
Spring源码剖析-单利Bean的实例化(六)
前言前面系列章节我们分析了Spring的IOC的启动流程,包括:容器创建,配置加载,配置解析,Bean注册等几个阶段,所以Bean注册其实就是把Bean的相关属性,依赖关系等封装成BeanDeafi ...
spring源码解析五
2019独角兽企业重金招聘Python工程师标准>>> 1.创建用于承载属性的BeanDefinition 这是一个接口,在spring中存在三种实现:RootBeanDefinit ...
Spring源码解析之 Bean与BeanDefinition详解
文章目录 Spring解决的核心问题 Bean与BeanDefinition 代码验证BeanDefinition 代码运行测试 Spring容器主要流程与BeanDefinition相关的类 At ...
【框架源码】Spring源码解析之BeanDefinition加载流程解析
观看本文之前,我们先思考一个问题,Spring是如何描述Bean对象的? Spring是根据BeanDefinition来创建Bean对象,BeanDefinition就是Spring中表示Bean定 ...

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

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

最新文章

热门文章