Spring中Bean的创建过程二

populateBean 设置属性方法

// 填充属性
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	// 判断beanWrapper 是否为空
	if (bw == null) {
		// 如果mbd有需要设置的属性
		if (mbd.hasPropertyValues()) {
			//抛异常
			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
		} else {
			// 没有可填充的属性，直接跳过
			return;
		}
	}

	// 给任何实现了InstantiationAwareBeanPostProcessors的子类机会去修改bean的状态再设置属性之前，可以被用来支持类型的字段注入
	boolean continueWithPropertyPopulation = 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;
				}
			}
		}
	}

	if (!continueWithPropertyPopulation) {
		return;
	}
	// PropertyValues：包含一个或多个PropertyValue对象的容器，通常包括针对特定目标Bean的一次更新
	// 如果mdb有PropertyValues就获取其PropertyValues
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
	// 获取mbd的自动装配模式 
	if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
		// MutablePropertyValues ：ProopertyValues接口的默认实现。允许对属性进行简单操作，并提供构造函数来支持从映射 进行深度复制和构造
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
		// 根据 autowire 的名称（如适用）添加属性值
		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
			// 通过bw的PropertyDescriptor属性名，查找出对应的Bean对象，将其添加到newPvs中
			autowireByName(beanName, mbd, bw, newPvs);  // 下面有介绍
		}
		// Add property values based on autowire by type if applicable.
		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
			// 通过bw的PropertyDescriptor 的属性类型，查找出对应的Bean对象，将其添加到newPvs中
			autowireByType(beanName, mbd, bw, newPvs);  // 下面有介绍
		}
		pvs = newPvs;
	}
	// 工厂是否拥有 InstantiationAwareBeanPostProcessors,如果拥有，就处理对应的流程
	// 主要是对几个注解的赋值工作，包含两个关键子类：CommonAnnoationBeanPostProcessor，AutowiredAnnotationBeanPostProcessor
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	// mbd.getDependencyCheck() 默认返回 DEPENDENCY_CHECK_NONE  表示不检查
	// 是否需要依赖检查 
	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
	if (hasInstAwareBpps || needsDepCheck) {
		if (pvs == null) {
			// 尝试获取mbd的PropertyValues
			pvs = mbd.getPropertyValues();
		}
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		if (hasInstAwareBpps) {
			// 遍历工厂内部所有的后置处理器
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					// 强转对象
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					// 让ibp对pvs 增加对bw的Bean对象的propertyValue，或编辑pvs的proertyValue
					pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvs == null) {
						return;
					}
				}
			}
		}
		// 如果需要依赖检查
		if (needsDepCheck) {
			// 检查依赖项：主要检查pd的setter方法需要赋值时，pvs中有没有满足其pd的需求的属性值可供其赋值
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}
	}

	if (pvs != null) {
		// 应用给定的属性值，解决任何在这个bean工厂运行其它bean的引用。不需使用深拷贝，所以我们不会永久的修改这个属性
		applyPropertyValues(beanName, mbd, bw, pvs);  // 下面有介绍
	} 
}

autowireByName

protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
	// 获取 bw中 有setter方法 &&  非简单类型属性  &&  mbd的PropertyValues中没有该pd的属性名的PropertyDescriptor 属性名数组
	String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
	// 遍历属性名
	for (String propertyName : propertyNames) {
		// 如果该bean工厂有propertyName的beanDefinition或外部注册的singleton实例
		if (containsBean(propertyName)) {
			// 获取该工厂中propertyName的bean对象
			Object bean = getBean(propertyName);
			// 将propertyName，bean添加到pvs中
			pvs.add(propertyName, bean);
			// 注册propertyName与beanName的依赖关系
			registerDependentBean(propertyName, beanName);
			if (logger.isDebugEnabled()) {
				logger.debug("Added autowiring by name from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
			}
		}
		else {
			if (logger.isTraceEnabled()) {
				logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName + "' by name: no matching bean found");
			}
		}
	}
}

autowireByType

