3.springboot-@Autowired和@Value工作原理

1.简介

A.名词说明

• spring bean生命周期
• 复合构造函数(synthetic)：由编译器引入的构造函数，主要用于JVM内部使用；
• 桥接方法(bridge)：由编译器引入的方法，主要用于JVM内部使用；

B.@Autowired与@Value功能

• @Autowired与@Value功能基本相同，都可以自动装配bean；
• @Value除了可以自动装配bean外，还可以自动装配配置参数。装配配置参数时，也可以配置参数写在方法上；

@Component
public class MyAutowiredDemo {
    @Value("user")
    public Object configInt;

    @Value("${spring.test.config-int}")
    public void test(Object configInt) {
        System.out.println(configInt);
    }
}

2.InjectionMetadata注入元数据

InjectionMetadata(类的注入元数据)，描述每个依赖spring注入的java类，以及所有需要注入member(Member是java字段、方法和构造函数的父类)的相关信息；

//**类的注入元数据(描述每个依赖spring注入的java类，以及所有需要注入member的相关信息)
public class InjectionMetadata {

	//**空元数据
	public static final InjectionMetadata EMPTY = new InjectionMetadata(Object.class, Collections.emptyList()) {
		@Override
		protected boolean needsRefresh(Class clazz) {
			return false;
		}
		@Override
		public void checkConfigMembers(RootBeanDefinition beanDefinition) {
		}
		@Override
		public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) {
		}
		@Override
		public void clear(@Nullable PropertyValues pvs) {
		}
	};

    //**注入的目标类
	private final Class targetClass;
    //**目标类所有注入元素的集合
	private final Collection injectedElements;
    //**检查的注入元素集合
	@Nullable
	private volatile Set checkedElements;

    //**构造方法
	public InjectionMetadata(Class targetClass, Collection elements) {
		this.targetClass = targetClass;
		this.injectedElements = elements;
	}

    //**检查是否需要刷新
	protected boolean needsRefresh(Class clazz) {
		return this.targetClass != clazz;
	}
    
    //**遍历注入元素集合检查member是否注册到externallyManagedConfigMembers(spring管理的配置成员集合)
	public void checkConfigMembers(RootBeanDefinition beanDefinition) {
		Set checkedElements = new LinkedHashSet<>(this.injectedElements.size());
		for (InjectedElement element : this.injectedElements) {
		    //**如注入元素对应的member没有注册到externallyManagedConfigMembers，则注册
		    //**然后把注入元素添加到checkedElements
			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;
	}
    
    //**遍历注入元素集合，调用注入元素的inject方法注入member依赖的bean
	public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
		Collection checkedElements = this.checkedElements;
		Collection elementsToIterate =
				(checkedElements != null ? checkedElements : this.injectedElements);
		if (!elementsToIterate.isEmpty()) {
			for (InjectedElement element : elementsToIterate) {
				if (logger.isTraceEnabled()) {
					logger.trace("Processing injected element of bean '" + beanName + "': " + element);
				}
				element.inject(target, beanName, pvs);
			}
		}
	}

	//**遍历注入元素集合，调用注入元素的clearPropertySkipping方法清除所有已经注入的member
	public void clear(@Nullable PropertyValues pvs) {
		Collection checkedElements = this.checkedElements;
		Collection elementsToIterate =
				(checkedElements != null ? checkedElements : this.injectedElements);
		if (!elementsToIterate.isEmpty()) {
			for (InjectedElement element : elementsToIterate) {
				element.clearPropertySkipping(pvs);
			}
		}
	}

    //**静态方法，创建InjectionMetadata对象
	public static InjectionMetadata forElements(Collection elements, Class clazz) {
		return (elements.isEmpty() ? InjectionMetadata.EMPTY : new InjectionMetadata(clazz, elements));
	}

	//**静态方法，检查是否需要刷新
	public static boolean needsRefresh(@Nullable InjectionMetadata metadata, Class clazz) {
		return (metadata == null || metadata.needsRefresh(clazz));
	}

    //**注入元素(描述每个依赖spring注入的member相关信息)
	public abstract static class InjectedElement {
        //**member
		protected final Member member;
        //**member是否是字段
		protected final boolean isField;
        //**member的属性描述器
		@Nullable
		protected final PropertyDescriptor pd;
        //**是否跳过
		@Nullable
		protected volatile Boolean skip;
        
        //**构造方法
		protected InjectedElement(Member member, @Nullable PropertyDescriptor pd) {
			this.member = member;
			this.isField = (member instanceof Field);
			this.pd = pd;
		}
        
        //**获取member依赖spring注入的bean类型
		protected final Class getResourceType() {
		    //**如果是字段，则直接返回字段的类型
			if (this.isField) {
				return ((Field) this.member).getType();
			}
			//**如果包含属性描述器，则使用属性描述器获取类型
			else if (this.pd != null) {
				return this.pd.getPropertyType();
			}
			else {  //**如果是方法，则返回第一个参数的类型
				return ((Method) this.member).getParameterTypes()[0];
			}
		}
        
        //**检查指定类是否可以注入到member(指定类和member依赖bean是否存在继承关系)
		protected final void checkResourceType(Class resourceType) {
			if (this.isField) {
				Class fieldType = ((Field) this.member).getType();
				if (!(resourceType.isAssignableFrom(fieldType) || fieldType.isAssignableFrom(resourceType))) {
					throw new IllegalStateException("Specified field type [" + fieldType +
							"] is incompatible with resource type [" + resourceType.getName() + "]");
				}
			}
			else {
				Class paramType =
						(this.pd != null ? this.pd.getPropertyType() : ((Method) this.member).getParameterTypes()[0]);
				if (!(resourceType.isAssignableFrom(paramType) || paramType.isAssignableFrom(resourceType))) {
					throw new IllegalStateException("Specified parameter type [" + paramType +
							"] is incompatible with resource type [" + resourceType.getName() + "]");
				}
			}
		}

		//**注入member依赖的bean(实际没有使用，使用的其子类AutowiredFieldElement和AutowiredMethodElement的重写方法)
		protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
				throws Throwable {
            //**如果是字段，直接设置字段的值
			if (this.isField) {
				Field field = (Field) this.member;
				ReflectionUtils.makeAccessible(field);
				//**getResourceToInject(target, requestingBeanName)获取注入的bean
				field.set(target, getResourceToInject(target, requestingBeanName));
			}
			else {
			    //**如果已经注入，则跳过
				if (checkPropertySkipping(pvs)) {
					return;
				}
				//**如果是方法，调用方法
				try {
					Method method = (Method) this.member;
					ReflectionUtils.makeAccessible(method);
					//**getResourceToInject(target, requestingBeanName)获取注入的bean
					method.invoke(target, getResourceToInject(target, requestingBeanName));
				}
				catch (InvocationTargetException ex) {
					throw ex.getTargetException();
				}
			}
		}

		//**检查是否已经注入
		protected boolean checkPropertySkipping(@Nullable PropertyValues pvs) {
			Boolean skip = this.skip;
			if (skip != null) {
				return skip;
			}
			if (pvs == null) {
				this.skip = false;
				return false;
			}
			synchronized (pvs) {
				skip = this.skip;
				if (skip != null) {
					return skip;
				}
				if (this.pd != null) {
				    //**包含在已经处理过的集合(processedProperties)中，则返回true
					if (pvs.contains(this.pd.getName())) {
						this.skip = true;
						return true;
					}
					//**否则，在已经处理过的集合中注册，并返回false
					else if (pvs instanceof MutablePropertyValues) {
						((MutablePropertyValues) pvs).registerProcessedProperty(this.pd.getName());
					}
				}
				this.skip = false;
				return false;
			}
		}

		//**清除已经注入的member
		protected void clearPropertySkipping(@Nullable PropertyValues pvs) {
			if (pvs == null) {
				return;
			}
			synchronized (pvs) {
				if (Boolean.FALSE.equals(this.skip) && this.pd != null && pvs instanceof MutablePropertyValues) {
					((MutablePropertyValues) pvs).clearProcessedProperty(this.pd.getName());
				}
			}
		}

		//**获取注入的对象，这里返回null，需用子类实现
		@Nullable
		protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
			return null;
		}

        ...equals and hashCode and toString方法
	}
}

