springboot-spring源码系列（八）

finishBeanFactoryInitialization(beanFactory)

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 初始化此上下文的转换服务。
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		//如果没有应用于注释属性值的字符串解析器,则注册一个默认的
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		/**
         * LoadTimeWeaverAware:
         * 用于当类被载入jvm时，动态转化类
 		 * 使用自定义的类加载器，可以节省性能
		 * 唯一的实现类 AspectJWeavingEnabler
         * 如果beanFactory中有实现了该接口的类,直接对该类进行实例化放入singletonObjects,用于其他的类的转化
         */
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// 停止使用临时类加载器进行类型匹配。
		beanFactory.setTempClassLoader(null);

		// 允许缓存所有bean定义元数据，而不需要进一步的更改
		beanFactory.freezeConfiguration();

		//实例化所有剩余的（非延迟初始化）单例。
		beanFactory.preInstantiateSingletons();
	}

public void preInstantiateSingletons() throws BeansException {
		//拿到beanDefinitionNames中的所有beanName
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
		//遍历每一个beanDefinition对象的名字
		for (String beanName : beanNames) {
			/**
			 * 用xml的方式来演示一下
			 * <bean id = "par" class = "xxx.xxx.xxx",>
			 *      <propertie name = "",value = " "></>
			 * </bean>
			 *
			 *  <bean id = "chi"  parent="par">        
			 *          <propertie name = "",value = " "></>
			 * 	</bean>
			 * 	这并不是一个真正的子类,这是配置在xml中指定了父类,在beanDefinitionMap中存在两个beanDefinition
			 * 	但是子beanDefinition并没有父beanDefinition的属性、方法....等，只有自己配置的属性
			 *  mergedBeanDefinitions他是另一个存放beanDefinition的集合 只不过它是用来合并的
			 * 	所以该方法就会去找mergedBeanDefinitions中是否有该beanDefinition,如果有则代表不是一个合并beanDefinition直接返回
			 * 	如果没有则进行合并
			 */
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 是否是抽象 && 是否是单例 && 是否是懒加载 
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				//判断他是否是一个FactoryBean,至于什么是FactoryBean后面会讲
				if (isFactoryBean(beanName)) {
                	//如果是一个FactoryBean,直接进行实例化操作,并且传递的beanName是"&"
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    //再判断一次防止初始化bean的过程中通过扩展点进行修改
					if (bean instanceof FactoryBean) {
                    	//把当前bean强转为一个FactoryBean类型
						final FactoryBean<?> factory = (FactoryBean<?>) bean;
                        //定义一个标识是否要急切加载,我的理解是你的FactoryBean此时仅仅只是把本身类实例化了
                        //如果你实现了SmartFactoryBean,那么此时就会把接口的方法中返回的对象也实例化
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						} else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				} else {
					//非FactoryBean的类进行实例化操作
					getBean(beanName);
				}
			}
		}
	}

	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}
    
    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
							  @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		/**
		 * 从别名集合中查找是否有key为name的value
         * 如果是name是以&开头,则从别名集合中查找是否有key为&的value
         * 如果找到了返回别名,否则返回原来的name
		 */
		final String beanName = transformedBeanName(name);
		Object bean;
		/**
		 *  第一次调用getSingleton()方法 ,看是否能够从singletonObjects中拿到该对象
		 *  这个方法循环依赖的时候进行细讲
		 */
		Object sharedInstance = getSingleton(beanName);
		//如果singletonObjects已经存在bean,不会进行实例化
		if (sharedInstance != null && args == null) {
        	//该方法就是对通过beanName拿到实现FactoryBean的bean的处理
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		} else {
			//判断key为beanName的bean是否在prototypesCurrentlyInCreation的线程池中
            //如果存在表示当前bean处于正在创建的阶段
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
			//判断beanFactory是否有父工厂,spring是没有的,除非手动给beanFactory的parentBeanFactory设置一个工厂
			BeanFactory parentBeanFactory = getParentBeanFactory();
            //判断父工厂是否为空 && beanDefinitionMap中不存在key为beanName的beanDefinition
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				} else if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				} else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
			 //传递进来的参数为typeCheckOnly=fasle
			if (!typeCheckOnly) {
				//mergedBeanDefinitions移除掉key为beanName的beanDefinition
                //添加进alreadyCreated集合中	
				markBeanAsCreated(beanName);
			}
			try {
            	//从MergedLocalBeanDefinition集合中拿到key为beanName的beanDefinition
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                //判断这个beanDefinition是否是“抽象的”,即不需要进行实例化的而只是作为具体子bean定义的父级,默认为false
				checkMergedBeanDefinition(mbd, beanName, args);
				//拿到当前类上的@dependsOn注解的值
                //@DependsOn控制bean加载顺序
				String[] dependsOn = mbd.getDependsOn();
                //是否为null
				if (dependsOn != null) {
                	//循环解析每一个依赖的类
					for (String dep : dependsOn) {
                    	//判断依赖的类是否存在于beanDefinitionMap,如果不存在直接报错
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
                        //注册进dependentBeanMap集合中
						registerDependentBean(dep, beanName);
                        //对依赖的bean进行实例化
						getBean(dep);
					}
				}
				/**
				 * 判断是否是单例的  为什么还需要判断一次
				 * 因为他是重新从map中拿到的RootBeanDefinition
				 * 有可能发生BeanDefinition的人为修改
				 */
				if (mbd.isSingleton()) {

					/**
					 *  第二次调用getSingleton()方法,是第一次调用时的重载方法
					 *  先执行getSingleton()然后在该方法内执行createBean()
					 */
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						} catch (BeansException ex) {
                      	    //尝试从单例缓存中删除实例，它可能已经存在于其中
							//允许循环创造过程。
							//同时删除所有接收到对该bean的临时引用的bean。
							destroySingleton(beanName);
							throw ex;
						}
					});

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		//判断beanName是否为null
		Assert.notNull(beanName, "Bean name must not be null");
        //尝试获取一个锁
		synchronized (this.singletonObjects) {
			//尝试从spring单例池中获取bean
			Object singletonObject = this.singletonObjects.get(beanName);
            //获取的单例bean是否为null
			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!)");
				}
				//检查是否处于被剔除的队列中 && 添加到singletonsCurrentlyInCreation集合中,表示正在被创建
				beforeSingletonCreation(beanName);