protected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
	// 获取工厂自定义的类型转换器
	TypeConverter converter = getCustomTypeConverter();
	if (converter == null) {
		converter = bw; // 如果没有，使用bw作为类型转换器
	}
	// 存放所有候选Bean名的集合
	Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
	// 获取bw中有setter方法 && 非简单类型属性 && mbd 的PropertyValues 中没有该pd的属性名的PropertyDescriptor 属性名数组
	String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
	for (String propertyName : propertyNames) {
		try {
			// PropertyDescriptor：表示JavaBean类通过存储器导出一个属性
			// 从bw中获取propertyName对应的PropertyDescriptor
			PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
			// 不要尝试按类型自动装配对象：永远是有意义的，即使它在技术上是一个不满意，复杂属性
			// 如果pd的属性值类型不是Object
			if (Object.class != pd.getPropertyType()) {
				// 获取pd属性的Setter方法的方法参数包装对象
				MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
				// 判断bean对象是否是PriorityOrder示例，如果不是就允许急于初始化来进行类型匹配
				// eager 为true时，会导致初始化lazy-init单例和由FactoryBeans（或者带有“factory-bean”引用的工厂方法）创建的对象以进行类型检查
				boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
				// AutowireByTypeDependencyDescriptor：根据类型依赖自动注入的描述符，重写了 getDependencyName() 方法，使其永远返回null
				// 将methodParam 封装成 AutowireByTypeDependencyDescriptor 对象
				DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
				// 根据desc的依赖类型解析出与descriptor所包装的对象匹配的候选Bean对象
				Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
				if (autowiredArgument != null) {
					pvs.add(propertyName, autowiredArgument);
				}
				// 遍历所有候选Bean名集合
				for (String autowiredBeanName : autowiredBeanNames) {
					// 注册beanName与dependentBeanNamed的依赖关系
					registerDependentBean(autowiredBeanName, beanName);
				}
				autowiredBeanNames.clear();
			}
		}
		catch (BeansException ex) {
		}
	}
}

applyPropertyValues

// 应用给定的属性值，解决任何在这个bean工厂运行其它bean的引用。不需使用深拷贝，所以我们不会永久的修改这个属性
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
	if (pvs.isEmpty())  return;

	if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
		//如果有安全管理器且bw是BeanWrapperImpl的实例，则设置bw的安全上下文为工厂的访问控制上下文
		((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
	}
	// MutablePropertyValues：PropertyValues接口的默认实现，允许对属性进行简单操作，并提供构造函数来支持从映射，进行深度复制和构造
	MutablePropertyValues mpvs = null;
	// 原始对象的属性列表     如 id  name  age  等
	List<PropertyValue> original;
	if (pvs instanceof MutablePropertyValues) {
		mpvs = (MutablePropertyValues) pvs;
		// isConverted 返回该holder是否只包含转换后的值（true），或者是否仍然需要转换这些值
		if (mpvs.isConverted()) {
			// Shortcut: use the pre-converted values as-is.
			try {
				bw.setPropertyValues(mpvs);  // 已完成，直接返回
				return;
			} catch (BeansException ex) {
				throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Error setting property values", ex);
			}
		}
		original = mpvs.getPropertyValueList();
	} else {
		original = Arrays.asList(pvs.getPropertyValues());
	}
	// 获取用户自定义的类型转换器
	TypeConverter converter = getCustomTypeConverter();
	if (converter == null) {
		converter = bw;
	}
	// BeanDefinitionValueResolver ：在bean工厂实现中使用Helper类，它将beanDefinition对象中包含的值解析为应用于 目标bean实例的实际值
	BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

	// 创建一个深拷贝，解析任何值引用
	List<PropertyValue> deepCopy = new ArrayList<>(original.size());
	boolean resolveNecessary = false;  // 是否需要解析标记
	for (PropertyValue pv : original) {
		if (pv.isConverted()) {   
			deepCopy.add(pv);  // 如果已经解析过，将 pv 添加到deepCopy中
		} else {
			// 没解析过的情况
			String propertyName = pv.getName();   // 获取属性的名字   eg：name  age  等
			Object originalValue = pv.getValue();  // 获取未经转换的value
			Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); // 交由valueResolver 根据pv 解析出 originalValue 锁封装的对象
			Object convertedValue = resolvedValue; // 默认转换后的值是刚解析出来的值
			// 可转换标记：propertyName 是否bw中的可写属性 && propertyName 不是标识索引属性或嵌套属性
			boolean convertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
			if (convertible) {
				// 如果可以转换，将resolvedValue 转换为指定的目标属性对象
				convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
			}
			// 可以将转换后的值存储合并后BeanDefinition中，以避免每隔创建的bean实例进行重新转换
			if (resolvedValue == originalValue) { // 如果resolvedValue 与 originalValue是同一个对象
				if (convertible) {
					pv.setConvertedValue(convertedValue); // 如果可转换，将convertedValue 设置到pv中
				}
				deepCopy.add(pv);  // 添加到deepCopy中
			} 
			// TypedStringValue：类型字符串的holder，这个holder将只存储字符串值和目标类型。实际得转换将由Bean工厂执行
			// 如果可转换 && originalValue是TypedStringValue的实例 && orginalValue 不是标记为动态（即不是一个表达式）
			// && convertedValue  不是Collection 对象 或数组
			else if (convertible && originalValue instanceof TypedStringValue &&
					!((TypedStringValue) originalValue).isDynamic() &&
					!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
				pv.setConvertedValue(convertedValue); //  将 convertedValue 设置到pv中
				deepCopy.add(pv);
			} else {
				resolveNecessary = true; 
				// 根据pv，convertedValue构建PropertyValue对象，并添加到deepCopy中
				deepCopy.add(new PropertyValue(pv, convertedValue));
			}
		}
	}
	if (mpvs != null && !resolveNecessary) {
		// 如果mpvs不为空 && 已经不需要解析，将此holder标记为只包含转换后的值
		mpvs.setConverted();
	}
	// -------------------------以上部分只是对属性值进行解析或者转换，还没有设置给对象----------
	try {
		// 按原样使用deepCopy构造一个新的MutablePropertyValues对象后设置到bw中，对bw的属性值更新
		// 循环并调用set方法进行赋值操作 
		bw.setPropertyValues(new MutablePropertyValues(deepCopy));  
	} catch (BeansException ex) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Error setting property values", ex);
	}
}