3.AutowiredAnnotationBeanPostProcessor(自动装配处理器)

注意(重点)

A.处理逻辑

• 首先处理@Lookup注解并获取候选的构造函数(包括父类上的@Lookup)。注意，这里只是选择了匹配的构造函数，有可能有多个，具体调用哪个构造函数逻辑在ConstructorResolver.autowireConstructor()，不在本篇深究；
• 然后把依赖spring注入的member信息注册到RootBeanDefinition的externallyManagedConfigMembers(spring管理的配置成员集合)；
• 最后把bean及其依赖注入的bean的关系注册到DefaultSingletonBeanRegistryt的dependentBeanMap和dependenciesForBeanMap。然后设置注入的值(如果是字段，直接赋值，如果是方法，调用方法)；

B.自定义自动装配注解

自定一个自动装配注解@MyAutowired，功能同解@Autowired

//1.自定义解@MyAutowired注解
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAutowired {

    //**required参数名也可以自定义
    boolean required() default true;

}

//2.使MyAutowired注解生效
@Component
public class MyAutowiredAnnotationBeanPostProcessor extends AutowiredAnnotationBeanPostProcessor {

    public MyAutowiredAnnotationBeanPostProcessor(){
        super.setAutowiredAnnotationTypes(Set.of(Autowired.class, Value.class, MyAutowired.class));
    }
}

