【Spring源码分析】从源码角度去熟悉依赖注入（一）

从源码角度去熟悉依赖注入

一、全局出发引出各种依赖注入策略
二、@Autowired依赖注入源码分析
- 属性注入源码分析（AutowiredFieldElement.inject）
- 方法注入源码分析（AutowiredMethodElement.inject）
- 流程图

其实在上篇阐述非懒加载单例Bean的实例化逻辑的时候，就有阐述过 AbstractAutowireCapableBeanFactory#createBean 的大概，它其实就阐述了一个 Bean 的生命周期：

加载BeanClass；
实例化前；
实例化；
后置处理合并后的 BeanDefinition，MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition（这不属于Bean的生命周期，但担任着很重要的角色）
实例化后；
属性填充，这里的属性填充其实就是俺们说的依赖注入。
初始化前、初始化、初始化后。
硬要加上个结尾的话，就还有个销毁，一般用不着。

先阐述一下，就当上期博客的复习咯。
这期博客呢我们从源码的角度去看看属性填充（依赖注入）的内部实现。
首先阐明一下，像源码分析这种类型的博客呢，要么是自己熟悉原理，要么是自己看过，不然看起来会觉得好困难。

一、全局出发引出各种依赖注入策略

从上篇博客中的流程也可以知道属性填充在处理 MergedBeanDefinitionPostProcessor 之后：

			// 合并后的BeanDefinition的在处理applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);// 属性填充populateBean(beanName, mbd, instanceWrapper);

接下来咱从 populateBean() 全局点的角度去引入各种属性注入的方式，下面是该方法的源码：

	@SuppressWarnings("deprecation")  // for postProcessPropertyValuesprotected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the// state of the bean before properties are set. This can be used, for example,// to support styles of field injection.// 实例化之后，属性设置之前// Spring 只是提供了这个生命周期阶段，但是实际上没有做任何处理if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {return;}}}// 这是看 BeanDefinition 中是否已经有填充的属性了PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);// Spring 自己提供的填充策略int resolvedAutowireMode = mbd.getResolvedAutowireMode();if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {// MutablePropertyValues是PropertyValues具体的实现类// 可以看见这里的 newPvs 和上面配置的 PropertyValues 是一起的MutablePropertyValues newPvs = new MutablePropertyValues(pvs);// Add property values based on autowire by name if applicable.if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {autowireByName(beanName, mbd, bw, newPvs);}// Add property values based on autowire by type if applicable.if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {autowireByType(beanName, mbd, bw, newPvs);}pvs = newPvs;}// 下面是通过注解的方式进行注入的方式boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);PropertyDescriptor[] filteredPds = null;if (hasInstAwareBpps) {if (pvs == null) {pvs = mbd.getPropertyValues();}for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {// 这里会调用AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法，会直接给对象中的属性赋值// AutowiredAnnotationBeanPostProcessor内部并不会处理pvs，直接返回了PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);if (pvsToUse == null) {if (filteredPds == null) {filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);if (pvsToUse == null) {return;}}pvs = pvsToUse;}}if (needsDepCheck) {if (filteredPds == null) {filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}checkDependencies(beanName, mbd, filteredPds, pvs);}// 如果当前Bean中的BeanDefinition中设置了PropertyValues，那么最终将是PropertyValues中的值，覆盖@Autowiredif (pvs != null) {applyPropertyValues(beanName, mbd, bw, pvs);}}

先是处理实例化后，Spring 没实例化后的逻辑，只是提供了这个生命周期阶段；
拿到 BeanDefinition 中已经有填充的属性，就是可以在 MergedBeanDefinitionPostProcessor 中去处理这个 BeanDefinition；比如下面这样自定义：
在上面拿到的基础上外加上解析是否通过 AUTOWIRE_BY_NAME 或 AUTOWIRE_BY_TYPE 俩种模式下的填充的属性（PropertyValues）；
通过 InstantiationAwareBeanPostProcessor#postProcessProperties 去填充属性，这里Spring主要是去解析注解填充（常用）；
最后将需要填充的属性进行个直接引用，通过 InstantiationAwareBeanPostProcessor#postProcessProperties 去填充属性的时候会直接去赋值操作，而最上面俩种是由最后处理，也就是说若俩种方式都使用了，上面的那种才有效，其中上面俩种需要提供对应的 setter 方法。