protected void beforeSingletonCreation(String beanName) {
	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
}

				//表示单例bean是否创建成功
				boolean newSingleton = false;
                //抑制异常(那些异常不会报错)的集合是否为null
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                //如果为null,显示创建一个LinkedHashSet集合
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					//这个方法就是执行 creatbean() 因为 lamdba表达式覆写了该方法
					singletonObject = singletonFactory.getObject();

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
        //定义变量接收传递进来的beanDefinition      
		RootBeanDefinition mbdToUse = mbd;

		//确保bean类在这一点上得到了实际的解析，并且
		//在动态解析类的情况下克隆bean定义	
		//不能存储在共享合并bean定义中。
		//进行一些安全验证
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}
		try {
			//处理lookup-method和replace-method 配置,spring将这两个类统称为准备方法
			mbdToUse.prepareMethodOverrides();
		} catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}
		try {		
			/**
			 * 在spring的bean的初始化过程中,一共在九个地方执行了5种后置处理器
             * 
			 * 第一处执行了InstantiationAwareBeanPostProcessor类型的beanPostProcessor
			 * 首先他会判断beanFactory中是否有该种类型的beanPostProcessor,如果没有直接返回null
             * 如果有,则循环所有该种类型的beanPostProcessor执行他的postProcessBeforeInstantiation方法
             * 如果返回值不为空剩下的beanPostProcessor不会执行,最后执行本次的的BeanPostProcesso的postProcessAfterInitialization方法
             * 
             * InstantiationAwareBeanPostProcessor
			 *	InstantiationAwareBeanPostProcessor接口继承BeanPostProcessor接口，它内部提供了3个方法，再加上BeanPostProcessor接口内部的2个方法，所以实现这个接口需要实现5个方法。InstantiationAwareBeanPostProcessor接口的主要作用在于目标对象的实例化过程中需要处理的事情，包括实例化对象的前后过程以及实例的属性设置
			 *  在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()方法的Object bean = resolveBeforeInstantiation(beanName, mbdToUse);方法里面执行了这个后置处理器
			 *		1、postProcessBeforeInstantiation
			 *		在目标对象实例化之前调用，方法的返回值类型是Object，我们可以返回任何类型的值。由于这个时候目标对象还未实例化，所以这个返回值可以用来代替原本该生成的目标对象的实例(一般都是代理对象)。如果该方法的返回值代替原本该生成的目标对象，后续只有postProcessAfterInitialization方法会调用，其它方法不再调用；否则按照正常的流程走
			 *		2、postProcessAfterInstantiation
			 *		方法在目标对象实例化之后调用，这个时候对象已经被实例化，但是该实例的属性还未被设置，都是null。如果该方法返回false，会忽略属性值的设置；如果返回true，会按照正常流程设置属性值。方法不管postProcessBeforeInstantiation方法的返回值是什么都会执行
			 *		3、postProcessPropertyValues
		     *		方法对属性值进行修改(这个时候属性值还未被设置，但是我们可以修改原本该设置进去的属性值)。如果postProcessAfterInstantiation方法返回false，该方法不会被调用。可以在该方法内对属性值进行修改
             *		4、postProcessBeforeInitialization&5.postProcessAfterInitialization	
             *		父接口BeanPostProcessor的2个方法postProcessBeforeInitialization和postProcessAfterInitialization都是在目标对象被实例化之后，并且属性也被设置之后调用的
             *
			 */
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            //如果返回的bean不为null,直接结束当前bean的创建
			if (bean != null) {
				return bean;
			}
		} catch (Throwable ex) {
			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}
		try {
			//真正进行bean的创建
			Object beanInstance = doCreateBean(beanName, mbdToUse, args)
			return beanInstance;
		}
	}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
		//BeanWrapper对bean进行封装,大部分情况下是在spring ioc内部进行使用
		BeanWrapper instanceWrapper = null;
        //是否是单例
		if (mbd.isSingleton()) {
			//从factoryBeanInstanceCache(缓存未完成的FactoryBean实例)移除当前正在创建的bean,保存进instanceWrapper中
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {			
			/**
			 *  得到一个生成策略，判断是通过构造器还是set方法来new
			 *  通过反射创建一个对象只是new出来了一个对象并没有进行属性的注入
			 */
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {		
		//获得当前正在创建的bean的Class实例
		Class<?> beanClass = resolveBeanClass(mbd, beanName);
		/**
		 * 确保类是可访问的
		 * 默认情况下，即使是private修饰的类，Spring也是允许访问的，
		 * 因为{@link AbstractBeanDefinition#isNonPublicAccessAllowed()}默认返回true
		 */
		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());
		}
		/**
		 * 正在创建的Bean若实现了Supplier接口，则调用该接口的get()方法返回实例
		 * JDK8新特性，支持函数式创建对象，Supplier接口中只有一个get()方法
		 * 比如：Supplier<User> sup= User::new；//此时并不会调用对象的构造方法，即不会创建对象
		 * sup.get() //此时会调用对象的构造方法，即获得到真正对象,且每次都会调用构造方法，即每次获得的对象不同
		 */
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}
		/**
		 * 解析设置的FactoryMethod方法
		 * 如果该类设置了FactoryMethod的方法那么也不会走生命周期,直接执行 FactoryMethod指定的方法
		 * 返回一个对象作为bean返回 这个方法一定得是静态的
		 *  1. xml的方式指定 Factory-method = ""
		 *  2. 静态方法上了@bean
		 */
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}
		/**
		 * 从spring的原始注释可以知道这个是一个Shortcut,什么意思呢?
		 * 当多次构建同一个bean时，可以使用这个Shortcut,
		 * 也就是说不在需要次推断应该使用哪种方式构造bean
		 * 比如在多次构建同一个prototype类型的bean时，就可以走此处的Shortcut
		 * 这里的resolved和mbd.constructorArgumentsResolved将会在bean第一次实例化的过程中被设置后面来证明
		 */
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
        //如果是通过上面的方式创建对象,判断是否有已经解析出来的有参构造方法
		if (resolved) {
			if (autowireNecessary) {
				//通过构造方法创建bean对象
				return autowireConstructor(beanName, mbd, null, null);
			} else {
				//通过默认的无参构造方法创建bean对象
				return instantiateBean(beanName, mbd);
			}
		}
		/**
		 * 第二处调用后置处理器执行SmartInstantiationAwareBeanPostProcessor类型的beanPostProcessor
         *   SmartInstantiationAwareBeanPostProcessor
         *   智能实例化Bean后置处理器（继承InstantiationAwareBeanPostProcessor）
		 *		1、determineCandidateConstructors
         *		检测Bean的构造器，可以检测出多个候选构造器
         *		2、getEarlyBeanReference
         *		循环引用的后置处理器，这个东西比较复杂，获得提前暴露的bean引用。主要用于解决循环引用的问题，只有单例对象才会调用此方法
         *		3、predictBeanType
         *		预测bean的类型
		 *
		 *  推断构造方法：
		 *   1.如果没有提供构造方法—>返回为null
		 * 	 2.如果提供了默认构造方法有且只有一个—>返回为null
         *   3.如果提供了2个一个有参一个无参构造方法->返回为有参的构造方法
		 *   4.如果是多个–>返回也为null,这个时候spring迷茫，不知道该用哪个，就为null,
		 *   5.如果是多个，且有一个加了@AutoWried=true 就返回这个加@AutoWried的这个构造器
		 *   6.如果是多个，且有多个加了@AutoWried=true的，这个spring会异常，会报错，
		 *   7.如果是多个，且有多个加了@AutoWried=false的—>会返回多个构造方法—>会再次进行推断，
		 * 		spring怎么找出最优的，
		 *		1.有一个sort排序规则，public 参数最长的排在最前面，private 的在最后面。
		 * 		2.更加精准的在前面。
		 * 		3，差异权重。
		 * }
		 */
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);

protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
	//省略了循环判断过程,很简单自己看
	//推断构造方法,通过AutowiredAnnotationBeanPostProcessor后置处理器
	Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
	if (ctors != null) {
		return ctors;
       }
	return null;
	}
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
			throws BeanCreationException {
		/**
		 * 处理含有@Lookup注解的方法
		 * 如果lookupMethodsChecked中没有该BeanName,则对该bean的所有方法进行过滤
		 */
		if (!this.lookupMethodsChecked.contains(beanName)) {
			try {
				//在方法中循环过滤所有的方法
				ReflectionUtils.doWithMethods(beanClass, method -> {
					//获取method上的@Lookup注解
					Lookup lookup = method.getAnnotation(Lookup.class);
					 //存在此注解的话，就将方法和注解中的内容构建LookupOverride对象，设置进BeanDefinition中
					if (lookup != null) {
						Assert.state(beanFactory != null, "No BeanFactory available");
						LookupOverride override = new LookupOverride(method, lookup.value());
						try {
							RootBeanDefinition mbd = (RootBeanDefinition) beanFactory.getMergedBeanDefinition(beanName);
							mbd.getMethodOverrides().addOverride(override);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(beanName,
								"Cannot apply @Lookup to beans without corresponding bean definition");
						}
					}
				});
			}
			catch (IllegalStateException ex) {
				throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
			}
			//无论对象中是否含有@Lookup方法，过滤完成后都会放到集合中，证明此Bean已经检查完@Lookup注解了
			this.lookupMethodsChecked.add(beanName);
		}
		/**
		 * 从缓存中拿构造函数，不存在的话就进入代码块中再拿一遍，还不存在的话就进行下方的逻辑
		 * 同时这个参数是最终返回的
		 * 这里是双重检查
		 */
		Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
		if (candidateConstructors == null) {
			//尝试拿锁
			synchronized (this.candidateConstructorsCache) {
				//再拿一次，双重检查
				candidateConstructors = this.candidateConstructorsCache.get(beanClass);
                //是否还为null
				if (candidateConstructors == null) {
					//声明一个变量用来接收 Bean 中所有的构造函数
					Constructor<?>[] rawCandidates;
					//获取Bean中所有的构造函数,任何类型的构造函数都能拿到
					rawCandidates = beanClass.getDeclaredConstructors();
					//暂时候选构造函数集合，通过下面代码得知，这个集合中只能有一个值
					List<Constructor<?>> candidates = new ArrayList<>(rawCandidates.length);
					 // 带有依赖项的构造函数
					Constructor<?> requiredConstructor = null;
					 // 默认使用的构造函数
					Constructor<?> defaultConstructor = null;
					 // 获取主构造函数(在Klion语言中存在),下方关于这个变量不再解释，不研究
					Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
					/**
					 * 标识，表示不是合成构造函数的数量
					 * 合成构造函数 -> 有方法参数并对实例进行赋值的构造函数
					 */
					int nonSyntheticConstructors = 0;
					 //遍历所有的构造函数
					for (Constructor<?> candidate : rawCandidates) {
						 //是否是内部类，如果是非静态内部类，编译器在编译的过程中会对其中的方法加入关键字Synthetic和外部类进行区分
						if (!candidate.isSynthetic()) {
							nonSyntheticConstructors++;
						}
						else if (primaryConstructor != null) {
							continue;
						}    
						/**
						 * 查找构造函数上{@link Autowired}注解的属性
						 * 断点应该还判断{@link Value}的属性，但是此注解不能注释在构造函数上，暂时不理解
						 */
						AnnotationAttributes ann = findAutowiredAnnotation(candidate);
						/**
						 * 注解不存在,则再通过方法获取用户类，如果是用户类则返回用户类，还判断了CGLIB情况，
						 * CGLIB情况则返回目标类，然后获取参数一致的构造函数再获取注解
						 */
						if (ann == null) {
							Class<?> userClass = ClassUtils.getUserClass(beanClass);
							if (userClass != beanClass) {
								try {
									Constructor<?> superCtor =
											userClass.getDeclaredConstructor(candidate.getParameterTypes());
									ann = findAutowiredAnnotation(superCtor);
								} 
							}
						}
						//构造函数上存在注解
						if (ann != null) {
							if (requiredConstructor != null) {
								throw new BeanCreationException(beanName,
										"Invalid autowire-marked constructor: " + candidate +
										". Found constructor with 'required' Autowired annotation already: " +
										requiredConstructor);
							}
							//获取@Autowired注解中required属性的值
							boolean required = determineRequiredStatus(ann);
							/**
							 * 为true则将这个构造函数设置为带有依赖项的构造函数
							 * 并进行一个判断，不可存在多个带有依赖项的构造函数
							 */
							if (required) {
								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;
						}
					}
					/**
					 * 存在@Autowired注解的函数，并且required值为false，则此注解不起作用
					 * 但是存在默认构造函数，则将默认构造函数添加进集合中
					 * 并将集合变为数组使用
					 */
					if (!candidates.isEmpty()) {					
						if (requiredConstructor == null) {
							if (defaultConstructor != null) {
								candidates.add(defaultConstructor);
							}
							else if (candidates.size() == 1 && logger.isWarnEnabled()) {
								logger.warn("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 = candidates.toArray(new Constructor<?>[candidates.size()]);
					}
					 //如果只存在一个构造函数，且这个构造函数有参数列表，则使用这个构造函数
					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);
				}
			}
		}
		 //使用构造列表中数据，没有值则返回null
		return (candidateConstructors.length > 0 ? candidateConstructors : null);
	}

		//推断出来的构造器是否为null || 当前bean的注入模型是否为构造器注入 || 当前bean是否有手动设置的构造器参数 || 传递进来的args是否为null
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			//利用推断出来的构造方法去实例化对象，
			return autowireConstructor(beanName, mbd, ctors, args);
		}

	//这个方法很长很难,多思考多想
	public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,
			@Nullable Constructor<?>[] chosenCtors, @Nullable final Object[] explicitArgs) {
		/**
		 * 构建Bean实例包装对象 ，用来封装 new出来的对象
		 */
		BeanWrapperImpl bw = new BeanWrapperImpl();
		/**
		 * 给包装对象设置一些属性
		 */
		this.beanFactory.initBeanWrapper(bw);
		/**
		 * Spring对这个Bean进行实例化使用的构造函数
		 */
		Constructor<?> constructorToUse = null;
		/**
		 * Spring执行构造函数所需要的参数类型
		 */
		ArgumentsHolder argsHolderToUse = null;
		/**
		 * Spring执行构造函数所需要的值
		 */
		Object[] argsToUse = null;
		/**
		 * 如果传入了参数值，则把传入的参数值添加进 argsToUse 数组
		 */
		if (explicitArgs != null) {
			argsToUse = explicitArgs;
		}
		else {
			Object[] argsToResolve = null;
			synchronized (mbd.constructorArgumentLock) {
				/**
				 * 获取BeanDefinition中解析完成的构造函数
				 * 第一次实例化bean,一定为null,解析完成后会给这个值赋值，下次就不需要解析
				 */
				constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
				/**
				 * BeanDefinition中存在构造函数并且存在构造函数的参数，赋值进行使用
				 */
				if (constructorToUse != null && mbd.constructorArgumentsResolved) {
					argsToUse = mbd.resolvedConstructorArguments;
					if (argsToUse == null) {
						argsToResolve = mbd.preparedConstructorArguments;
					}
				}
			}
			/**
			 * BeanDefinition中存在缓存的构造函数参数，解析成为参与构造函数实例化的参数
			 */
			if (argsToResolve != null) {
				argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
			}
		}
		/**
		 * BeanDefinition中没有解析完成的构造函数，则需要解析
		 */
		if (constructorToUse == null) {
			/**
			 *  2个判断，满足一个即为true
			 *   1.传入的构造方法数组不为空，spring知道了应该使用那个构造方法
			 *   2.该bean的注入模型为构造器注入
			 */
			boolean autowiring = (chosenCtors != null ||
					mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
			/**
			 * 构造函数参数值
			 */
			ConstructorArgumentValues resolvedValues = null;
			/**
			 * 定义一个变量，意思是构造函数的最小参数个数
			 * 这是一个推断值，Spring并不确定即将使用的构造函数有多少个参数
			 */
			int minNrOfArgs;
			/**
			 * 如果你传入了参数，那么他的最小值就是传入参数的个数
			 */
			if (explicitArgs != null) {
				minNrOfArgs = explicitArgs.length;
			}
			else {
				/**
				 * 获取BeanDefinition中存放的参与构造函数参数的值
				 * 这个值可能通过后置处理器或{@link ImportBeanDefinitionRegistrar}设置
				 * @see mbd.getConstructorArgumentValues().addGenericArgumentValue()
				 * 如果设置的参数有序，就放到ConstructorArgumentValues的map中
				 * 没序，就放到ConstructorArgumentValues的list中
				 */
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				/**
				 * 实例化构造函数参数值存放实例
				 */
				resolvedValues = new ConstructorArgumentValues();
				/**
				 * 确定最小参数个数
				 * 如果你没有通过后置处理器手动往BeanDefinition设置想要调用的构造函数参数 ，则返回零
				 */
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}
			/**
			 * 获取Spring能够明确推断使用的构造函数,也就是传递进来的
			 */
			Constructor<?>[] candidates = chosenCtors;
			/**
			 * Spring并不能够确定的话,就从Class中获取全部的构造函数
			 */
			if (candidates == null) {
				Class<?> beanClass = mbd.getBeanClass();
				try {
					candidates = (mbd.isNonPublicAccessAllowed() ?
							beanClass.getDeclaredConstructors() : beanClass.getConstructors());
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Resolution of declared constructors on bean Class [" + beanClass.getName() +
							"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
				}
			}

			/**
			 * 对所有的构造函数进行排序，先是访问权限后是参数个数，大致如下
			 * 		public权限参数数量由多到少
			 * 		参数列表相同则	protected权限在前，private权限在后
			 * 		最后是默认权限(不加修饰符)
			 *
			 * 例如：
			 * 	public XXX(Object o1, Object o2, Object o3)
			 * 	public XXX(Object o1, Object o2)
			 * 	public XXX(Object o1)
			 * 	protected XXX(String s1, Object o2, Object o3)
			 * 	private XXX(Integer s1, Object o2, Object o3)
			 * 	protected XXX(String s1, Object o2)
			 * 	private XXX(Integer s1, Object o2)
			 * 	XXX(String s1)
			 */
			AutowireUtils.sortConstructors(candidates);
			/**
			 * 定义一个差异变量,这个变量很重要,变量的大小决定着构造函数是否能够被使用
			 */
			int minTypeDiffWeight = Integer.MAX_VALUE;
			/**
			 * 不明确的构造函数集合,正常情况下差异量不可能相同
			 */
			Set<Constructor<?>> ambiguousConstructors = null;
			LinkedList<UnsatisfiedDependencyException> causes = null;
			//遍历每个构造方法
			for (Constructor<?> candidate : candidates) {
				//获取构造方法的参数类型列表
				Class<?>[] paramTypes = candidate.getParameterTypes();
				/**
				 * constructorToUse这个变量存放的是当前bean确定实例化所需要的构造函数
				 * 如果已经添加进去了，那么第一个判断就符合
				 *
				 * 由于之前已经对构造函数进行了排序，而且已经选定
				 * 已经确定使用哪个构造函数了，并且确定使用的函数的参数大于本次函数的参数数量，
				 * 再往后遍历的话，构造函数的参数列表数量越来越小，权限越来越小，越不符合了
				 * 所以直接不再遍历了
				 */
				if (constructorToUse != null && argsToUse.length > paramTypes.length) {
					//已经找到可以满足的构造函数->
					//结束循环因为只剩下更不符合的构造函数了。
					break;
				}
				//如果参数个数小于最小的，则直接开启下一次循环
				if (paramTypes.length < minNrOfArgs) {
					continue;
				}
				//存放构造函数解析完成的参数列表
				ArgumentsHolder argsHolder;
				//存在需要解析的构造函数参数
				if (resolvedValues != null) {
					try {
						//获取构造函数上的{@link ConstructorProperties}注解中的参数
						String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
						//如果上面那个注解为null,则获取构造函数参数列表中属性的名称
						if (paramNames == null) {
							ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
							if (pnd != null) {
								paramNames = pnd.getParameterNames(candidate);
							}
						}
						//对构造函数依赖项进行解析,其中就是调用BeanFactory的resolveDependency进行解析
						argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
								getUserDeclaredConstructor(candidate), autowiring);
					}
				}
				//不存在构造函数参数列表需要解析的参数
				else {
					/**
					 * 如果参数列表的数量与传入进来的参数数量不相等，继续遍历
					 * 否则构建参数列表封装对象
					 */
					if (paramTypes.length != explicitArgs.length) {
						continue;
					}
					argsHolder = new ArgumentsHolder(explicitArgs);
				}
				/**
				 * 计算差异量，根据要参与构造函数的参数列表和本构造函数的参数列表进行计算
				 * 使用的编辑距离算法，数值越小证明使用的几率越大
				 */
				int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
						argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
				/**
				 * 本次的构造函数差异值小于上一个构造函数，则进行构造函数更换
				 */
				if (typeDiffWeight < minTypeDiffWeight) {
					/**
					 * 将确定使用的构造函数设置为本构造函数
					 */
					constructorToUse = candidate;
					/**
					 * 更换使用的构造函数参数封装类
					 */
					argsHolderToUse = argsHolder;
					/**
					 * 更换参与构造函数实例化的参数
					 */
					argsToUse = argsHolder.arguments;
					/**
					 * 差异值更换
					 */
					minTypeDiffWeight = typeDiffWeight;
					/**
					 * 不明确的构造函数列表清空为null
					 */
					ambiguousConstructors = null;
				}
				/**
				 * 差异值相等，则表明构造函数不正常，放入异常集合
				 *
				 * 为什么不在找到的第一时间就返回报错信息
				 * 因为如果在之后的遍历中，找到了更合适的构造函数时，则再有几个重复的都不重要，
				 * 所以找到更好的这个集合参数会被置为空
				 * 根据这个集合判断是否抛异常
				 */
				else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
					if (ambiguousConstructors == null) {
						ambiguousConstructors = new LinkedHashSet<>();
						ambiguousConstructors.add(constructorToUse);
					}
					ambiguousConstructors.add(candidate);
				}
			}
			//至此构造函数循环结束
            
			/**
			 * 以下两种情况会抛异常
			 *  1、至此为止还没有确定使用的构造函数
			 * 	2、存在模棱两可的构造函数并且不允许存在模棱两可的构造函数
			 */
			if (constructorToUse == null) {
				if (causes != null) {
					UnsatisfiedDependencyException ex = causes.removeLast();
					for (Exception cause : causes) {
						this.beanFactory.onSuppressedException(cause);
					}
					throw ex;
				}
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Could not resolve matching constructor " +
						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
			}
			else 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);
			}

			/**
			 * 没有传入参与构造函数参数列表的参数时，对构造函数缓存到BeanDefinition中
			 * 	1、缓存BeanDefinition进行实例化时使用的构造函数
			 * 	2、缓存BeanDefinition代表的Bean的构造函数已解析完标识
			 * 	3、缓存参与构造函数参数列表值的参数列表
			 */
			if (explicitArgs == null) {
				argsHolderToUse.storeCache(mbd, constructorToUse);
			}
		}
		try {
			 //获取创建bean实例的实例化策略
			final InstantiationStrategy strategy = beanFactory.getInstantiationStrategy();
			Object beanInstance;
			/**
			 * Java安全管理器
			 * @see SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory, java.lang.reflect.Constructor, java.lang.Object...)
			 */
			if (System.getSecurityManager() != null) {
				final Constructor<?> ctorToUse = constructorToUse;
				final Object[] argumentsToUse = argsToUse;
				beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
						strategy.instantiate(mbd, beanName, beanFactory, ctorToUse, argumentsToUse),
						beanFactory.getAccessControlContext());
			}
			else {
				/**
				 *  如果安全
				 * 	根据策略进行实例的创建
				 */
				beanInstance = strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
			}
			/**
			 * 将实例填入包装类的属性中
			 */
			bw.setBeanInstance(beanInstance);
			//返回该构造方法
			return bw;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean instantiation via constructor failed", ex);
		}
	}

		 //如果推断出来的构造方法为null,则会使用默认的构造方法
         //并且使用了CGLIB代理策略,如果该bean有重写的父类方法,则用CGLIB代理,如果没有就反射创建对象
		return instantiateBean(beanName, mbd);
	}

		//此时已经完成了bean的实例化,但是没有进行初始化
        //拿到实例化出来的bean
		final Object bean = instanceWrapper.getWrappedInstance();
        //拿到bean的Class实例
		Class<?> beanType = instanceWrapper.getWrappedClass();
        //当前bean的Class实例是否为NullBean类型
		if (beanType != NullBean.class) {
        	//表明当前bean以确定,Class实例缓存在bean的beanDefinition的resolvedTargetType属性中
			mbd.resolvedTargetType = beanType;
		}
		//合并MergedBeanDefinition并做解析
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
                	/**
                     * 第三处调用后置处理器MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法
                     *  1、postProcessMergedBeanDefinition
					 *   缓存bean的注入信息的后置处理器，仅仅是缓存或者干脆叫做查找更加合适，没有完成注入，注入是另外一个后置处理器的作用
                     */
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				} catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}
		//急切地缓存单例以能够解析循环引用
		//即使是由BeanFactoryAware之类的生命周期接口触发
		//判断是否开启了循环依赖
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}			
			/**
             * 第四处执行后置处理器
             * SmartInstantiationAwareBeanPostProcessor---getEarlyBeanReference
             * 得到一个提前暴露的对象
             *
			 * 就是往第二缓存放入对象
			 * getEarlyBeanReference这个方法也很重要，这就是为什么从二级缓存拿出来的对象，完成了调用后置处理器
			 * 此时它并不调用该方法，只有从该缓存中 get(beanName) 时才执行
			 */
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		//准备初始化bean实例。
		Object exposedObject = bean;
		try {
			/**
			 * 对bean属性进行依赖注入
			 */
			populateBean(beanName, mbd, instanceWrapper);

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		/**
		 * 如果实例出来的bean为null，则直接返回
		 * 如果实力出来的bean为null，而且beanDefinition有需要填充的属性则报错
		 */
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			} else {
				return;
			}
		}
		/**
		 * 设置一个标识，在设置属性之前，给任何InstantiationAwareBeanPostProcessors实现修改bean状态的机会
		 */
		boolean continueWithPropertyPopulation = true;

		/**
         * 第五处调用后置处理器InstantiationAwareBeanPostProcessor--postProcessAfterInstantiation
		*  判断你的bean需不需要完成属性填充
		 * BeanDefinition不是合成的，并且存在 InstantiationAwareBeanPostProcessors 的后置处理器
		 * 则遍历所有实现了BeanPostProcessor，如果实现了InstantiationAwareBeanPostProcessor接口，
		 * 执行该后置处理器的postProcessAfterInstantiation方法
		 *	最后一次机会在属性注入前修改BeanDefinition中的属性值
		 * 并返回一个状态，是否继续进行依赖注入，默认实现返回true，继续依赖注入
		 */
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}
		/**
		 * 如果有任何一个 InstantiationAwareBeanPostProcessor 设置了 不需要继续进行依赖注入
		 * 则直接返回
		 */
		if (!continueWithPropertyPopulation) {
			return;
		}
		/**
		 * 封装属性值的对象，里面封装了显示设置的属性名称和值
		 * XML:
		 * 		<bean id="xxx" class="xxx">
		 *         <property name="xxx" ref="xxx"/>
		 *     </bean>
		 */
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		/**
		 * 如果注入模型手动设置了 AUTOWIRE_BY_NAME 或者 AUTOWIRE_BY_TYPE 则执行
		 */
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			/**
			 * 封装了显示设置的属性名称和值
			 */
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			/**
			 * 根据属性的setter方法名称装配属性，然后进行合并
			 */
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			/**
			 * 根据属性类型装配属性，
			 * 先拿到有get/set方法的属性，然后进行过滤，然后进行合并
			 */
			// Add property values based on autowire by type if applicable.
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			/**
			 * 更新配置，此时已经成功注入的属性的值替换成真正的对象
			 */
			pvs = newPvs;
		}
		/**
		 * 容器中是否有InstantiationAwareBeanPostProcessors类型的BeanPostProcessor
		 */
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		/**
		 * 是否进行依赖检查，默认不检查
		 */
		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
		/**
		 * 含有InstantiationAwareBeanPostProcessors类型的BeanPostProcessor
		 * 或者需要进行检查则进入
		 */
		if (hasInstAwareBpps || needsDepCheck) {
			/**
			 * 如果没有显示设置的对象，则再从beanDefinition拿一次，严谨性，如果没有则得到一个口空壳对象
			 * 防止pvs为空的情况
			 */
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			/**
			 * 从BeanWrapper中提取经过筛选的属性封装对象，不包括忽略的依赖项类型或在忽略的依赖项接口上定义的属性。
			 */
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			/**
             * 第六出执行后置处理器InstantiationAwareBeanPostProcessor---postProcessPropertyValues
			 * 属性填充---自动注入 
             *
			 * 遍历InstantiationAwareBeanPostProcessor，可对属性做修改
			 * 主要起作用的是CommonAnnotationBeanPostProcessor和AutowiredAnnotationBeanPostProcessor这两个类
			 * 解析了{@link Resource} 和 {@link org.springframework.beans.factory.annotation.Autowired}注解
			 */
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						/**
                         * 真正执行了属性注入的方法,并且每成功注入一个,就会往pvs中设置一个
                         * 通过bean拿到元信息,解析出所有需要进行注入的属性和方法,对所有属性和方法进行注入
                         * 从单例池拿,先通过类型,如果找到多个则在根据名字,如果beanDefinitionMap不存在被注入的类则报错
                         */
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			/**
			 * 需要则进行属性检查，确保所有依赖的Bean已经完成实例创建
			 * 比对的就是pvs中属性的值是否已经设置
			 */
			if (needsDepCheck) {
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}
		/**
		 * 此时pvs中保存了成功注入对象的属性
		 * 对属性进行注入 (xml)
		 */
		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

			/**
			 *  在对bean实例化完成和属性注入完成以后，
			 *  完成剩下几乎所有的步骤执行aware、初始化回调方法、aop ....等等
 			 */
			exposedObject = initializeBean(beanName, exposedObject, mbd);

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		//JDK的安全己制验证机制
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		} else {
			/**
			 * 执行部分aware方法 为当前的bean包装相关属性，如名称、类加载器、所属容器 (BeanFactory) 等信息
			 * 主要执行三个Aware
			 *  BeanNameAware
			 *  BeanClassLoaderAware
			 *  BeanFactoryAware
			 */
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		/**
		 *  是否这个beanDefinition属于内部类
		 */
		if (mbd == null || !mbd.isSynthetic()) {
			/**
			 * 第七处执行所有后置处理器,执行所有存在于beanPostProcessors的后置处理器的 postProcessBeforeInitialization方法
             * 
             * 因为所有后置处理器都实现了beanPostProcessor 接口
			 * 这个接口有两个方法
			 * 		1. postProcessBeforeInitialization
			 * 		2. postProcessAfterInitialization
			 *  但是并不是所有的后置处理器只在这个时候执行，因为部分后置处理器有自己独有的方法，在实例化的过程中这些方法就已经被执行了。
			 *  这里只是执行公有的两个方法
			 *
			 * 还执行剩下的aware接口方法 通过ApplicationContextAwareProcessor的postProcessBeforeInitialization方法
			 * 								 ServletContextAwareProcessor 的 postProcessBeforeInitialization方法
			 * 	反正此时所有aware的方法全部执行完毕，还有一些在前面执行
			 *
			 * 执行 InitDestroyAnnotationBeanPostProcessor 的 postProcessBeforeInitialization 来执行 @PostConstruct注解
			 */
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			/**
			 * 执行初始化回调方法
			 * 1. @PostConstruct 在上面的后置处理器中执行
			 * 2.实现了InitializingBean接口
			 * 3.xml 的 init-method 属性
			 */
			invokeInitMethods(beanName, wrappedBean, mbd);
		} catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			/**
             * 第八处执行后置处理器,执行所有存在于beanPostProcessors的后置处理器的 postProcessAfterInitialization方法
             * 
             * aop的后置处理器就是在这个方法中完成代理
			 * 为什么jdk动态代理要求必须使用接口 因为通过jdk代理生成的对象默认继承proxy父类
			 * 他不能继承代理之前的对象只能通过实现之前对象的接口才可以完成代理
			 */
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

		} catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			} else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}
        //省略的代码不重要。。。
        //返回该单例bean
		return exposedObject;
	}

                    //设置newSingleton表示为true,表示创建bean成功
					newSingleton = true;
				} catch (IllegalStateException ex) {
					//同时是否隐式出现了singleton对象
					//如果是,请继续执行,因为异常指示该状态。
                    //从singletonObjects拿到beanName的bean
					singletonObject = this.singletonObjects.get(beanName);
                    //如果为空直接报错
					if (singletonObject == null) {
						throw ex;
					}
				} catch (BeanCreationException ex) {
                	//把抑制的异常添加进BeanCreationException这个relatedCauses(异常原因)集合中
					if (recordSuppressedExceptions) {
						for (Exception suppressedException : this.suppressedExceptions) {
							ex.addRelatedCause(suppressedException);
						}
					}
                    //报错
					throw ex;
				} finally {
                    //从singletonsCurrentlyInCreation移除该beanName,表示创建结束
					afterSingletonCreation(beanName);
				}
				//如果创建bean
				if (newSingleton) {
					/**
					 * 生命周期的创建最后一步
                     *	this.singletonObjects.put(beanName, singletonObject);
					 *  this.singletonFactories.remove(beanName);
					 *  this.earlySingletonObjects.remove(beanName);
					 *  this.registeredSingletons.add(beanName);
					 */
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

					/**
					 * 该方法处理了FactoryBean这个接口
					 * spring中并没有给他的getObject()单独创建一个对象注入 ioc 容器
					 * 仅仅只是拿的时候判断是否加了‘&’符号，如果没加那么他返回的就是 getObject()方法返回的对象
					 */
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
		//如果实际的bean类型与所需的实例类型匹配，则进行检查。
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			} catch (TypeMismatchException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

/**
 * FactoryBean
 * 使用这种方式会往singletonObjects中注入MyFactoryBean这个bean
 * 但是如果你想从单例池中通过key拿到类的bean需要使用&myFactoryBean
 * 拿到对象返回的bean需要使用myFactoryBean,但是这个bean并不是存储在singletonObjects中,而是保存在factoryBeanObjectCache中,并且是第一次尝试拿到这个bean的时候才会进行实例化
 * mybaits中默认也是使用的这种方法
 */
public class MyFactoryBean implements FactoryBean {
	@Override
	public Object getObject() throws Exception {
		TDao MyTDao = (TDao) Demo.getMapper(clazz);
		return MyTDao;
	}
	@Override
	public Class<?> getObjectType() {
		return null;
	}
}

protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
            
		//如果是对FactoryBean的解引用，但bean对象不是FactoryBean，抛出异常
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			//如果Bean实例不是FactoryBean，或者指定名称是FactoryBean的解引用，也就是普通的bean调用，则直接返回当前的Bean实例  
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
			}
		}
		/**
		 * 如果Bean实例不是FactoryBean，或者指定名称是FactoryBean的解引用，也就是普通的bean调用，则直接返回当前的Bean实例
		 * 判断bean类型是否是FactoryBean，或者name是否是以&开头，如果是则直接返回
		 */
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}
		//处理对FactoryBean的调用
		Object object = null;
		if (mbd == null) {
			//从Bean工厂缓存中获取给定名称的实例对象
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			//如果从Bean工厂生产的Bean是单态模式的，则缓存
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			/**
			 * 调用FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法,就是调用getObject()方法,
			 * 实现FactoryBean生产Bean对象实例的过程
             * 缓存到factoryBeanObjectCache集合中,下次如果beanName不带'&'符号直接从缓存中拿
			 */
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

spring ioc的生命周期到此全部走完