//3.使用示例
@Component
public class MyAutowiredDemo {

    @MyAutowired
    private User user;

    public void hello(){
        System.out.println(user.getClass());
    }
}

C.处理规则

构造方法注入：

• 如果required=true，只能标注一个@Autowired
• 如果required=false，可标注多个@Autowired，且匹配项最多的构造函数会生效
• 如果没有匹配到任何一个构造函数，则默认的构造函数会生效
• 如果只有一个构造函数，则这个构造函数会生效(无论有没有标注@Autowired)
• 构造函数不需要为public

字段注入：

• 字段在构造方法注入之后，在配置方法注入之前调用
• 字段不需要为public

方法注入

• 配置方法可以有任意名称和任意数量的参数，spring会从容器中匹配并注入这些参数
• setter方法是配置方法的特例，spring并没有要求配置方法一定是setter方法
• 配置方法不需要为public

xml配置注入

• 默认情况下，AutowiredAnnotationBeanPostProcessor会注册context:annotation-config和context:component-scan标签
• 可指定自定义的AutowiredAnnotationBeanPostProcessor删除或者关闭默认的注解配置
• 注意：注解注入会在xml注入之前执行。后一种配置会覆盖前一种配置

Lookup方法

• @Lookup会在运行查找需要注入的参数(如果参数不是单例的，这会很有用。等同类型安全的getBean方法)

源码

• InstantiationAwareBeanPostProcessorAdapter：SmartInstantiationAwareBeanPostProcessor(智能实例化处理器)接口适配器(空实现)，其子类只需要实现关注的方法，而不用把所有的方法都实现；
• MergedBeanDefinitionPostProcessor：合并Bean定义后置处理器；
• PriorityOrdered：优先的Ordered序列，PriorityOrdered优先级总是在Ordered之前(无论order值是多少)；
• BeanFactoryAware：获取spring上下文中的BeanFactory；
• 执行顺序：
  • BeanFactory.setBeanFactory()
  • PriorityOrdered.getOrder()
  • InstantiationAwareBeanPostProcessorAdapter.determineCandidateConstructors()：处理@Lookup注解并获取候选的构造函数(包括父类上的@Lookup)；
  • MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()：注册需要注入的member；
  • InstantiationAwareBeanPostProcessorAdapter.postProcessProperties()：执行注入bean的逻辑(包括父类上的注入注解)；
  • MergedBeanDefinitionPostProcessor.resetBeanDefinition()：重置bean定义后，在缓存中删除注入数据；

