29、Spring5.x源码之旅二十九getBean详解十四populateBean二

  • autowireResource自动装配Resource注解的对象
  • AutowiredAnnotationBeanPostProcessor的postProcessProperties
  • AutowiredFieldElement的inject
    • AutowiredAnnotationBeanPostProcessor的resolvedCachedArgument

autowireResource自动装配Resource注解的对象

这里主要就是根据依赖描述进行工厂的解析,最后都是调用getBean(String name, Class<T> requiredType)方法,最后获取之后再注册到依赖映射里。其实这个有个resolveBeanByName,看起来好像是名字优先,其实也会获取类型的。

	protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
			throws NoSuchBeanDefinitionException {
   
     

		Object resource;//自动装配的对象
		Set<String> autowiredBeanNames;//自动装配的名字
		String name = element.name;//依赖的属性名

		if (factory instanceof AutowireCapableBeanFactory) {
   
     
			AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
			DependencyDescriptor descriptor = element.getDependencyDescriptor();//创建依赖描述
			if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
   
     //不包含依赖对象,或者依赖对象的bean定义,只能通过解析类型去处理
				autowiredBeanNames = new LinkedHashSet<>();
				resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
				if (resource == null) {
   
     
					throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
				}
			}
			else {
   
     //获取依赖对象,里面就是getBean
				resource = beanFactory.resolveBeanByName(name, descriptor);
				autowiredBeanNames = Collections.singleton(name);//装配好的bean名字
			}
		}
		else {
   
     
			resource = factory.getBean(name, element.lookupType);
			autowiredBeanNames = Collections.singleton(name);
		}

		if (factory instanceof ConfigurableBeanFactory) {
   
     
			ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
			for (String autowiredBeanName : autowiredBeanNames) {
   
     
				if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) {
   
     
					beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);//注册依赖关系
				}
			}
		}

		return resource;
	}

AutowiredAnnotationBeanPostProcessor的postProcessProperties

这里和前面的很像,都是这个模板。

@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
   
     
		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;
	}

InjectionMetadata的inject里面也是:
*

AutowiredFieldElement的inject

但是最后是AutowiredFieldElement类型的方法,前面是ResourceElement的,他们都是InjectedElement的子类,ResourceElement把处理属性和方法放一起判断处理,自动装配的AutowiredFieldElementAutowiredMethodElement是分开处理的。
*
如果有缓存依赖描述的话,会根据缓存的依赖描述来解析依赖对象,否则还是执行bean工厂的resolveDependency,但是这个时候会传入TypeConverter类型,解析出来之后如果是required的,就放入缓存,并注册依赖信息,如果自动装配的bean只有一个,创建ShortcutDependencyDescriptor,并放入缓存。

@Override
		protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
   
     
			Field field = (Field) this.member;
			Object value;
			if (this.cached) {
   
     
				value = resolvedCachedArgument(beanName, this.cachedFieldValue);
			}
			else {
   
     
				DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
				desc.setContainingClass(bean.getClass());
				Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
				Assert.state(beanFactory != null, "No BeanFactory available");
				TypeConverter typeConverter = beanFactory.getTypeConverter();
				try {
   
     
					value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
				}
				catch (BeansException ex) {
   
     
					throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
				}
				synchronized (this) {
   
     
					if (!this.cached) {
   
     
						if (value != null || this.required) {
   
     
							this.cachedFieldValue = desc;
							registerDependentBeans(beanName, autowiredBeanNames);
							if (autowiredBeanNames.size() == 1) {
   
     
								String autowiredBeanName = autowiredBeanNames.iterator().next();
								if (beanFactory.containsBean(autowiredBeanName) &&
										beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
   
     
									this.cachedFieldValue = new ShortcutDependencyDescriptor(
											desc, autowiredBeanName, field.getType());
								}
							}
						}
						else {
   
     
							this.cachedFieldValue = null;
						}
						this.cached = true;
					}
				}
			}
			if (value != null) {
   
     
				ReflectionUtils.makeAccessible(field);
				field.set(bean, value);
			}
		}

AutowiredAnnotationBeanPostProcessor的resolvedCachedArgument

检查缓存是不是依赖描述类型的,是的话就取出相关数据,然后解析依赖。

@Nullable
	private Object resolvedCachedArgument(@Nullable String beanName, @Nullable Object cachedArgument) {
   
     
		if (cachedArgument instanceof DependencyDescriptor) {
   
     
			DependencyDescriptor descriptor = (DependencyDescriptor) cachedArgument;
			Assert.state(this.beanFactory != null, "No BeanFactory available");
			return this.beanFactory.resolveDependency(descriptor, beanName, null, null);
		}
		else {
   
     
			return cachedArgument;
		}
	}

其实不管哪种注入的注解,原理都是一样的,都要根据名字和类型去容器里找,其他的类似的自己看下就好了。

好了,今天就到这里了,希望对学习理解有帮助,大神看见勿喷,仅为自己的学习理解,能力有限,请多包涵。