了解完上面这些就可以开始真正的源码分析环节了，前俩种属性填充其实没啥好说的，这里简单提一下 By_Name 和 By_Type 方式进行的填充源码：
在这里插入图片描述

先是获取到可以注入的属性名（这里面的具体实现是先拿到属性的内省对象，然后遍历去将满足条件的属性返回）
- 该属性有对应的set方法；
- 没有被 excludeFilters 所排除；
- 先前是没有填充过该属性的；
- 属性类型不是简单类型。
  - 比如下面容器中有个 Number 简单类型的Bean；
  - 现在尝试注入到UserService中：
  - 可以看见注入失败了
然后遍历返回的属性名，去获取对应的实例，然后放到 PropertyValues 对象中，由后续再直接去调用 setter 去填充。

它是有缺陷的，会把所有满足条件的 setter 方法都当做是去属性注入去调用，而且可以看见它是不让填充简单类型的实例对象的，所以就有了后续的注解式的方式。

二、@Autowired依赖注入源码分析

这里的源码逻辑和 InstantiationAwareBeanPostProcessor#postProcessPropertyValues 里实现的。其主要实现是在 AutowiredAnnotationBeanPostProcessor 中。
有必要去看一下该类的关系结构图：
在这里插入图片描述该 BeanPostProcessor 就一个无参构造，咱来看看，就是俺们希望看见的 @Autowired、@Value 注解。
从上文中也清楚，是先执行的 MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition BeanDefinition 的再操作，再去进行属性注入。那我们看这个 BeanPostProcessor 源码，当然也是先去看 postProcessMergedBeanDefinition 方法。接下俩的分析如下：

	@Overridepublic void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {// 找注入点（所有被@Autowired注解了的Field或Method）InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);// 将寻找到的注入点放入到 BeanDefinition 中metadata.checkConfigMembers(beanDefinition);}

findAutowiringMetadata 源码分析：

	private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {// Fall back to class name as cache key, for backwards compatibility with custom callers.// 构造缓存 key，如果beanName不为空，就用beanName，否则用类的全限定名String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());// Quick check on the concurrent map first, with minimal locking.InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);if (InjectionMetadata.needsRefresh(metadata, clazz)) {synchronized (this.injectionMetadataCache) {metadata = this.injectionMetadataCache.get(cacheKey);if (InjectionMetadata.needsRefresh(metadata, clazz)) {if (metadata != null) {metadata.clear(pvs);}// 解析注入点并缓存metadata = buildAutowiringMetadata(clazz);// 存入本地缓存// 后续属性注入可以直接从这个缓存中获取this.injectionMetadataCache.put(cacheKey, metadata);}}}return metadata;}

也就是说咱得去看这里面的核心代码 buildAutowiringMetadata 它是如何去解析注入点的，拿到元数据然后放到本地缓存中，接下来是看源码环节：

	private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {// 如果一个Bean的类型是String...，那么则根本不需要进行依赖注入// 准确的说是 clazz 的全限定名是以 java. 开头，比如 java.lang.Stringif (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {return InjectionMetadata.EMPTY;}List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();Class<?> targetClass = clazz;do {final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();// 遍历targetClass中的所有FieldReflectionUtils.doWithLocalFields(targetClass, field -> {// field上是否存在@Autowired、@Value、@Inject中的其中一个MergedAnnotation<?> ann = findAutowiredAnnotation(field);if (ann != null) {// static filed不是注入点，不会进行自动注入if (Modifier.isStatic(field.getModifiers())) {if (logger.isInfoEnabled()) {logger.info("Autowired annotation is not supported on static fields: " + field);}return;}// 构造注入点boolean required = determineRequiredStatus(ann);currElements.add(new AutowiredFieldElement(field, required));}});// 遍历targetClass中的所有MethodReflectionUtils.doWithLocalMethods(targetClass, method -> {// 处理桥接方法Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {return;}// method上是否存在@Autowired、@Value、@Inject中的其中一个MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {// static method不是注入点，不会进行自动注入if (Modifier.isStatic(method.getModifiers())) {if (logger.isInfoEnabled()) {logger.info("Autowired annotation is not supported on static methods: " + method);}return;}// set方法最好有入参// 要是没参的话会打印日志信息，但是也会注入if (method.getParameterCount() == 0) {if (logger.isInfoEnabled()) {logger.info("Autowired annotation should only be used on methods with parameters: " +method);}}boolean required = determineRequiredStatus(ann);PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);currElements.add(new AutowiredMethodElement(method, required, pd));}});elements.addAll(0, currElements);targetClass = targetClass.getSuperclass();}while (targetClass != null && targetClass != Object.class);return InjectionMetadata.forElements(elements, clazz);}

总结流程
- 从该类开始不断遍历父类；
- 通过反射机制遍历所有的属性
  - 看属性上面是不是有 @Autowired、@Value、@Inject 中的其中一个
  - 排除属性是静态的，静态的属性类方面的成员，不属于实体级别的，不应该进行属性注入；
  - 创建注入点 AutowiredFieldElement 实体对象，然后放入到 InjectedElement 集。
- 通过反射机制遍历所有的方法
  - 其他点和上面属性是一样的，如看方法上有无那些注解，排除方法是静态的…
  - 然后创建注入点 AutowiredMethodElement 实体对象，然后放入到 InjectedElement 集。

OK，也就是通过这咱就拿到了需要注入的属性和方法集，接下来就可以进行注入咯。
现咱去看看 InstantiationAwareBeanPostProcessor#postProcessPropertyValues ，这里指的是 AutowiredAnnotationBeanPostProcessor#postProcessPropertyValues

	@Overridepublic PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {// 找注入点（所有被@Autowired注解了的Field或Method）InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);try {metadata.inject(bean, beanName, pvs);} catch (BeanCreationException ex) {throw ex;} catch (Throwable ex) {throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);}return pvs;}

findAutowiringMetadata 方法找到对应需要注入的元数据对象，上面分析过，这里就是从本地缓存拿到的 InjectionMetadata 对象；
接下来直接进行注入~

注入 inject 方法实现其实很简单，就是遍历 InjectedElement 对象，然后依次调用它的 inject 进行遍历。
在这里插入图片描述
咱再过来看看 AutowiredFiledElement、AutowiredMethodElement、InjectedElement 之间的关系：

接下来就是看属性注入和方法注入是咋地实现的咯~

属性注入源码分析（AutowiredFieldElement.inject）

		@Overrideprotected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {Field field = (Field) this.member;Object value;if (this.cached) {// 对于原型Bean，第一次创建的时候，也找注入点，然后进行注入，此时cached为false，注入完了之后cached为true// 第二次创建的时候，先找注入点（此时会拿到缓存好的注入点），也就是AutowiredFieldElement对象，此时cache为true，也就进到此处了// 注入点内并没有缓存被注入的具体Bean对象，而是beanName，这样就能保证注入到不同的原型Bean对象try {value = resolvedCachedArgument(beanName, this.cachedFieldValue);} catch (NoSuchBeanDefinitionException ex) {// Unexpected removal of target bean for cached argument -> re-resolvevalue = resolveFieldValue(field, bean, beanName);}} else {// 根据filed从BeanFactory中查到的匹配的Bean对象value = resolveFieldValue(field, bean, beanName);}// 反射给filed赋值if (value != null) {ReflectionUtils.makeAccessible(field);field.set(bean, value);}}

resolveFieldValue 方法，从 BeanFactory 中查询到对应的 Bean 对象；
反射进行属性赋值

方法注入源码分析（AutowiredMethodElement.inject）

		@Overrideprotected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {// 如果pvs中已经有当前注入点的值了，则跳过注入if (checkPropertySkipping(pvs)) {return;}Method method = (Method) this.member;Object[] arguments;if (this.cached) {try {arguments = resolveCachedArguments(beanName);} catch (NoSuchBeanDefinitionException ex) {// Unexpected removal of target bean for cached argument -> re-resolvearguments = resolveMethodArguments(method, bean, beanName);}} else {arguments = resolveMethodArguments(method, bean, beanName);}if (arguments != null) {try {ReflectionUtils.makeAccessible(method);method.invoke(bean, arguments);} catch (InvocationTargetException ex) {throw ex.getTargetException();}}}