/**
 * 实现自动装配：注解，字段，setter方法和配置方法
 * 通过注解检测需要注入的成员。默认注解包括@Autowired和@Value，并且支持JSR-330的@Inject(同@Autowired)
 * 
 * 构造方法注入：
 * 如果required=true，只能标注一个@Autowired
 * 如果required=false，可标注多个@Autowired，且匹配项最多的构造函数会生效
 * 如果没有匹配到任何一个构造函数，则默认的构造函数会生效
 * 如果只有一个构造函数，则这个构造函数会生效(无论有没有标注@Autowired)
 * 构造函数不需要为public
 *
 * 字段注入：
 * 字段在构造方法注入之后，在配置方法注入之前调用
 * 字段不需要为public
 *
 * 方法注入
 * 配置方法可以有任意名称和任意数量的参数，spring会从容器中匹配并注入这些参数
 * setter方法是配置方法的特例，spring并没有要求配置方法一定是setter方法
 * 配置方法不需要为public
 *
 * xml配置注入
 * 默认情况下，AutowiredAnnotationBeanPostProcessor会注册context:annotation-config和context:component-scan标签
 * 可指定自定义的AutowiredAnnotationBeanPostProcessor删除或者关闭默认的注解配置
 *
 * 注意：注解注入会在xml注入之前执行。后一种配置会覆盖前一种配置
 *
 * Lookup方法
 * @Lookup会在运行查找需要注入的参数(如果参数不是单例的，这会很有用。等同类型安全的getBean方法)
 */