initializeBean 执行初始化逻辑

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	// 安全管理器
	if (System.getSecurityManager() != null) {
		// 以特权的方式执行回调bean中的Aware接口方法
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}	else {
		// Aware 接口处理器，调用BeanNameAware、BeanClassLoaderAware、beanFactoryAware
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	// 一般只有AOP相关的pointcut配置或者Advice配置才会将synthetic设置为true
	if (mbd == null || !mbd.isSynthetic()) {
		// 将BeanPostProcessors应用到给定的现有Bean实例，调用它们的postProcessBeforeInitialization初始化方法
		// 返回的Bean实例可能是原始Bean包装器      
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); // before 后面有介绍
	}

	try {
		//执行bean的声明周期回调中的init方法
		// 先调用bean的InitializingBean接口方法，后调用bean的自定义初始化方法
		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()) {
		//执行后置处理器的after方法
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}
	return wrappedBean;  // 返回包装后的Bean
}

applyBeanPostProcessorsBeforeInitialization

@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
	// 初始化返回结果为 existingBean
	Object result = existingBean;
	// 遍历该工厂创建的bean的BeanPostProcessors列表
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		// postProcessBeforeInitialization：在任何Bean初始化回调之前（如初始化Bean的afterPropertiesSet或自定义的init方法）
		// 将此BeanPostProcessor 应用到给定的新Bean实例。Bean已经填充了属性值。返回的Bean实例可能是原始Bean的包装器。
		 // 默认实现按原样返回给定的Bean
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;  // 如果为null，直接返回，中断其后面的BeanPostProcessor处理
		}
		result = current; // 让result引用processor的返回结果，使其经过所有BeanPostProcess对象的后置处理的层层包装
	}
	return result; // 返回所有BeanPostProcess对象的后置处理器的层层包装后的result
}

invokeInitMethods

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
	// InitializingBean: 当Bean的所有属性都被BeanFactory设置后，Bean需要执行相应的接口。例如执行自定义初始化，或者仅仅是检查所有强制属性是否已经设置好
	// bean 是 InitializingBean 实例标记
	boolean isInitializingBean = (bean instanceof InitializingBean);
	// isExternallyManagedInitMethod是否外部受管理的init方法名
	// 如果bean是InitializingBean 实例 && （mbd==null || ‘afterPropertiesSet’ 不是外部受管理的init方法）
	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
		// 安全管理器相关-----可忽略
		if (System.getSecurityManager() != null) {
			try {
				AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
					((InitializingBean) bean).afterPropertiesSet();
					return null;
				}, getAccessControlContext());
			} catch (PrivilegedActionException pae) {
				throw pae.getException();
			}
		} else {
			// 调用 bean 的afterPropertiesSet方法
			// afterPropertiesSet 主要做一些初始化工作和验证工作
			// 一个对象实现InitializingBean 就可以重写这个方法
			((InitializingBean) bean).afterPropertiesSet();  // 
		}
	}

	if (mbd != null && bean.getClass() != NullBean.class) {
		// 获取mbd指定的初始化方法名
		String initMethodName = mbd.getInitMethodName();

		if (StringUtils.hasLength(initMethodName) &&
				 !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
				!mbd.isExternallyManagedInitMethod(initMethodName)) {
			// 调用自定义的初始化方法
			invokeCustomInitMethod(beanName, bean, mbd);
		}
	}
}