public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
		implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
	//**处理的注入注解
	private final Set> autowiredAnnotationTypes = new LinkedHashSet<>(4);
    //**表示required参数的参数名
	private String requiredParameterName = "required";
    //**表示required参数的默认值
	private boolean requiredParameterValue = true;
    //**默认的执行顺序
	private int order = Ordered.LOWEST_PRECEDENCE - 2;
    //**beanFactory
	@Nullable
	private ConfigurableListableBeanFactory beanFactory;
    //**缓存处理过@Lookup注解的bean名称
	private final Set lookupMethodsChecked = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
    //**缓存指定类候选的构造函数
	private final Map, Constructor[]> candidateConstructorsCache = new ConcurrentHashMap<>(256);
    //**缓存注入的元数据
	private final Map injectionMetadataCache = new ConcurrentHashMap<>(256);

    //**默认处理的自动装配注解为@Autowired和@Value，并且支持@Inject
	public AutowiredAnnotationBeanPostProcessor() {
		this.autowiredAnnotationTypes.add(Autowired.class);
		this.autowiredAnnotationTypes.add(Value.class);
		try {
			this.autowiredAnnotationTypes.add((Class)
					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.
		}
	}
    
    //**指定处理的自动装配注解
	public void setAutowiredAnnotationType(Class autowiredAnnotationType) {
		Assert.notNull(autowiredAnnotationType, "'autowiredAnnotationType' must not be null");
		this.autowiredAnnotationTypes.clear();
		this.autowiredAnnotationTypes.add(autowiredAnnotationType);
	}

	//**指定多个处理的自动装配注解
	public void setAutowiredAnnotationTypes(Set> autowiredAnnotationTypes) {
		Assert.notEmpty(autowiredAnnotationTypes, "'autowiredAnnotationTypes' must not be empty");
		this.autowiredAnnotationTypes.clear();
		this.autowiredAnnotationTypes.addAll(autowiredAnnotationTypes);
	}

	//**指定表示required参数的参数名
	public void setRequiredParameterName(String requiredParameterName) {
		this.requiredParameterName = requiredParameterName;
	}

	//**指定表示required参数的参数值
	public void setRequiredParameterValue(boolean requiredParameterValue) {
		this.requiredParameterValue = requiredParameterValue;
	}

    //**设置执行顺序
	public void setOrder(int order) {
		this.order = order;
	}
    
    //**实现PriorityOrdered，获取执行顺序
	@Override
	public int getOrder() {
		return this.order;
	}

    //**实现BeanFactoryAware，获取beanFactory
	@Override
	public void setBeanFactory(BeanFactory beanFactory) {
		if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
			throw new IllegalArgumentException(
					"AutowiredAnnotationBeanPostProcessor requires a ConfigurableListableBeanFactory: " + beanFactory);
		}
		this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
	}

    //**实现MergedBeanDefinitionPostProcessor
    //**如果存在需要注入的member，则注册到externallyManagedConfigMembers(spring管理的配置成员集合)
	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
	    //**获取注入元数据
		InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
		//**如果存在需要注入的member，把注入元素注册到externallyManagedConfigMembers(spring管理的配置成员集合)
		metadata.checkConfigMembers(beanDefinition);
	}
    
    //**实现MergedBeanDefinitionPostProcessor，重置bean定义后，在缓存中删除注入数据；
	@Override
	public void resetBeanDefinition(String beanName) {
		this.lookupMethodsChecked.remove(beanName);
		this.injectionMetadataCache.remove(beanName);
	}
    
    //**实现InstantiationAwareBeanPostProcessorAdapter，处理@Lookup注解并获取候选的构造函数
    //**如果required=true，则只能有一个候选构造函数
    //**如果required=false，则全部都为候选构造函数
    //**如果只有一个构造函数且包含参数，则这个构造函数为候选构造函数(无论有没有标注@Autowired)
	@Override
	@Nullable
	public Constructor[] determineCandidateConstructors(Class beanClass, final String beanName)
			throws BeanCreationException {
        //**处理当前类及其父类@Lookup注解(spring会动态生成子类并重写/实现被注解的方法)，并缓存到lookupMethodsChecked中
		if (!this.lookupMethodsChecked.contains(beanName)) {
			if (AnnotationUtils.isCandidateClass(beanClass, Lookup.class)) {
				try {
					Class targetClass = beanClass;
					do {
						ReflectionUtils.doWithLocalMethods(targetClass, method -> {
							Lookup lookup = method.getAnnotation(Lookup.class);
							if (lookup != null) {
								Assert.state(this.beanFactory != null, "No BeanFactory available");
								LookupOverride override = new LookupOverride(method, lookup.value());
								try {
									RootBeanDefinition mbd = (RootBeanDefinition)
											this.beanFactory.getMergedBeanDefinition(beanName);
									mbd.getMethodOverrides().addOverride(override);
								}
								catch (NoSuchBeanDefinitionException ex) {
									throw new BeanCreationException(beanName,
											"Cannot apply @Lookup to beans without corresponding bean definition");
								}
							}
						});
						targetClass = targetClass.getSuperclass();
					}
					while (targetClass != null && targetClass != Object.class);

				}
				catch (IllegalStateException ex) {
					throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
				}
			}
			this.lookupMethodsChecked.add(beanName);
		}

		//**从缓存中获取当前类的候选构造函数
		Constructor[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
		//**缓存中不存在，则获取
		if (candidateConstructors == null) {
			//**加锁
			synchronized (this.candidateConstructorsCache) {
				candidateConstructors = this.candidateConstructorsCache.get(beanClass);
				if (candidateConstructors == null) {
				    
				    //**获取所有构造函数
					Constructor[] rawCandidates;
					try {
						rawCandidates = beanClass.getDeclaredConstructors();
					}
					catch (Throwable ex) {
						throw new BeanCreationException(beanName,
								"Resolution of declared constructors on bean Class [" + beanClass.getName() +
								"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
					}
					//**存放候选构造函数
					List> candidates = new ArrayList<>(rawCandidates.length);
					//**required=true的构造函数
					Constructor requiredConstructor = null;
					//**默认的无参构造函数
					Constructor defaultConstructor = null;
					//**Kotlin中的primary构造函数，java直接返回null
					Constructor primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
					//**非Synthetic构造函数的数量(synthetic是由编译器引入的构造函数，主要用于JVM内部使用)
					int nonSyntheticConstructors = 0;
					
					//**遍历所有构造函数
					for (Constructor candidate : rawCandidates) {
					    //**记录非Synthetic构造函数的数量
						if (!candidate.isSynthetic()) {
							nonSyntheticConstructors++;
						}
						//**java这里为null
						else if (primaryConstructor != null) {
							continue;
						}
						//**查找是否包含@Autowired和@Value等注入注解
						MergedAnnotation ann = findAutowiredAnnotation(candidate);
						//**如果不包含注入注解，则获取当前类的用户类(如果当前类为spring生成的动态代理类，则会获取到当前类代理的类)构造函数的注入注解
						if (ann == null) {
							Class userClass = ClassUtils.getUserClass(beanClass);
							if (userClass != beanClass) {
								try {
									Constructor superCtor =
											userClass.getDeclaredConstructor(candidate.getParameterTypes());
									ann = findAutowiredAnnotation(superCtor);
								}
								catch (NoSuchMethodException ex) {
									// Simply proceed, no equivalent superclass constructor found...
								}
							}
						}
						
						//**如果包含注入注解，验证如果required=true时只能标注一个@Autowired，并添加到候选构造函数集合中
						if (ann != null) {
							if (requiredConstructor != null) {
								throw new BeanCreationException(beanName,
										"Invalid autowire-marked constructor: " + candidate +
										". Found constructor with 'required' Autowired annotation already: " +
										requiredConstructor);
							}
							//**获取当前构造函数required的值
							boolean required = determineRequiredStatus(ann);
							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) { //**否则如果参数为0，则为默认构造函数
							defaultConstructor = candidate;
						}
					}
					
					//**如果候选构造函数不为空，并且required=true的构造函数为空，则把默认构造函数添加到候选构造函数集合中
					if (!candidates.isEmpty()) {
						if (requiredConstructor == null) {
							if (defaultConstructor != null) {
								candidates.add(defaultConstructor);
							}
							else if (candidates.size() == 1 && logger.isInfoEnabled()) {
								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 = candidates.toArray(new Constructor[0]);
					}
				    //**如果只有一个构造函数，则这个构造函数会生效(无论有没有标注@Autowired)
					else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
						candidateConstructors = new Constructor[] {rawCandidates[0]};
					}
					//**针对Kotlin中的primary构造函数
					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];
					}
					//**缓存到candidateConstructorsCache中
					this.candidateConstructorsCache.put(beanClass, candidateConstructors);
				}
			}
		}
		return (candidateConstructors.length > 0 ? candidateConstructors : null);
	}
    
    //**实现InstantiationAwareBeanPostProcessorAdapter.postProcessProperties()，执行注入bean的逻辑
	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
	    //**获取当前bean的注入元数据
		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
		try {//**执行注入(字段使用使用AutowiredFieldElement.inject()，方法使用AutowiredMethodElement的.inject())
			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;
	}
    
    //**过时，以postProcessProperties为准
	@Deprecated
	@Override
	public PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {

		return postProcessProperties(pvs, bean, beanName);
	}

	//**指定bean的注入，逻辑基本和postProcessProperties一样，运行项目没发现有调用
	public void processInjection(Object bean) throws BeanCreationException {
		Class clazz = bean.getClass();
		InjectionMetadata metadata = findAutowiringMetadata(clazz.getName(), clazz, null);
		try {
			metadata.inject(bean, null, null);
		}
		catch (BeanCreationException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					"Injection of autowired dependencies failed for class [" + clazz + "]", ex);
		}
	}

    //**获取指定bean的注入元数据
	private InjectionMetadata findAutowiringMetadata(String beanName, Class clazz, @Nullable PropertyValues pvs) {
		// Fall back to class name as cache key, for backwards compatibility with custom callers.
		String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
		//**从缓存中获取注入元数据
		InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
		//**如果metadata为空，则重新构造metadata，如果metadata的目标类不是传入的clazz，则清除注入数据，然后重新构造metadata
		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
					metadata = buildAutowiringMetadata(clazz);
					//**缓存到injectionMetadataCache中
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
			}
		}
		return metadata;
	}

    //**构造指定类及其父类的注入元数据
	private InjectionMetadata buildAutowiringMetadata(final Class clazz) {
	    //**如果不包含注入注解，则返回空注入元数据
		if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
			return InjectionMetadata.EMPTY;
		}
        //**存放类的所有注入元素
		List elements = new ArrayList<>();
		Class targetClass = clazz;
        
        //**遍历获取类及其父类的注入元素
		do {
			final List currElements = new ArrayList<>();
            
            //**遍历获取类的字段注入元素
			ReflectionUtils.doWithLocalFields(targetClass, field -> {
				MergedAnnotation ann = findAutowiredAnnotation(field);
				if (ann != null) {
				    //**不支持静态字段
					if (Modifier.isStatic(field.getModifiers())) {
						if (logger.isInfoEnabled()) {
							logger.info("Autowired annotation is not supported on static fields: " + field);
						}
						return;
					}
					//**获取required的值
					boolean required = determineRequiredStatus(ann);
					//**创建注入元素并存放到currElements中
					currElements.add(new AutowiredFieldElement(field, required));
				}
			});

            //**遍历获取类的方法注入元素
			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
			    //**如果方法是编译器引入桥接方法，则跳过
				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
					return;
				}
				
				MergedAnnotation ann = findAutowiredAnnotation(bridgedMethod);
				//**如果方法包含注入注解 && 属于指定clazz类(继承的方法也算)
				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
				    //**不支持静态方法
					if (Modifier.isStatic(method.getModifiers())) {
						if (logger.isInfoEnabled()) {
							logger.info("Autowired annotation is not supported on static methods: " + method);
						}
						return;
					}
					//**没有参数，则跳过
					if (method.getParameterCount() == 0) {
						if (logger.isInfoEnabled()) {
							logger.info("Autowired annotation should only be used on methods with parameters: " +
									method);
						}
					}
					//**获取required的值
					boolean required = determineRequiredStatus(ann);
					//**获取方法的属性描述器
					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
					//**创建注入元素并存放到currElements中
					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);
	}
    
    //**查找member上的注入注解
	@Nullable
	private MergedAnnotation findAutowiredAnnotation(AccessibleObject ao) {
		MergedAnnotations annotations = MergedAnnotations.from(ao);
		for (Class type : this.autowiredAnnotationTypes) {
			MergedAnnotation annotation = annotations.get(type);
			if (annotation.isPresent()) {
				return annotation;
			}
		}
		return null;
	}

	//**获取注入配置的required的值
	@SuppressWarnings({"deprecation", "cast"})
	protected boolean determineRequiredStatus(MergedAnnotation ann) {
		// The following (AnnotationAttributes) cast is required on JDK 9+.
		return determineRequiredStatus((AnnotationAttributes)
				ann.asMap(mergedAnnotation -> new AnnotationAttributes(mergedAnnotation.getType())));
	}

	//**过时，获取注入配置的required的值
	@Deprecated
	protected boolean determineRequiredStatus(AnnotationAttributes ann) {
		return (!ann.containsKey(this.requiredParameterName) ||
				this.requiredParameterValue == ann.getBoolean(this.requiredParameterName));
	}

	//**根据类对象查找注入的候选bean
	protected  Map findAutowireCandidates(Class type) throws BeansException {
		if (this.beanFactory == null) {
			throw new IllegalStateException("No BeanFactory configured - " +
					"override the getBeanOfType method or specify the 'beanFactory' property");
		}
		return BeanFactoryUtils.beansOfTypeIncludingAncestors(this.beanFactory, type);
	}

	//**注册bean及其依赖注入的bean
	private void registerDependentBeans(@Nullable String beanName, Set autowiredBeanNames) {
		if (beanName != null) {
			for (String autowiredBeanName : autowiredBeanNames) {
				if (this.beanFactory != null && this.beanFactory.containsBean(autowiredBeanName)) {
					this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
				}
				if (logger.isTraceEnabled()) {
					logger.trace("Autowiring by type from bean name '" + beanName +
							"' to bean named '" + autowiredBeanName + "'");
				}
			}
		}
	}

	//**解析指定的缓存方法参数/字段值
	@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;
		}
	}

    //**注入元素(描述每个依赖spring注入的字段相关信息)
	private class AutowiredFieldElement extends InjectionMetadata.InjectedElement {
        //**required
		private final boolean required;
        //**是否已经缓存字段注入的值
		private volatile boolean cached = false;
        //**缓存字段注入的值
		@Nullable
		private volatile Object cachedFieldValue;

		public AutowiredFieldElement(Field field, boolean required) {
			super(field, null);
			this.required = required;
		}
        
        //**注入
		@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 {
			    //**获取注入的bean
				DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
				desc.setContainingClass(bean.getClass());
				Set autowiredBeanNames = new LinkedHashSet<>(1);
				Assert.state(beanFactory != null, "No BeanFactory available");
				TypeConverter typeConverter = beanFactory.getTypeConverter();
				try {
				    //**如果是@value获取配置的参数值，则此处获取的是配置的值，autowiredBeanNames会为空
					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) { //**如果注入的bean存在 || required = true
							this.cachedFieldValue = desc;  //**缓存注入的bean
							//**注册bean及其依赖注入的bean
							registerDependentBeans(beanName, autowiredBeanNames); 
							//**如果匹配的依赖bean只有一个，则封装为ShortcutDependencyDescriptor，并缓存
							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);
			}
		}
	}

	//**注入元素(描述每个依赖spring注入的方法相关信息)
	private class AutowiredMethodElement extends InjectionMetadata.InjectedElement {
        //**required
		private final boolean required;
        //**是否已经缓存方法注入的值
		private volatile boolean cached = false;
        //**缓存方法注入的值
		@Nullable
		private volatile Object[] cachedMethodArguments;

		public AutowiredMethodElement(Method method, boolean required, @Nullable PropertyDescriptor pd) {
			super(method, pd);
			this.required = required;
		}
        
        //**注入
		@Override
		protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
		    //**如果已经注入，则跳过
			if (checkPropertySkipping(pvs)) {
				return;
			}
			Method method = (Method) this.member;
			Object[] arguments;
			if (this.cached) {//**如果已经缓存方法注入的值，则直接从缓存中解析
				arguments = resolveCachedArguments(beanName);
			}
			else {
				int argumentCount = method.getParameterCount();
				arguments = new Object[argumentCount];
				DependencyDescriptor[] descriptors = new DependencyDescriptor[argumentCount];
				Set autowiredBeans = new LinkedHashSet<>(argumentCount);
				Assert.state(beanFactory != null, "No BeanFactory available");
				TypeConverter typeConverter = beanFactory.getTypeConverter();
				//**遍历方法的所有参数，获取注入的bean
				for (int i = 0; i < arguments.length; i++) {
					MethodParameter methodParam = new MethodParameter(method, i);
					DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required);
					currDesc.setContainingClass(bean.getClass());
					descriptors[i] = currDesc;
					try {
					    //**如果是@value获取配置的参数值，则此处获取的是配置的值，autowiredBeanNames会为空
						Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
						if (arg == null && !this.required) {
							arguments = null;
							break;
						}
						arguments[i] = arg;
					}
					catch (BeansException ex) {
						throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(methodParam), ex);
					}
				}
				synchronized (this) {//**同步
					if (!this.cached) {
						if (arguments != null) {
							DependencyDescriptor[] cachedMethodArguments = Arrays.copyOf(descriptors, arguments.length);
							//**注册bean及其依赖注入的bean
							registerDependentBeans(beanName, autowiredBeans);
							//**如果每个参数匹配的依赖bean都只有一个，则封装为ShortcutDependencyDescriptor，并缓存
							if (autowiredBeans.size() == argumentCount) {
								Iterator it = autowiredBeans.iterator();
								Class[] paramTypes = method.getParameterTypes();
								for (int i = 0; i < paramTypes.length; i++) {
									String autowiredBeanName = it.next();
									if (beanFactory.containsBean(autowiredBeanName) &&
											beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) {
										cachedMethodArguments[i] = new ShortcutDependencyDescriptor(
												descriptors[i], autowiredBeanName, paramTypes[i]);
									}
								}
							}
							this.cachedMethodArguments = cachedMethodArguments;
						}
						else {
							this.cachedMethodArguments = null;
						}
						this.cached = true;
					}
				}
			}
			if (arguments != null) {
				try {//**通过反射调用方法
					ReflectionUtils.makeAccessible(method);
					method.invoke(bean, arguments);
				}
				catch (InvocationTargetException ex) {
					throw ex.getTargetException();
				}
			}
		}
        
        //**遍历解析缓存参数
		@Nullable
		private Object[] resolveCachedArguments(@Nullable String beanName) {
			Object[] cachedMethodArguments = this.cachedMethodArguments;
			if (cachedMethodArguments == null) {
				return null;
			}
			Object[] arguments = new Object[cachedMethodArguments.length];
			for (int i = 0; i < arguments.length; i++) {
				arguments[i] = resolvedCachedArgument(beanName, cachedMethodArguments[i]);
			}
			return arguments;
		}
	}

    //**注入依赖描述器
	@SuppressWarnings("serial")
	private static class ShortcutDependencyDescriptor extends DependencyDescriptor {

		private final String shortcut;

		private final Class requiredType;

		public ShortcutDependencyDescriptor(DependencyDescriptor original, String shortcut, Class requiredType) {
			super(original);
			this.shortcut = shortcut;
			this.requiredType = requiredType;
		}

		@Override
		public Object resolveShortcut(BeanFactory beanFactory) {
			return beanFactory.getBean(this.shortcut, this.requiredType);
		}
	}

}