通过之前对注解式配置的解析（Spring 源码学习（三）—— 注解式配置解析_spring源码学习-CSDN博客）可以发现其使用 AnnotationConfigUtils 类的 registerAnnotationConfigProcessors 静态方法对象注解后处理器对象进行注册；该方法首先使用 unwrapDefaultListableBeanFactory 方法对 registry 方法进行解封装并将其结果保存到 beanFactory 局部变量中，在该变量不为 null 且其 dependencyComparator 属性不为 AnnotationAwareOrderComparator 对象时将其 dependencyComparator 属性更新为 AnnotationAwareOrderComparator 类中的 INSTANCE 常量值，在其 autowireCandidateResolver 属性不为 ContextAnnotationAutowireCandidateResolver 对象时则会将该属性更新为新建的 ContextAnnotationAutowireCandidateResolver 对象；随后在其中还没有名为 CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME 对象，即还未注册 internalConfigurationAnnotationProcessor 对象时则会向其中注册该对象；在其中还没有 AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME 对象，即还未注册 internalAutowiredAnnotationProcessor 对象时则会向其中注册该对象；在其中还没有 COMMON_ANNOTATION_PROCESSOR_BEAN_NAME 对象，即还未注册 internalCommonAnnotationProcessor 对象且 jsr250Present 静态变量不为 null 时则会向其中注册该对象；在其中还没有 PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME 对象，即还未注册 internalPersistenceAnnotationProcessor 对象且 jpaPresent 静态变量不为 null 时则会向其中注册该对象；在其中还没有 EVENT_LISTENER_PROCESSOR_BEAN_NAME 对象，即还未注册 internalEventListenerProcessor 对象时则会向其中注册该对象；在其中还没有 EVENT_LISTENER_FACTORY_BEAN_NAME 对象，即还未注册 internalEventListenerFactory 对象时则会向其中注册该对象；

public abstract class AnnotationConfigUtils {

	public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalConfigurationAnnotationProcessor";

	public static final String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalAutowiredAnnotationProcessor";

	public static final String COMMON_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalCommonAnnotationProcessor";

	public static final String PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalPersistenceAnnotationProcessor";

	private static final String PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME =
			"org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor";

	public static final String EVENT_LISTENER_PROCESSOR_BEAN_NAME =
			"org.springframework.context.event.internalEventListenerProcessor";

	public static final String EVENT_LISTENER_FACTORY_BEAN_NAME =
			"org.springframework.context.event.internalEventListenerFactory";

	private static final boolean jsr250Present;

	private static final boolean jpaPresent;

	static {
		ClassLoader classLoader = AnnotationConfigUtils.class.getClassLoader();
		jsr250Present = ClassUtils.isPresent("javax.annotation.Resource", classLoader);
		jpaPresent = ClassUtils.isPresent("javax.persistence.EntityManagerFactory", classLoader) &&
				ClassUtils.isPresent(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, classLoader);
	}

	public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
		registerAnnotationConfigProcessors(registry, null);
	}

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}
}

        unwrapDefaultListableBeanFactory 方法在 registry 参数为 DefaultListableBeanFactory 对象时直接返回该参数，为 GenericApplicationContext 对象时返回 getDefaultListableBeanFactory 方法执行结果，否则返回 null；

public abstract class AnnotationConfigUtils {
	@Nullable
	private static DefaultListableBeanFactory unwrapDefaultListableBeanFactory(BeanDefinitionRegistry registry) {
		if (registry instanceof DefaultListableBeanFactory) {
			return (DefaultListableBeanFactory) registry;
		}
		else if (registry instanceof GenericApplicationContext) {
			return ((GenericApplicationContext) registry).getDefaultListableBeanFactory();
		}
		else {
			return null;
		}
	}
}

        registerPostProcessor 方法首先将 definition 参数的角色设置为 BeanDefinition 类的 ROLE_INFRASTRUCTURE 常量值同时将其以 beanName 参数名注入 registry 注册器中，最后使用 definition 与 beanName 两个参数创建 BeanDefinitionHolder 对象并返回；

public abstract class AnnotationConfigUtils {
	private static BeanDefinitionHolder registerPostProcessor(
			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		registry.registerBeanDefinition(beanName, definition);
		return new BeanDefinitionHolder(definition, beanName);
	}
}

一 AnnotationAwareOrderComparator 类

1 OrderComparator 类

1.1 常量

        OrderComparator 类中只有一个存储单例 OrderComparator 对象的常量 INSTANCE；

public class OrderComparator implements Comparator<Object> {
	public static final OrderComparator INSTANCE = new OrderComparator();
}

1.2 类方法

1.2.1 withSourceProvider 方法

        withSourceProvider 方法直接使用 sourceProvider 参数执行 doCompare 方法来实现 Comparator 比较器接口；

public class OrderComparator implements Comparator<Object> {
	public Comparator<Object> withSourceProvider(OrderSourceProvider sourceProvider) {
		return (o1, o2) -> doCompare(o1, o2, sourceProvider);
	}
}

1.2.2 compare 方法

        compare 方法直接使用参数值与 null 执行 doCompare 方法并返回执行结果；

public class OrderComparator implements Comparator<Object> {
	@Override
	public int compare(@Nullable Object o1, @Nullable Object o2) {
		return doCompare(o1, o2, null);
	}
}

        doCompare 方法在 o1 为 PriorityOrdered 对象且 o2 不为 PriorityOrdered 对象时直接返回 -1 而在 o1 不为 PriorityOrdered 对象且 o2 为 PriorityOrdered 对象时直接返回 1；并在之后使用 getOrder 方法分别计算 o1 与 o2 对象的排序值并返回其比较结果；

public class OrderComparator implements Comparator<Object> {
	private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
		boolean p1 = (o1 instanceof PriorityOrdered);
		boolean p2 = (o2 instanceof PriorityOrdered);
		if (p1 && !p2) {
			return -1;
		}
		else if (p2 && !p1) {
			return 1;
		}

		int i1 = getOrder(o1, sourceProvider);
		int i2 = getOrder(o2, sourceProvider);
		return Integer.compare(i1, i2);
	}
}

        getOrder 方法在 obj 与 sourceProvider 参数都为 null 时直接执行 getOrder 方法并返回，直接调用 sourceProvider 参数的 getOrderSource 方法获取 obj 参数对应的 orderSource，在其不为 null 时，在该值不为数组时直接执行单参数 findOrder 方法为 order 局部参数赋值，否则对该值中所有元素逐一执行 findOrder 方法，直到其执行结果不为空时返回其执行结果，若执行对所有元素执行完毕后也直接执行单参数 getOrder 方法并返回；最后若 order 变量值不为 null 时直接执行单参数 getOrder 方法并返回；

public class OrderComparator implements Comparator<Object> {
	private int getOrder(@Nullable Object obj, @Nullable OrderSourceProvider sourceProvider) {
		Integer order = null;
		if (obj != null && sourceProvider != null) {
			Object orderSource = sourceProvider.getOrderSource(obj);
			if (orderSource != null) {
				if (orderSource.getClass().isArray()) {
					for (Object source : ObjectUtils.toObjectArray(orderSource)) {
						order = findOrder(source);
						if (order != null) {
							break;
						}
					}
				}
				else {
					order = findOrder(orderSource);
				}
			}
		}
		return (order != null ? order : getOrder(obj));
	}
}

        单参数 getOrder 方法在 obj 为 null 时直接返回 Ordered 类中的 LOWEST_PRECEDENCE 常量值，及最大整型数，否则使用 obj 参数执行 findOrder 方法尝试获取排序号，获取到时直接返回该结果值，没获取到也是返回 Ordered 类中的 LOWEST_PRECEDENCE 常量值；

public class OrderComparator implements Comparator<Object> {
	protected int getOrder(@Nullable Object obj) {
		if (obj != null) {
			Integer order = findOrder(obj);
			if (order != null) {
				return order;
			}
		}
		return Ordered.LOWEST_PRECEDENCE;
	}
}

        findOrder 方法只有在 obj 实现了 Ordered 接口时才会返回其 getOrder 方法结果值，否则直接返回 null；

public class OrderComparator implements Comparator<Object> {
	@Nullable
	protected Integer findOrder(Object obj) {
		return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
	}
}

1.2.3 getPriority 方法

        getPriority 方法直接返回 null；

public class OrderComparator implements Comparator<Object> {
	@Nullable
	public Integer getPriority(Object obj) {
		return null;
	}
}

1.3 sortIfNecessary 方法

        sortIfNecessary 方法只有在 value 参数为数组或 List 列表对象时才会使用 INSTANCE 常量执行对应的 sort 方法对其进行排序；

public class OrderComparator implements Comparator<Object> {
	public static void sortIfNecessary(Object value) {
		if (value instanceof Object[]) {
			sort((Object[]) value);
		}
		else if (value instanceof List) {
			sort((List<?>) value);
		}
	}

	public static void sort(List<?> list) {
		if (list.size() > 1) {
			list.sort(INSTANCE);
		}
	}

	public static void sort(Object[] array) {
		if (array.length > 1) {
			Arrays.sort(array, INSTANCE);
		}
	}
}

1.4 OrderSourceProvider 内部类

        OrderSourceProvider 内部类为只有一个 getOrderSource 方法的方法接口；

public class OrderComparator implements Comparator<Object> {
	@FunctionalInterface
	public interface OrderSourceProvider {
		@Nullable
		Object getOrderSource(Object obj);
	}
}

2 常量

        AnnotationAwareOrderComparator 类也只有一个存储单例 AnnotationAwareOrderComparator 对象的常量 INSTANCE；

public class AnnotationAwareOrderComparator extends OrderComparator {
	public static final AnnotationAwareOrderComparator INSTANCE = new AnnotationAwareOrderComparator();
}

3 类方法

3.1 findOrder 方法

        findOrder 方法首先在父类的 findOrder 方法执行结果不为 null 时直接返回其结果，否则执行 findOrderFromAnnotation 方法并返回；

public class AnnotationAwareOrderComparator extends OrderComparator {
	@Override
	@Nullable
	protected Integer findOrder(Object obj) {
		Integer order = super.findOrder(obj);
		if (order != null) {
			return order;
		}
		return findOrderFromAnnotation(obj);
	}
}

        findOrderFromAnnotation 方法首先通过 TYPE_HIERARCHY 创建 MergedAnnotations 对象，即包含其实现接口上的所有注解，随后通过 OrderUtils 类的 getOrderFromAnnotations 方法查询通过 Order 或 Priority 注解设置的排序值，最后若获取到的 order 值为 null 且 obj 参数为 DecoratingProxy 对象时则使用装饰类递归调用 findOrderFromAnnotation 方法并返回其结果，否则直接返回获取到的 order 值；

public class AnnotationAwareOrderComparator extends OrderComparator {
	@Nullable
	private Integer findOrderFromAnnotation(Object obj) {
		AnnotatedElement element = (obj instanceof AnnotatedElement ? (AnnotatedElement) obj : obj.getClass());
		MergedAnnotations annotations = MergedAnnotations.from(element, SearchStrategy.TYPE_HIERARCHY);
		Integer order = OrderUtils.getOrderFromAnnotations(element, annotations);
		if (order == null && obj instanceof DecoratingProxy) {
			return findOrderFromAnnotation(((DecoratingProxy) obj).getDecoratedClass());
		}
		return order;
	}
}

3.2 getPriority 方法

        getPriority 方法在 obj 参数为 Class 对象则直接使用该参数执行 OrderUtils 类的 getPriority 方法并返回，否则使用 obj 的类 Class 对象执行 OrderUtils 类的 getPriority 方法获取其结果，之后在获取到的执行结果为 null 且 obj 参数为 DecoratingProxy 对象时，也会使用其修饰类递归调用 getPriority 方法并返回，否则直接返回 getPriority 方法执行结果；

public class AnnotationAwareOrderComparator extends OrderComparator {
	@Override
	@Nullable
	public Integer getPriority(Object obj) {
		if (obj instanceof Class) {
			return OrderUtils.getPriority((Class<?>) obj);
		}
		Integer priority = OrderUtils.getPriority(obj.getClass());
		if (priority == null  && obj instanceof DecoratingProxy) {
			return getPriority(((DecoratingProxy) obj).getDecoratedClass());
		}
		return priority;
	}
}

二 ContextAnnotationAutowireCandidateResolver 类

1 AutowireCandidateResolver 接口

        AutowireCandidateResolver 接口向外提供了 autowire 自动注入对象的解析功能；

1.1 isAutowireCandidate 方法   

        isAutowireCandidate 方法用于判断指定对象注册表是否为主动注入候选对象，其拥有两个入参，用于判断的 BeanDefinitionHolder 类型的 bdHolder 对象及 DependencyDescriptor 类型的依赖描述参数 descriptor，默认实现直接执行 bdHolder 关联对象注册表的 isAutowireCandidate 方法并返回其执行结果；

public interface AutowireCandidateResolver {
	default boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		return bdHolder.getBeanDefinition().isAutowireCandidate();
	}
}

1.2 isRequired 方法   

        isRequired 方法只有一个 DependencyDescriptor 类型的 descriptor 参数用于判断该参数描述的依赖是否为必须的，即依赖是否不是 Optional 与 Nullable 等进行封装或修饰，其默认直接返回 descriptor 参数的 isRequired 方法执行结果；

public interface AutowireCandidateResolver {
	default boolean isRequired(DependencyDescriptor descriptor) {
		return descriptor.isRequired();
	}
}

1.3 hasQualifier 方法   

        hasQualifier 方法也只有一个 DependencyDescriptor 类型的 descriptor 参数用于判断该参数是否拥有类型之外的其他限制，如 Qualifier 注解声明的对象名，其默认直接返回 false；

public interface AutowireCandidateResolver {
	default boolean hasQualifier(DependencyDescriptor descriptor) {
		return false;
	}
}

1.4 getSuggestedValue 方法   

        getSuggestedValue 方法也只有一个 DependencyDescriptor 类型的 descriptor 参数用于判断获取默认推荐对象，其默认直接返回 null；

public interface AutowireCandidateResolver {
	@Nullable
	default Object getSuggestedValue(DependencyDescriptor descriptor) {
		return null;
	}
}

1.5 getLazyResolutionProxyIfNecessary 方法   

        getLazyResolutionProxyIfNecessary 方法也除了一个 DependencyDescriptor 类型的 descriptor 参数还拥有一个对象名 beanName 参数，用于获取以来解析延迟加载代理对象，其默认直接返回 null；

public interface AutowireCandidateResolver {
	@Nullable
	default Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
		return null;
	}
}

1.6 cloneIfNecessary 方法   

        cloneIfNecessary 方法用于复制当前对象，其默认使用 BeanUtils 类的 instantiateClass 方法创建 getClass 方法执行结果对象；

public interface AutowireCandidateResolver {
	default AutowireCandidateResolver cloneIfNecessary() {
		return BeanUtils.instantiateClass(getClass());
	}
}

1.7 DependencyDescriptor 类

1.7.1 InjectionPoint 类

1）属性及构造方法  

        InjectionPoint 类拥有三个属性，用于保存注入方法参数的 methodParameter 属性、保存注入字段对象 field 属性及保存字段注解数组 fieldAnnotations 属性；

public class InjectionPoint {

	@Nullable
	protected MethodParameter methodParameter;

	@Nullable
	protected Field field;

	@Nullable
	private volatile Annotation[] fieldAnnotations;

	@Nullable
	public MethodParameter getMethodParameter() {
		return this.methodParameter;
	}

	@Nullable
	public Field getField() {
		return this.field;
	}
}

         InjectionPoint 类拥有 4 个不同的构造方法，其中无参构造方法直接创建空对象，其他构造方法都只有一个参数，参数类型为 MethodParameter 与 Field 对象时，其首先对入参值进行非空验证，并在验证通过后将对应属性初始化为入参值；而参数类型为 InjectionPoint 对象时，在其 methodParameter 属性不为 null 时使用该属性创建 MethodParameter 对象为 methodParameter 属性进行赋值，随后将 field 与 fieldAnnotations 属性分别初始化为 original 参数的对应属性值；

public class InjectionPoint {
	public InjectionPoint(MethodParameter methodParameter) {
		Assert.notNull(methodParameter, "MethodParameter must not be null");
		this.methodParameter = methodParameter;
	}

	public InjectionPoint(Field field) {
		Assert.notNull(field, "Field must not be null");
		this.field = field;
	}

	protected InjectionPoint(InjectionPoint original) {
		this.methodParameter = (original.methodParameter != null ?
				new MethodParameter(original.methodParameter) : null);
		this.field = original.field;
		this.fieldAnnotations = original.fieldAnnotations;
	}

	protected InjectionPoint() {
	}
}

2）getAnnotations 方法  

        getAnnotations 方法在 field 属性为 null 时，直接返回 obtainMethodParameter 方法执行结果的 getParameterAnnotations 方法执行结果；否则在 fieldAnnotations 属性不为 null 时直接返回该属性值，在其为 null 时则会将 fieldAnnotations 属性初始化为 field 属性所有修饰注解数组对象并返回该数组；

public class InjectionPoint {
	public Annotation[] getAnnotations() {
		if (this.field != null) {
			Annotation[] fieldAnnotations = this.fieldAnnotations;
			if (fieldAnnotations == null) {
				fieldAnnotations = this.field.getAnnotations();
				this.fieldAnnotations = fieldAnnotations;
			}
			return fieldAnnotations;
		}
		else {
			return obtainMethodParameter().getParameterAnnotations();
		}
	}
}

        obtainMethodParameter 方法在 methodParameter 属性通过了非空验证后直接返回 methodParameter 属性值；

public class InjectionPoint {
	protected final MethodParameter obtainMethodParameter() {
		Assert.state(this.methodParameter != null, "Neither Field nor MethodParameter");
		return this.methodParameter;
	}
}

3）getAnnotation 方法  

        getAnnotation 方法在 field 属性为 null 时，直接返回 obtainMethodParameter 方法执行结果的 getParameterAnnotation 方法执行结果；否则返回 field 属性上的指定注解对象；

public class InjectionPoint {
	@Nullable
	public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
		return (this.field != null ? this.field.getAnnotation(annotationType) :
				obtainMethodParameter().getParameterAnnotation(annotationType));
	}
}

4）getDeclaredType 方法  

        getDeclaredType 方法在 field 属性为 null 时，直接返回 obtainMethodParameter 方法执行结果的 getParameterType 方法执行结果；否则返回 field 属性的类型 Class 对象；

public class InjectionPoint {
	public Class<?> getDeclaredType() {
		return (this.field != null ? this.field.getType() : obtainMethodParameter().getParameterType());
	}
}

5）getMember 方法  

        getDeclaredType 方法在 field 属性为 null 时，直接返回 obtainMethodParameter 方法执行结果的 getMember 方法执行结果；否则返回 field 属性值；

public class InjectionPoint {
	public Member getMember() {
		return (this.field != null ? this.field : obtainMethodParameter().getMember());
	}
}

6）getAnnotatedElement 方法  

        getDeclaredType 方法在 field 属性为 null 时，直接返回 obtainMethodParameter 方法执行结果的 getAnnotatedElement 方法执行结果；否则返回 field 属性值；

public class InjectionPoint {
	public AnnotatedElement getAnnotatedElement() {
		return (this.field != null ? this.field : obtainMethodParameter().getAnnotatedElement());
	}
}

1.7.2 MethodParameter 类

1）属性及构造方法

• 常量

        MethodParameter 类只有一个空注解对象数组的 EMPTY_ANNOTATION_ARRAY 常量；

public class MethodParameter {

	private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0];
}

• 属性变量

        MethodParameter 类拥有保存方法元数据，其中 executable 属性保存的是关联的方法对象，parameterIndex 属性保存的则是注入的目标参数索引，小于 0 时为方法返回值，parameter 属性保存的是注入的方法参数对象，nestingLevel 则是属性的嵌套层级，而 typeIndexesPerLevel 则是层级与参数索引的映射关系，containingClass、parameterType 及 genericParameterType 属性分别保存类对象、参数类型 Class 对象及 Type 对象，parameterAnnotations 保存的则是修饰参数注解对象数组，parameterNameDiscoverer 属性保存方法的参数查询对象，parameterName 属性为方法参数名及保存嵌套方法参数对象的 nestedMethodParameter 属性。

public class MethodParameter {
	private final Executable executable;

	private final int parameterIndex;

	@Nullable
	private volatile Parameter parameter;

	private int nestingLevel;

	@Nullable
	Map<Integer, Integer> typeIndexesPerLevel;

	@Nullable
	private volatile Class<?> containingClass;

	@Nullable
	private volatile Class<?> parameterType;

	@Nullable
	private volatile Type genericParameterType;

	@Nullable
	private volatile Annotation[] parameterAnnotations;

	@Nullable
	private volatile ParameterNameDiscoverer parameterNameDiscoverer;

	@Nullable
	private volatile String parameterName;

	@Nullable
	private volatile MethodParameter nestedMethodParameter;

	public int getParameterIndex() {
		return this.parameterIndex;
	}

	public int getNestingLevel() {
		return this.nestingLevel;
	}
}

• 构造方法

        MethodParameter 类拥有多个不同的构造方法，其基本上都是将对应属性值更新为对应入参值，但值得注意的是在构造方法未传入 nestingLevel 参数时，直接将 nestingLevel 值默认设置为 1。

public class MethodParameter {
	public MethodParameter(Method method, int parameterIndex) {
		this(method, parameterIndex, 1);
	}

	public MethodParameter(Method method, int parameterIndex, int nestingLevel) {
		Assert.notNull(method, "Method must not be null");
		this.executable = method;
		this.parameterIndex = validateIndex(method, parameterIndex);
		this.nestingLevel = nestingLevel;
	}

	public MethodParameter(Constructor<?> constructor, int parameterIndex) {
		this(constructor, parameterIndex, 1);
	}

	public MethodParameter(Constructor<?> constructor, int parameterIndex, int nestingLevel) {
		Assert.notNull(constructor, "Constructor must not be null");
		this.executable = constructor;
		this.parameterIndex = validateIndex(constructor, parameterIndex);
		this.nestingLevel = nestingLevel;
	}

	MethodParameter(Executable executable, int parameterIndex, @Nullable Class<?> containingClass) {
		Assert.notNull(executable, "Executable must not be null");
		this.executable = executable;
		this.parameterIndex = validateIndex(executable, parameterIndex);
		this.nestingLevel = 1;
		this.containingClass = containingClass;
	}

	public MethodParameter(MethodParameter original) {
		Assert.notNull(original, "Original must not be null");
		this.executable = original.executable;
		this.parameterIndex = original.parameterIndex;
		this.parameter = original.parameter;
		this.nestingLevel = original.nestingLevel;
		this.typeIndexesPerLevel = original.typeIndexesPerLevel;
		this.containingClass = original.containingClass;
		this.parameterType = original.parameterType;
		this.genericParameterType = original.genericParameterType;
		this.parameterAnnotations = original.parameterAnnotations;
		this.parameterNameDiscoverer = original.parameterNameDiscoverer;
		this.parameterName = original.parameterName;
	}
}

        validateIndex 方法验证 parameterIndex 参数值是否大于等于 -1 且小于 executable 参数的关联参数数量，在通过验证后直接返回 parameterIndex 参数；

public class MethodParameter {
	private static int validateIndex(Executable executable, int parameterIndex) {
		int count = executable.getParameterCount();
		Assert.isTrue(parameterIndex >= -1 && parameterIndex < count,
				() -> "Parameter index needs to be between -1 and " + (count - 1));
		return parameterIndex;
	}
}

2）类方法

• executable 相关方法

        getMethod、getConstructor、getMember、getMembr 及 getExecutable 方法都是返回 executable 属性值，其中 getMethod 与 getConstructor 方法只有在 executable 属性为指定对象时才会返回该属性值，否则直接返回 null；而剩余三个方法不对 executable 属性进行任何验证直接返回该属性值；getDeclaringClass 方法则是直接返回 executable 属性的 getDeclaringClass 方法执行结果；

public class MethodParameter {
	@Nullable
	public Method getMethod() {
		return (this.executable instanceof Method ? (Method) this.executable : null);
	}

	@Nullable
	public Constructor<?> getConstructor() {
		return (this.executable instanceof Constructor ? (Constructor<?>) this.executable : null);
	}

	public Class<?> getDeclaringClass() {
		return this.executable.getDeclaringClass();
	}

	public Member getMember() {
		return this.executable;
	}

	public AnnotatedElement getAnnotatedElement() {
		return this.executable;
	}

	public Executable getExecutable() {
		return this.executable;
	}
}

• getParameter 方法

        getParameter 方法在 parameterIndex 属性小于 0 时直接抛出异常，否则在 parameter 属性不为 null 时直接返回该属性值，否则 parameter 属性更新为 executable 属性的 parameterIndex 索引处对应参数对象并返回该对象；

public class MethodParameter {
	public Parameter getParameter() {
		if (this.parameterIndex < 0) {
			throw new IllegalStateException("Cannot retrieve Parameter descriptor for method return type");
		}
		Parameter parameter = this.parameter;
		if (parameter == null) {
			parameter = getExecutable().getParameters()[this.parameterIndex];
			this.parameter = parameter;
		}
		return parameter;
	}
}

• nested 相关方法

        withTypeIndex 方法直接使用 nestingLevel 属性与 typeIndex 参数执行 nested 方法并返回；

public class MethodParameter {
	public MethodParameter withTypeIndex(int typeIndex) {
		return nested(this.nestingLevel, typeIndex);
	}
}

        单参数 nested 方法在 nestedMethodParameter 属性不为 null 且 typeIndex 为 null 时直接返回 nestedMethodParameter 属性值，否则直接使用 nestingLevel 属性 + 1 与 typeIndex 参数执行 nested 方法并将其结果保存到 nestedParam 属性中，最后在 typeIndex 为 null 时会将 nestedMethodParameter 属性更新为 nestedParam 属性并返回该对象值；

public class MethodParameter {
    public MethodParameter nested() {
		return nested(null);
	}

	public MethodParameter nested(@Nullable Integer typeIndex) {
		MethodParameter nestedParam = this.nestedMethodParameter;
		if (nestedParam != null && typeIndex == null) {
			return nestedParam;
		}
		nestedParam = nested(this.nestingLevel + 1, typeIndex);
		if (typeIndex == null) {
			this.nestedMethodParameter = nestedParam;
		}
		return nestedParam;
	}
}

        拥有两个参数的 nested 方法首先调用 clone 方法克隆当前对象，并将其 nestingLevel 属性更新为 nestingLevel 参数值，并在当前 typeIndexesPerLevel 属性不为 null 时，将克隆对象的 typeIndexesPerLevel 属性初始化为使用当前 typeIndexesPerLevel 属性创建的 HashMap 对象，同时在 typeIndex 参数不为 null 时，直接将其与 nestingLevel 参数的映射值添加到克隆对象的 typeIndexesPerLevel 属性中，最后将克隆对象的 parameterType 与 genericParameterType 属性全置为 null 并返回该克隆对象；

public class MethodParameter {
	private MethodParameter nested(int nestingLevel, @Nullable Integer typeIndex) {
		MethodParameter copy = clone();
		copy.nestingLevel = nestingLevel;
		if (this.typeIndexesPerLevel != null) {
			copy.typeIndexesPerLevel = new HashMap<>(this.typeIndexesPerLevel);
		}
		if (typeIndex != null) {
			copy.getTypeIndexesPerLevel().put(copy.nestingLevel, typeIndex);
		}
		copy.parameterType = null;
		copy.genericParameterType = null;
		return copy;
	}
}

• typeIndexesPerLevel 相关方法

        getTypeIndexesPerLevel 方法在 typeIndexesPerLevel 属性为 null 时，将其初始化为初始容量为 4 的 HashMap 对象并返回，否则返回 typeIndexesPerLevel 值；getTypeIndexForLevel 方法则获取 typeIndexesPerLevel 中 nestingLevel 参数对应值，getTypeIndexForCurrentLevel 方法则使用 nestingLevel 属性执行 getTypeIndexForLevel 方法，即获取当前层级对应参数索引值。

public class MethodParameter {
	@Nullable
	public Integer getTypeIndexForCurrentLevel() {
		return getTypeIndexForLevel(this.nestingLevel);
	}

	@Nullable
	public Integer getTypeIndexForLevel(int nestingLevel) {
		return getTypeIndexesPerLevel().get(nestingLevel);
	}

	private Map<Integer, Integer> getTypeIndexesPerLevel() {
		if (this.typeIndexesPerLevel == null) {
			this.typeIndexesPerLevel = new HashMap<>(4);
		}
		return this.typeIndexesPerLevel;
	}
}

• isOptional 方法

        isOptional 方法用于判断当前参数是否为 Optional，及其是否为 Optional 属性或使用 Nullable 注解进行修饰，即该属性是否可以为空；

public class MethodParameter {
	public boolean isOptional() {
		return (getParameterType() == Optional.class || hasNullableAnnotation() ||
				(KotlinDetector.isKotlinReflectPresent() &&
						KotlinDetector.isKotlinType(getContainingClass()) &&
						KotlinDelegate.isOptional(this)));
	}
}

        hasNullableAnnotation 方法用于判断当前属性是否使用 Nullable 注解进行修饰；         

public class MethodParameter {
	private boolean hasNullableAnnotation() {
		for (Annotation ann : getParameterAnnotations()) {
			if ("Nullable".equals(ann.annotationType().getSimpleName())) {
				return true;
			}
		}
		return false;
	}
}

• getParameterType 方法

        getParameterType 方法在 parameterType 参数不为 null 时直接返回该值，否则在 container 属性为 executable 属性中所在类时，直接使用 ResolvableType 的 forMethodParameter 获取对应参数对应类型并为 paramType 属性赋值，若 paramType 属性还为 null 时，则会将 paramType 属性值更新为 computeParameterType 执行结果并返回该值；

public class MethodParameter {
	public Class<?> getParameterType() {
		Class<?> paramType = this.parameterType;
		if (paramType != null) {
			return paramType;
		}
		if (getContainingClass() != getDeclaringClass()) {
			paramType = ResolvableType.forMethodParameter(this, null, 1).resolve();
		}
		if (paramType == null) {
			paramType = computeParameterType();
		}
		this.parameterType = paramType;
		return paramType;
	}
}

        computeParameterType 在 parameterIndex 不小于 0 时直接获取 executable 属性对应索引处元素值，否则在关联 Method 对象为 null 时，直接返回 void 类对象，在 getContainingClass 方法执行结果为 KotlinType 时返回 KotlinDelegate 类的 getReturnType 方法执行结果，在上述条件都不满足时则返回 Method 对象的返回类型；

public class MethodParameter {
	private Class<?> computeParameterType() {
		if (this.parameterIndex < 0) {
			Method method = getMethod();
			if (method == null) {
				return void.class;
			}
			if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(getContainingClass())) {
				return KotlinDelegate.getReturnType(method);
			}
			return method.getReturnType();
		}
		return this.executable.getParameterTypes()[this.parameterIndex];
	}
}

• getGenericParameterType 方法

        getGenericParameterType 方法在 genericParameterType 属性不为 null 时直接返回该值，否则根据 parameterIndex 属性值来判断怎么为 genericParameterType 属性赋值，在该属性值小于 0 时，即方法返回值，getMethod 方法结果若为 null 则直接将值赋为 void Class 对象，否则根据外部方法类是否为 KotlinType 时选择将 genericParameterType 属性值更新为 KotlinDelegate 类的 getGenericReturnType 方法执行结果还是 method 对象的 getGenericReturnType 方法执行结果；在 parameterIndex 属性值不小于 0 时，即方法形参，首先获取 executable 属性的所有参数的 Type 对象数组，在 executable 属性为构造方法，executable 属性所属类为内部类且 genericParameterTypes 数组大小比 executable 的参数数量少一个时，获取 parameterIndex - 1 处的对应元素，否则直接获取对应元素值，但在处理后的索引值大于 genericParameterTypes 的总容量时会直接将其值更新为 computeParameterType 值；

public class MethodParameter {
	public Type getGenericParameterType() {
		Type paramType = this.genericParameterType;
		if (paramType == null) {
			if (this.parameterIndex < 0) {
				Method method = getMethod();
				paramType = (method != null ?
						(KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(getContainingClass()) ?
						KotlinDelegate.getGenericReturnType(method) : method.getGenericReturnType()) : void.class);
			}
			else {
				Type[] genericParameterTypes = this.executable.getGenericParameterTypes();
				int index = this.parameterIndex;
				if (this.executable instanceof Constructor &&
						ClassUtils.isInnerClass(this.executable.getDeclaringClass()) &&
						genericParameterTypes.length == this.executable.getParameterCount() - 1) {
					index = this.parameterIndex - 1;
				}
				paramType = (index >= 0 && index < genericParameterTypes.length ?
						genericParameterTypes[index] : computeParameterType());
			}
			this.genericParameterType = paramType;
		}
		return paramType;
	}
}

• getNestedParameterType 方法

        getNestedParameterType 方法则是根据 nestingLevel 属性值的大小来决定具体返回值，在该属性值不大于 1 时直接返回 getParameterType 方法的执行结果；否则首先将 type 局部变量值初始化为 getGenericParameterType 方法执行结果，并从 2 开始对深度进行遍历直到将 type 属性值更新为实际内部嵌套参数类型对象，在该值为 Class 对象时直接返回该值，在其为 ParameterizedType 值时则获取获取其实际对象类型并返回，否则直接返回 Object 类型的 Class 对象；

public class MethodParameter {
	public Class<?> getNestedParameterType() {
		if (this.nestingLevel > 1) {
			Type type = getGenericParameterType();
			for (int i = 2; i <= this.nestingLevel; i++) {
				if (type instanceof ParameterizedType) {
					Type[] args = ((ParameterizedType) type).getActualTypeArguments();
					Integer index = getTypeIndexForLevel(i);
					type = args[index != null ? index : args.length - 1];
				}
				// TODO: Object.class if unresolvable
			}
			if (type instanceof Class) {
				return (Class<?>) type;
			}
			else if (type instanceof ParameterizedType) {
				Type arg = ((ParameterizedType) type).getRawType();
				if (arg instanceof Class) {
					return (Class<?>) arg;
				}
			}
			return Object.class;
		}
		else {
			return getParameterType();
		}
	}
}

        getNestedGenericParameterType 方法的执行逻辑几乎与 getNestedParameterType 方法一致，因此这里就不做过多介绍了；

public class MethodParameter {
	public Type getNestedGenericParameterType() {
		if (this.nestingLevel > 1) {
			Type type = getGenericParameterType();
			for (int i = 2; i <= this.nestingLevel; i++) {
				if (type instanceof ParameterizedType) {
					Type[] args = ((ParameterizedType) type).getActualTypeArguments();
					Integer index = getTypeIndexForLevel(i);
					type = args[index != null ? index : args.length - 1];
				}
			}
			return type;
		}
		else {
			return getGenericParameterType();
		}
	}
}

• getNestedParameterType 方法

        getNestedParameterType 方法在 parameterAnnotations 为 null 时，通过 executable 的 getParameterAnnotations 方法获取所有方法属性注解，并将 parameterIndex 属性对应的注解数组保存到 parameterAnnotations 属性中，并在最后返回该属性值；

public class MethodParameter {
	public Annotation[] getParameterAnnotations() {
		Annotation[] paramAnns = this.parameterAnnotations;
		if (paramAnns == null) {
			Annotation[][] annotationArray = this.executable.getParameterAnnotations();
			int index = this.parameterIndex;
			if (this.executable instanceof Constructor &&
					ClassUtils.isInnerClass(this.executable.getDeclaringClass()) &&
					annotationArray.length == this.executable.getParameterCount() - 1) {
				// Bug in javac in JDK <9: annotation array excludes enclosing instance parameter
				// for inner classes, so access it with the actual parameter index lowered by 1
				index = this.parameterIndex - 1;
			}
			paramAnns = (index >= 0 && index < annotationArray.length ?
					adaptAnnotationArray(annotationArray[index]) : EMPTY_ANNOTATION_ARRAY);
			this.parameterAnnotations = paramAnns;
		}
		return paramAnns;
	}
}

        getParameterAnnotation 方法用于获取方法指定类型的注解，属性上不存在该类型的属性则直接返回 null； 

public class MethodParameter {
	@Nullable
	public <A extends Annotation> A getParameterAnnotation(Class<A> annotationType) {
		Annotation[] anns = getParameterAnnotations();
		for (Annotation ann : anns) {
			if (annotationType.isInstance(ann)) {
				return (A) ann;
			}
		}
		return null;
	}
}

• getNestedParameterType 方法

        getParameterName 方法在 parameterIndex 小于 0，即返回参数时直接返回 null，而在 parameterNameDiscoverer 属性为 null 时，通过其的 getParameterNames 方法获取 executable 属性的参数名数组，若获取到的参数名数组不为 null 时则会将 parameterIndex 对应位置处的参数名保存到 parameterName 属性中，并在最后将 parameterNameDiscoverer 值置为 null 同时返回 parameterName 属性值；

public class MethodParameter {
	@Nullable
	public String getParameterName() {
		if (this.parameterIndex < 0) {
			return null;
		}
		ParameterNameDiscoverer discoverer = this.parameterNameDiscoverer;
		if (discoverer != null) {
			String[] parameterNames = null;
			if (this.executable instanceof Method) {
				parameterNames = discoverer.getParameterNames((Method) this.executable);
			}
			else if (this.executable instanceof Constructor) {
				parameterNames = discoverer.getParameterNames((Constructor<?>) this.executable);
			}
			if (parameterNames != null) {
				this.parameterName = parameterNames[this.parameterIndex];
			}
			this.parameterNameDiscoverer = null;
		}
		return this.parameterName;
	}
}

3）静态方法

• forExecutable 方法

        forExecutable 方法在 executable 参数为 Method 或 Constructor 对象时直接使用其与 parameterIndex 参数调用构造方法创建 MethodParameter 对象并返回，否则直接抛出异常；

public class MethodParameter {
	public static MethodParameter forExecutable(Executable executable, int parameterIndex) {
		if (executable instanceof Method) {
			return new MethodParameter((Method) executable, parameterIndex);
		}
		else if (executable instanceof Constructor) {
			return new MethodParameter((Constructor<?>) executable, parameterIndex);
		}
		else {
			throw new IllegalArgumentException("Not a Method/Constructor: " + executable);
		}
	}
}

•  forParameter 方法

        forParameter 方法直接使用 parameter 参数对应的 Executable 对象及 findParameterIndex 方法的执行结果执行 forExecutable 方法并返回；

public class MethodParameter {
	public static MethodParameter forParameter(Parameter parameter) {
		return forExecutable(parameter.getDeclaringExecutable(), findParameterIndex(parameter));
	}
}

        findParameterIndex 通过两次寻找 parameter 参数对应的 Executable 对象中与其想等参数值来获取对应的参数索引，若经历了两次遍历还未找到则直接抛出异常；

public class MethodParameter {
	protected static int findParameterIndex(Parameter parameter) {
		Executable executable = parameter.getDeclaringExecutable();
		Parameter[] allParams = executable.getParameters();
		// Try first with identity checks for greater performance.
		for (int i = 0; i < allParams.length; i++) {
			if (parameter == allParams[i]) {
				return i;
			}
		}
		// Potentially try again with object equality checks in order to avoid race
		// conditions while invoking java.lang.reflect.Executable.getParameters().
		for (int i = 0; i < allParams.length; i++) {
			if (parameter.equals(allParams[i])) {
				return i;
			}
		}
		throw new IllegalArgumentException("Given parameter [" + parameter +
				"] does not match any parameter in the declaring executable");
	}
}

1.7.3 属性及构造方法

1）属性变量

        DependencyDescriptor 类拥有多个标识当前方法的属性，如用于存储所在类的 containingClass 属性、用于存储方法名的 methodName 属性、用于存储参数类型数组的 parameterTypes 属性及分别用于保存参数索引与嵌套层级的 parameterIndex 与 nestingLevel 参数；同时由于可以通过方法进行注入，因此其也拥有两个标识当前属性字段的属性，即字段名 fieldName 与最后一个保存其所在类的 declaringClass 属性；除了上述属性之外还有四个通用属性，为是否必须注入的 required 标识、是否拥有强烈注入意愿的 eager 属性以及最后用于类型解析的 resolvableType 与 typeDescriptor 属性。

public class DependencyDescriptor extends InjectionPoint implements Serializable {

	private final Class<?> declaringClass;

	@Nullable
	private String methodName;

	@Nullable
	private Class<?>[] parameterTypes;

	private int parameterIndex;

	@Nullable
	private String fieldName;

	private final boolean required;

	private final boolean eager;

	private int nestingLevel = 1;

	@Nullable
	private Class<?> containingClass;

	@Nullable
	private transient volatile ResolvableType resolvableType;

	@Nullable
	private transient volatile TypeDescriptor typeDescriptor;
}

2）构造方法

        DependencyDescriptor 类中的第一类构造方法是使用 MethodParameter 类型参数创建对象，除该参数之外还有 required 与 eager 两个参数，若方法为传入 eager 参数时直接将其置为 true；

public class DependencyDescriptor extends InjectionPoint implements Serializable {
	public DependencyDescriptor(MethodParameter methodParameter, boolean required) {
		this(methodParameter, required, true);
	}

	public DependencyDescriptor(MethodParameter methodParameter, boolean required, boolean eager) {
		super(methodParameter);

		this.declaringClass = methodParameter.getDeclaringClass();
		if (methodParameter.getMethod() != null) {
			this.methodName = methodParameter.getMethod().getName();
		}
		this.parameterTypes = methodParameter.getExecutable().getParameterTypes();
		this.parameterIndex = methodParameter.getParameterIndex();
		this.containingClass = methodParameter.getContainingClass();
		this.required = required;
		this.eager = eager;
	}
}

         第二类构造方法则使用 Field 类型参数创建对象，剩余 required 与 eager 两个参数规则与第一类参数一致；

public class DependencyDescriptor extends InjectionPoint implements Serializable {
	public DependencyDescriptor(Field field, boolean required) {
		this(field, required, true);
	}

	public DependencyDescriptor(Field field, boolean required, boolean eager) {
		super(field);

		this.declaringClass = field.getDeclaringClass();
		this.fieldName = field.getName();
		this.required = required;
		this.eager = eager;
	}
}

          第三类构造方法则使用 DependencyDescriptor 类型参数创建对象，直接将属性值初始化为 original 参数对应属性值；

public class DependencyDescriptor extends InjectionPoint implements Serializable {
	public DependencyDescriptor(DependencyDescriptor original) {
		super(original);

		this.declaringClass = original.declaringClass;
		this.methodName = original.methodName;
		this.parameterTypes = original.parameterTypes;
		this.parameterIndex = original.parameterIndex;
		this.fieldName = original.fieldName;
		this.containingClass = original.containingClass;
		this.required = original.required;
		this.eager = original.eager;
		this.nestingLevel = original.nestingLevel;
	}
}

1.7.4 类方法

1）isRequired 方法

        isRequired 方法在 required 属性为 false 时直接返回 false，否则判断 field 属性是否为 null，在其为 null 时直接返回 methodParameter 属性的对应参数是否不是 Optional 对象，否则则会判断该字段是否不为 Optional 对象或使用 Nullable 注解进行修饰。

public class DependencyDescriptor extends InjectionPoint implements Serializable {
	public boolean isRequired() {
		if (!this.required) {
			return false;
		}

		if (this.field != null) {
			return !(this.field.getType() == Optional.class || hasNullableAnnotation() ||
					(KotlinDetector.isKotlinReflectPresent() &&
							KotlinDetector.isKotlinType(this.field.getDeclaringClass()) &&
							KotlinDelegate.isNullable(this.field)));
		}
		else {
			return !obtainMethodParameter().isOptional();
		}
	}
}

2）increaseNestingLevel 方法

        increaseNestingLevel 方法在首先将 nestingLevel 属性 +1 同时将 resolvableType 属性置为空，同时在 methodParameter 属性不为 null 时调用其 nested 方法将方法参数嵌套层数也 +1并更新该属性。

public class DependencyDescriptor extends InjectionPoint implements Serializable {
	public void increaseNestingLevel() {
		this.nestingLevel++;
		this.resolvableType = null;
		if (this.methodParameter != null) {
			this.methodParameter = this.methodParameter.nested();
		}
	}
}

3）setContainingClass 方法

        setContainingClass 方法在将 containingClass 属性更新为 containingClass 参数值的同时将 resolvableType 属性置为 null，并在 methodParameter 属性不为空时调用 withContainingClass 方法设置相关参数并更新该属性。

public class DependencyDescriptor extends InjectionPoint implements Serializable {
	public void setContainingClass(Class<?> containingClass) {
		this.containingClass = containingClass;
		this.resolvableType = null;
		if (this.methodParameter != null) {
			this.methodParameter = this.methodParameter.withContainingClass(containingClass);
		}
	}
}

4）getResolvableType 方法

        getResolvableType 方法首先在 resolvableType 属性为空时为其进行赋值，若 field 属性不为空，则使用 field、nestingLevel 以及 containingClass 三个属性创建 ResolvableType 对象并为该属性赋值， 否则直接使用 obtainMethodParameter 方法执行结果创建 ResolvableType 对象来赋值，在赋值完成后直接返回 resolvableType 属性值。

public class DependencyDescriptor extends InjectionPoint implements Serializable {
	public ResolvableType getResolvableType() {
		ResolvableType resolvableType = this.resolvableType;
		if (resolvableType == null) {
			resolvableType = (this.field != null ?
					ResolvableType.forField(this.field, this.nestingLevel, this.containingClass) :
					ResolvableType.forMethodParameter(obtainMethodParameter()));
			this.resolvableType = resolvableType;
		}
		return resolvableType;
	}
}

5）getTypeDescriptor 方法

        getTypeDescriptor 方法与 getResolvableType 方法一样都是在对应属性不为 null 时对其进行赋值，随后返回相关属性值，即 typeDescriptor 属性；同样也是根据 field 属性是否为空来确定创建 TypeDescriptor 对象的逻辑，在其不为空时也是使用 field、nestingLevel 以及 containingClass 三个属性创建， 否则也使用 obtainMethodParameter 方法执行结果来创建。

public class DependencyDescriptor extends InjectionPoint implements Serializable {
	public TypeDescriptor getTypeDescriptor() {
		TypeDescriptor typeDescriptor = this.typeDescriptor;
		if (typeDescriptor == null) {
			typeDescriptor = (this.field != null ?
					new TypeDescriptor(getResolvableType(), getDependencyType(), getAnnotations()) :
					new TypeDescriptor(obtainMethodParameter()));
			this.typeDescriptor = typeDescriptor;
		}
		return typeDescriptor;
	}
}

6）fallbackMatchAllowed 方法

        fallbackMatchAllowed 方法默认直接返回 false，而在 forFallbackMatch 方法中使用当前对象创建的 DependencyDescriptor 对象，则会重写其 fallbackMatchAllowed 方法使得其返回值改为 true。

public class DependencyDescriptor extends InjectionPoint implements Serializable {
	public boolean fallbackMatchAllowed() {
		return false;
	}

	public DependencyDescriptor forFallbackMatch() {
		return new DependencyDescriptor(this) {
			@Override
			public boolean fallbackMatchAllowed() {
				return true;
			}
		};
	}
}

7）getDependencyType 方法

        getDependencyType 方法在 field 属性为 null 时直接返回 obtainMethodParameter 方法结果的关联 Type，否则根据 nestingLevel 属性获取对应嵌套字段类型值。

public class DependencyDescriptor extends InjectionPoint implements Serializable {
	public Class<?> getDependencyType() {
		if (this.field != null) {
			if (this.nestingLevel > 1) {
				Type type = this.field.getGenericType();
				for (int i = 2; i <= this.nestingLevel; i++) {
					if (type instanceof ParameterizedType) {
						Type[] args = ((ParameterizedType) type).getActualTypeArguments();
						type = args[args.length - 1];
					}
				}
				if (type instanceof Class) {
					return (Class<?>) type;
				}
				else if (type instanceof ParameterizedType) {
					Type arg = ((ParameterizedType) type).getRawType();
					if (arg instanceof Class) {
						return (Class<?>) arg;
					}
				}
				return Object.class;
			}
			else {
				return this.field.getType();
			}
		}
		else {
			return obtainMethodParameter().getNestedParameterType();
		}
	}
}

1.8 ResolvableType 类

1.8.1 属性及构造方法

1）常量

        ResolvableType 类拥有三个常量值，NONE 存储的是空类型对象，EMPTY_TYPES_ARRAY 则是空 ResolvableType 对象数组，而 cache 则是已完成类型封装的缓存；

public class ResolvableType implements Serializable {

	public static final ResolvableType NONE = new ResolvableType(EmptyType.INSTANCE, null, null, 0);

	private static final ResolvableType[] EMPTY_TYPES_ARRAY = new ResolvableType[0];

	private static final ConcurrentReferenceHashMap<ResolvableType, ResolvableType> cache =
			new ConcurrentReferenceHashMap<>(256);
}

2）属性变量

        由于 ResolvableType 类是用于封装Java类型以提供对超类、接口及泛型参数的访问，因此其将类型相关属性包括类对象值、Type 类型值、父类解析对象、接口解析对象数组、泛型类型解析对象及数组的元素类型解析对象等都保存了下来；与此同时由于其还可以标识方法参数或属性字段，因此其还提供了对其操作的 typeProvider 与 variableResolver 两个属性； 

public class ResolvableType implements Serializable {

	private final Type type;

	@Nullable
	private final TypeProvider typeProvider;

	@Nullable
	private final VariableResolver variableResolver;

	@Nullable
	private final ResolvableType componentType;

	@Nullable
	private final Integer hash;

	@Nullable
	private Class<?> resolved;

	@Nullable
	private volatile ResolvableType superType;

	@Nullable
	private volatile ResolvableType[] interfaces;

	@Nullable
	private volatile ResolvableType[] generics;
}

3）构造方法

        ResolvableType 拥有多个构造方法除了将所有入参值保存到对应属性中之外还会在必要时分别将 hash 或 resolved 属性值分别初始化为 calculateHashCode 方法执行结果或 resolveClass 方法执行结果； 

public class ResolvableType implements Serializable {
	private ResolvableType(
			Type type, @Nullable TypeProvider typeProvider, @Nullable VariableResolver variableResolver) {

		this.type = type;
		this.typeProvider = typeProvider;
		this.variableResolver = variableResolver;
		this.componentType = null;
		this.hash = calculateHashCode();
		this.resolved = null;
	}

	private ResolvableType(Type type, @Nullable TypeProvider typeProvider,
			@Nullable VariableResolver variableResolver, @Nullable Integer hash) {

		this.type = type;
		this.typeProvider = typeProvider;
		this.variableResolver = variableResolver;
		this.componentType = null;
		this.hash = hash;
		this.resolved = resolveClass();
	}

	private ResolvableType(Type type, @Nullable TypeProvider typeProvider,
			@Nullable VariableResolver variableResolver, @Nullable ResolvableType componentType) {

		this.type = type;
		this.typeProvider = typeProvider;
		this.variableResolver = variableResolver;
		this.componentType = componentType;
		this.hash = null;
		this.resolved = resolveClass();
	}

	private ResolvableType(@Nullable Class<?> clazz) {
		this.resolved = (clazz != null ? clazz : Object.class);
		this.type = this.resolved;
		this.typeProvider = null;
		this.variableResolver = null;
		this.componentType = null;
		this.hash = null;
	}
}

        calculateHashCode 使用 type、typeProvider、variableResolver 及 componentType 四个属性来对对象 hash 值进行计算并返回；

public class ResolvableType implements Serializable {
	private int calculateHashCode() {
		int hashCode = ObjectUtils.nullSafeHashCode(this.type);
		if (this.typeProvider != null) {
			hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.typeProvider.getType());
		}
		if (this.variableResolver != null) {
			hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.variableResolver.getSource());
		}
		if (this.componentType != null) {
			hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.componentType);
		}
		return hashCode;
	}
}

        resolveClass 在 type 属性值为 EmptyType 类的 INSTANCE 常量时直接返回 null，在其为 Class 对象时将其转化为 Class 对象然后返回、在其为 GenericArrayType 对象时则获取其内部元素的类型并返回，若 type 属性值不满足上述所有条件，则在执行完 resolveType 方法后对其结果执行 resolve 方法并返回；

public class ResolvableType implements Serializable {
	@Nullable
	private Class<?> resolveClass() {
		if (this.type == EmptyType.INSTANCE) {
			return null;
		}
		if (this.type instanceof Class) {
			return (Class<?>) this.type;
		}
		if (this.type instanceof GenericArrayType) {
			Class<?> resolvedComponent = getComponentType().resolve();
			return (resolvedComponent != null ? Array.newInstance(resolvedComponent, 0).getClass() : null);
		}
		return resolveType().resolve();
	}
}

         resolveType 在 type 属性值为 ParameterizedType 对象时，直接使用其内部类型及 variableResolver 属性创建 ResolvableType 对象并返回；在其为 WildcardType 对象时，首先尝试获取其上限，未获取时则会尝试获取其下限，随后使用获取到的类型值与 variableResolver 属性创建 ResolvableType 对象并返回；在其为 TypeVariable 对象时，若 variableResolver 属性不为 null 时，则会执行其 resolveVariable 方法对其属性进行解析，若解析结果不为 null 则直接返回结果，否则使用 type 属性所有上限值执行 resolveBounds 方法与 variableResolver 属性创建 ResolvableType 对象并返回；最后在上述所有条件都不满足时则直接返回 NONE 常量值；

public class ResolvableType implements Serializable {
	ResolvableType resolveType() {
		if (this.type instanceof ParameterizedType) {
			return forType(((ParameterizedType) this.type).getRawType(), this.variableResolver);
		}
		if (this.type instanceof WildcardType) {
			Type resolved = resolveBounds(((WildcardType) this.type).getUpperBounds());
			if (resolved == null) {
				resolved = resolveBounds(((WildcardType) this.type).getLowerBounds());
			}
			return forType(resolved, this.variableResolver);
		}
		if (this.type instanceof TypeVariable) {
			TypeVariable<?> variable = (TypeVariable<?>) this.type;
			if (this.variableResolver != null) {
				ResolvableType resolved = this.variableResolver.resolveVariable(variable);
				if (resolved != null) {
					return resolved;
				}
			}
			return forType(resolveBounds(variable.getBounds()), this.variableResolver);
		}
		return NONE;
	}

	@Nullable
	public Class<?> resolve() {
		return this.resolved;
	}
}

        resolveBounds 在 bounds 参数没有任何元素或其第一个元素为 Object 时直接返回 null，否则会返回其第一个元素值； 

public class ResolvableType implements Serializable {
	@Nullable
	private Type resolveBounds(Type[] bounds) {
		if (bounds.length == 0 || bounds[0] == Object.class) {
			return null;
		}
		return bounds[0];
	}
}

1.8.2 类方法

1）getType 方法

        getType 方法使用 SerializableTypeWrapper 的 unwrap 方法对 type 属性进行解封装并返回。

public class ResolvableType implements Serializable {
	public Type getType() {
		return SerializableTypeWrapper.unwrap(this.type);
	}
}

2）getRawClass 方法

        getRawClass 方法在 type 与 resolved 属性想等时直接返回 resolved 属性值；否则在 type 属性为 ParameterizedType 对象时直接返回其实际类型，否则直接返回 type 属性值；

public class ResolvableType implements Serializable {
	@Nullable
	public Class<?> getRawClass() {
		if (this.type == this.resolved) {
			return this.resolved;
		}
		Type rawType = this.type;
		if (rawType instanceof ParameterizedType) {
			rawType = ((ParameterizedType) rawType).getRawType();
		}
		return (rawType instanceof Class ? (Class<?>) rawType : null);
	}
}

3）toClass 方法

        toClass 方法在 resolved 属性不为 null 时直接返回该属性值，否则返回 Object Class 对象；

public class ResolvableType implements Serializable {
	public Class<?> toClass() {
		return resolve(Object.class);
	}

	public Class<?> resolve(Class<?> fallback) {
		return (this.resolved != null ? this.resolved : fallback);
	}
}

4）isInstance 方法

        isInstance 方法用于判断当前类是否为 obj 参数的实例，即是否为 obj 属性对应类的子类；

public class ResolvableType implements Serializable {
	public boolean isInstance(@Nullable Object obj) {
		return (obj != null && isAssignableFrom(obj.getClass()));
	}
}

5）isAssignableFrom 方法

        isAssignableFrom 方法首先对 other 参数进行非空验证并在该参数或当前对象有一个为 NONE 值时直接返回 false；随后在当前对象为数组时直接返回其元素是否为 other 参数的子类，同时在 matchedBefore 参数不为 null 且其关联类型与 other 参数的类型一致时直接返回 true；随后使用 WildcardBounds 类获取当前对象与 other 参数的泛型通配符并对其进行判断并返回；之后在 type 属性值为 TypeVariable 对象时依次使用本对象的 variableResolver 属性、other 的 variableResolver 属性及 resolve 方法为 ourResolved 局部变量进行赋值，若该值为 variableResolver 属性解析出的结果会将 exactMatch 变量置为 false，若从 other 变量的 variableResolver 变量解析出的则会将 checkGenerics 变量置为 false；随后若 exactMatch 为 true 且 ourResolved 变量值与 other 参数解析出的对象不同或 exactMatch 为 false 且 ourResolved 变量值不为 other 参数解析出的对象的父类时直接返回 false；最后若 checkGenerics 为 true 时判断当前对象与 other 参数中是否存在不匹配的泛型对象，若存在直接返回 false，否则返回 true；

public class ResolvableType implements Serializable {
	public boolean isAssignableFrom(Class<?> other) {
		return isAssignableFrom(forClass(other), null);
	}

	public boolean isAssignableFrom(ResolvableType other) {
		return isAssignableFrom(other, null);
	}

	private boolean isAssignableFrom(ResolvableType other, @Nullable Map<Type, Type> matchedBefore) {
		Assert.notNull(other, "ResolvableType must not be null");

		if (this == NONE || other == NONE) {
			return false;
		}

		if (isArray()) {
			return (other.isArray() && getComponentType().isAssignableFrom(other.getComponentType()));
		}

		if (matchedBefore != null && matchedBefore.get(this.type) == other.type) {
			return true;
		}

		WildcardBounds ourBounds = WildcardBounds.get(this);
		WildcardBounds typeBounds = WildcardBounds.get(other);

		if (typeBounds != null) {
			return (ourBounds != null && ourBounds.isSameKind(typeBounds) &&
					ourBounds.isAssignableFrom(typeBounds.getBounds()));
		}

		if (ourBounds != null) {
			return ourBounds.isAssignableFrom(other);
		}

		boolean exactMatch = (matchedBefore != null);  
		boolean checkGenerics = true;
		Class<?> ourResolved = null;
		if (this.type instanceof TypeVariable) {
			TypeVariable<?> variable = (TypeVariable<?>) this.type;
			if (this.variableResolver != null) {
				ResolvableType resolved = this.variableResolver.resolveVariable(variable);
				if (resolved != null) {
					ourResolved = resolved.resolve();
				}
			}
			if (ourResolved == null) {
				if (other.variableResolver != null) {
					ResolvableType resolved = other.variableResolver.resolveVariable(variable);
					if (resolved != null) {
						ourResolved = resolved.resolve();
						checkGenerics = false;
					}
				}
			}
			if (ourResolved == null) {
				exactMatch = false;
			}
		}
		if (ourResolved == null) {
			ourResolved = resolve(Object.class);
		}
		Class<?> otherResolved = other.toClass();

		if (exactMatch ? !ourResolved.equals(otherResolved) : !ClassUtils.isAssignable(ourResolved, otherResolved)) {
			return false;
		}

		if (checkGenerics) {
			ResolvableType[] ourGenerics = getGenerics();
			ResolvableType[] typeGenerics = other.as(ourResolved).getGenerics();
			if (ourGenerics.length != typeGenerics.length) {
				return false;
			}
			if (matchedBefore == null) {
				matchedBefore = new IdentityHashMap<>(1);
			}
			matchedBefore.put(this.type, other.type);
			for (int i = 0; i < ourGenerics.length; i++) {
				if (!ourGenerics[i].isAssignableFrom(typeGenerics[i], matchedBefore)) {
					return false;
				}
			}
		}

		return true;
	}
}

6）getComponentType 方法

        getComponentType 方法首先也是在当前对象为 NONE 时直接返回 NONE 常量值，在 componentType 属性不为 null 时也直接返回该属性值，在 type 属性为 Class 对象时直接使用其内部元素 Type 类型对象与 variableResolver 属性值创建 ResolvableType 对象并返回，在 type 为 GenericArrayType 对象时则会使用 type 属性的 getGenericComponentType 方法的执行结果与  variableResolver 属性值创建 ResolvableType 对象并返回，否则直接执行 resolveType 方法同时对其执行 getComponentType 方法并返回；

public class ResolvableType implements Serializable {
    public ResolvableType getComponentType() {
		if (this == NONE) {
			return NONE;
		}
		if (this.componentType != null) {
			return this.componentType;
		}
		if (this.type instanceof Class) {
			Class<?> componentType = ((Class<?>) this.type).getComponentType();
			return forType(componentType, this.variableResolver);
		}
		if (this.type instanceof GenericArrayType) {
			return forType(((GenericArrayType) this.type).getGenericComponentType(), this.variableResolver);
		}
		return resolveType().getComponentType();
	}
}

7）as 方法

        as 方法首先也是在当前对象为 NONE 时直接返回 NONE 常量值，在 resolved 属性不为 null 或 resolved 与 type 参数想等时直接返回当前对象；随后对 getInterfaces 方法的执行结果中所有元素全部执行 as 方法查询其中结果不为 NONE 的结果并直接返回，否则对 getSuperType 方法执行 as 方法并返回。

public class ResolvableType implements Serializable {
	public ResolvableType asCollection() {
		return as(Collection.class);
	}

	public ResolvableType asMap() {
		return as(Map.class);
	}

	public ResolvableType as(Class<?> type) {
		if (this == NONE) {
			return NONE;
		}
		Class<?> resolved = resolve();
		if (resolved == null || resolved == type) {
			return this;
		}
		for (ResolvableType interfaceType : getInterfaces()) {
			ResolvableType interfaceAsType = interfaceType.as(type);
			if (interfaceAsType != NONE) {
				return interfaceAsType;
			}
		}
		return getSuperType().as(type);
	}
}

        getInterfaces 方法在 resolve 方法执行结果为 null 时直接返回 EMPTY_TYPES_ARRAY 常量值；随后在 interfaces 属性值不为 null 时直接返回该属性值，否则调用 forType 方法将当前对象的所有借口对象转换为 ResolvableType 对象并保存到 interfaces 属性中并在完成后返回该属性值；

public class ResolvableType implements Serializable {
	public ResolvableType[] getInterfaces() {
		Class<?> resolved = resolve();
		if (resolved == null) {
			return EMPTY_TYPES_ARRAY;
		}
		ResolvableType[] interfaces = this.interfaces;
		if (interfaces == null) {
			Type[] genericIfcs = resolved.getGenericInterfaces();
			interfaces = new ResolvableType[genericIfcs.length];
			for (int i = 0; i < genericIfcs.length; i++) {
				interfaces[i] = forType(genericIfcs[i], this);
			}
			this.interfaces = interfaces;
		}
		return interfaces;
	}
}

        getSuperType 方法也是在 resolve 方法执行结果为 null 时直接返回 EMPTY_TYPES_ARRAY 常量值；随后在当前对象不存在父类时直接返回 NONE ，最后在 superType 属性为 null 时，使用当前对象的父类对象与当前对象创建 ResolvableType 对象为 superType 属性赋值并返回；若上述流程抛出任何异常则直接返回 NONE 常量值。

public class ResolvableType implements Serializable {
	public ResolvableType getSuperType() {
		Class<?> resolved = resolve();
		if (resolved == null) {
			return NONE;
		}
		try {
			Type superclass = resolved.getGenericSuperclass();
			if (superclass == null) {
				return NONE;
			}
			ResolvableType superType = this.superType;
			if (superType == null) {
				superType = forType(superclass, this);
				this.superType = superType;
			}
			return superType;
		}
		catch (TypeNotPresentException ex) {
			return NONE;
		}
	}
}

8）getGenerics 方法

        hasGenerics 方法直接返回 getGenerics 方法执行结果是否为空。

public class ResolvableType implements Serializable {
	public boolean hasGenerics() {
		return (getGenerics().length > 0);
	}
}

        isEntirelyUnresolvable 方法在当前对象为 NONE 常量时直接返回 false，否则返回 getGenerics 方法执行结果，即当前对象所拥有的泛型数组中是否存在 isUnresolvableTypeVariable 与 isWildcardWithoutBounds 方法执行结果全不为 false 的元素。

public class ResolvableType implements Serializable {
	boolean isEntirelyUnresolvable() {
		if (this == NONE) {
			return false;
		}
		ResolvableType[] generics = getGenerics();
		for (ResolvableType generic : generics) {
			if (!generic.isUnresolvableTypeVariable() && !generic.isWildcardWithoutBounds()) {
				return false;
			}
		}
		return true;
	}
}

        isUnresolvableTypeVariable 方法在 type 属性不是 TypeVariable 对象时直接返回 false；否则在 variableResolver 属性为 null 时也会直接返回 false，随后通过判断 variableResolver 对 type 属性的 resolveVariable 方法执行结果是否为 null 或其 isUnresolvableTypeVariable 方法执行结果是否为 true 来判断是否返回 true；

public class ResolvableType implements Serializable {
	private boolean isUnresolvableTypeVariable() {
		if (this.type instanceof TypeVariable) {
			if (this.variableResolver == null) {
				return true;
			}
			TypeVariable<?> variable = (TypeVariable<?>) this.type;
			ResolvableType resolved = this.variableResolver.resolveVariable(variable);
			if (resolved == null || resolved.isUnresolvableTypeVariable()) {
				return true;
			}
		}
		return false;
	}
}

        isWildcardWithoutBounds 方法则是判断关联类型是否拥有泛型通配符；其在 type 属性不为 WildcardType 对象时直接返回 false，否则在 getLowerBounds 方法执行结果不为空数组时判断 getUpperBounds 结果是否为空数组或其唯一元素是否为 Object Class 对象并返回；

public class ResolvableType implements Serializable {
	private boolean isWildcardWithoutBounds() {
		if (this.type instanceof WildcardType) {
			WildcardType wt = (WildcardType) this.type;
			if (wt.getLowerBounds().length == 0) {
				Type[] upperBounds = wt.getUpperBounds();
				if (upperBounds.length == 0 || (upperBounds.length == 1 && Object.class == upperBounds[0])) {
					return true;
				}
			}
		}
		return false;
	}
}

        getGeneric 方法获取 indexes 参数中最后一个元素对应的泛型对象，若该参数值为空则直接返回第一个泛型对象，若不存在则直接返回 NONE 常量值； 

public class ResolvableType implements Serializable {
	public ResolvableType getGeneric(@Nullable int... indexes) {
		ResolvableType[] generics = getGenerics();
		if (indexes == null || indexes.length == 0) {
			return (generics.length == 0 ? NONE : generics[0]);
		}
		ResolvableType generic = this;
		for (int index : indexes) {
			generics = generic.getGenerics();
			if (index < 0 || index >= generics.length) {
				return NONE;
			}
			generic = generics[index];
		}
		return generic;
	}
}

        getGenerics 方法在当前对象为 NONE 常量值时直接返回 EMPTY_TYPES_ARRAY 常量值，在 generics 属性值不为 null 时直接返回该属性值，否则会根据 type 属性值类型为 generics 属性赋值；在其为 Class 对象时，将其所有泛型对象转化为 ResolvableType 对象并保存到 generics 属性中；在其为 ParameterizedType 属性时，将其实际类型参数数组转换为 ResolvableType 数组并保存到 generics 属性中；否则将 generics 属性值更新为 resolveType 方法结果的 getGenerics 执行结果；最后则返回 getGenerics 属性值。

public class ResolvableType implements Serializable {
	public ResolvableType[] getGenerics() {
		if (this == NONE) {
			return EMPTY_TYPES_ARRAY;
		}
		ResolvableType[] generics = this.generics;
		if (generics == null) {
			if (this.type instanceof Class) {
				Type[] typeParams = ((Class<?>) this.type).getTypeParameters();
				generics = new ResolvableType[typeParams.length];
				for (int i = 0; i < generics.length; i++) {
					generics[i] = ResolvableType.forType(typeParams[i], this);
				}
			}
			else if (this.type instanceof ParameterizedType) {
				Type[] actualTypeArguments = ((ParameterizedType) this.type).getActualTypeArguments();
				generics = new ResolvableType[actualTypeArguments.length];
				for (int i = 0; i < actualTypeArguments.length; i++) {
					generics[i] = forType(actualTypeArguments[i], this.variableResolver);
				}
			}
			else {
				generics = resolveType().getGenerics();
			}
			this.generics = generics;
		}
		return generics;
	}
}

9）resolveGenerics 方法

        resolveGenerics 方法将当前对象泛型对象转化为 Class 类型数组并返回，值得注意的是，若方法传入了 fallback 参数则会将其中不存的元素替换为该值，否则不存在的值直接使用 null。

public class ResolvableType implements Serializable {
	public Class<?>[] resolveGenerics() {
		ResolvableType[] generics = getGenerics();
		Class<?>[] resolvedGenerics = new Class<?>[generics.length];
		for (int i = 0; i < generics.length; i++) {
			resolvedGenerics[i] = generics[i].resolve();
		}
		return resolvedGenerics;
	}

	public Class<?>[] resolveGenerics(Class<?> fallback) {
		ResolvableType[] generics = getGenerics();
		Class<?>[] resolvedGenerics = new Class<?>[generics.length];
		for (int i = 0; i < generics.length; i++) {
			resolvedGenerics[i] = generics[i].resolve(fallback);
		}
		return resolvedGenerics;
	}

	@Nullable
	public Class<?> resolveGeneric(int... indexes) {
		return getGeneric(indexes).resolve();
	}
}

10）resolveVariable 方法

        resolveVariable 方法在 type 属性值为 TypeVariable 对象时，直接使用 variable 参数值对 resolveType 方法结果执行 resolveVariable 方法并返回；在其为 ParameterizedType 对象时则会判断 resolve 方法结果的所有相关泛型数组中是否存在与 variable 参数同名元素，若存在则使用该泛型对应实际类型与 variableResolver 属性创建 ResolvableType 对象并返回，否则返回当前类型所属类型创建的 ResolvableType 对象的 resolveVariable 方法执行结果；在 type 属性值为 WildcardType 对象时，则会对 resolveType 方法执行结果执行 resolveVariable 方法并在其结果不为空时直接返回；否则在 variableResolver 属性为空时直接返回 null，反之对 variable 参数执行 variableResolver 属性的 resolveVariable 方法并返回其结果；

public class ResolvableType implements Serializable {
	@Nullable
	private ResolvableType resolveVariable(TypeVariable<?> variable) {
		if (this.type instanceof TypeVariable) {
			return resolveType().resolveVariable(variable);
		}
		if (this.type instanceof ParameterizedType) {
			ParameterizedType parameterizedType = (ParameterizedType) this.type;
			Class<?> resolved = resolve();
			if (resolved == null) {
				return null;
			}
			TypeVariable<?>[] variables = resolved.getTypeParameters();
			for (int i = 0; i < variables.length; i++) {
				if (ObjectUtils.nullSafeEquals(variables[i].getName(), variable.getName())) {
					Type actualType = parameterizedType.getActualTypeArguments()[i];
					return forType(actualType, this.variableResolver);
				}
			}
			Type ownerType = parameterizedType.getOwnerType();
			if (ownerType != null) {
				return forType(ownerType, this.variableResolver).resolveVariable(variable);
			}
		}
		if (this.type instanceof WildcardType) {
			ResolvableType resolved = resolveType().resolveVariable(variable);
			if (resolved != null) {
				return resolved;
			}
		}
		if (this.variableResolver != null) {
			return this.variableResolver.resolveVariable(variable);
		}
		return null;
	}
}

1.8.3 静态方法

1）forClass 方法

        forClass 方法使用 clazz 参数创建 ResolvableType 对象并返回。

public class ResolvableType implements Serializable {
	public static ResolvableType forClass(@Nullable Class<?> clazz) {
		return new ResolvableType(clazz);
	}
}

        双参数 forClass 方法首先会对 baseType 参数进行非空验证，验证通过后首先使用 forType 方法创建 implementationClass 参数的 ResolvableType 封装对象并执行其 as 方法查询其实现的 baseType 对象并在其不为 NONE 是查询到的 ResolvableType 封装对象创建 ResolvableType 对象并返回，否则直接返回 NONE 常量值。

public class ResolvableType implements Serializable {
	public static ResolvableType forClass(Class<?> baseType, Class<?> implementationClass) {
		Assert.notNull(baseType, "Base type must not be null");
		ResolvableType asType = forType(implementationClass).as(baseType);
		return (asType == NONE ? forType(baseType) : asType);
	}
}

2）forRawClass 方法

        forRawClass 方法也使用 clazz 参数创建 ResolvableType 对象并返回；但与 forClass 方法不同的是，其返回的 ResolvableType 对象会对 getGenerics 与两个 isAssignableFrom 方法进行重写，其中 getGenerics 方法直接返回 EMPTY_TYPES_ARRAY 空 ResolvableType 对象数组；而 isAssignableFrom 方法则直接使用 ClassUtils 类的 isAssignable 方法判断 clazz 是否为 other 参数的子类。

public class ResolvableType implements Serializable {
	public static ResolvableType forRawClass(@Nullable Class<?> clazz) {
		return new ResolvableType(clazz) {
			@Override
			public ResolvableType[] getGenerics() {
				return EMPTY_TYPES_ARRAY;
			}
			@Override
			public boolean isAssignableFrom(Class<?> other) {
				return (clazz == null || ClassUtils.isAssignable(clazz, other));
			}
			@Override
			public boolean isAssignableFrom(ResolvableType other) {
				Class<?> otherClass = other.resolve();
				return (otherClass != null && (clazz == null || ClassUtils.isAssignable(clazz, otherClass)));
			}
		};
	}
}

3）forClassWithGenerics 方法

        ResolvableType 类拥有两个不同的 forClassWithGenerics 方法，其相似处为第一个参数都是 Class 类型的 clazz 参数，差异在第二个参数，第一个方法中第二个参数为可变 Class 类型数组，第二个方法则为可变 ResolvableType 对象数组参数。

        第一个 forClassWithGenerics 方法首先对 clazz 与 generics 参数进行非空验证，通过验证后则将可变 Class 对象数组转化为 ResolvableType 对象数组并联合 clazz 参数执行第二个方法并返回；

public class ResolvableType implements Serializable {
	public static ResolvableType forClassWithGenerics(Class<?> clazz, Class<?>... generics) {
		Assert.notNull(clazz, "Class must not be null");
		Assert.notNull(generics, "Generics array must not be null");
		ResolvableType[] resolvableGenerics = new ResolvableType[generics.length];
		for (int i = 0; i < generics.length; i++) {
			resolvableGenerics[i] = forClass(generics[i]);
		}
		return forClassWithGenerics(clazz, resolvableGenerics);
	}
}

         第二个 forClassWithGenerics 方法首先也会对入参进行非空验证，随后获取 clazz 参数的泛型对象数组，在其元素数量与 generics 参数元素数量不一致时直接抛出异常，最后将 generics 参数中的 TypeVariable 类型替换 clazz 参数的泛型元素；然后使用 clazz 参数与替换完成的类型对象数组创建 ParameterizedType 对象，并使用该对象与使用泛型数组与 generics 参数创建的 TypeVariablesVariableResolver 对象一起执行 forType 方法创建 ResolvableType 对象并返回；

public class ResolvableType implements Serializable {
	public static ResolvableType forClassWithGenerics(Class<?> clazz, ResolvableType... generics) {
		Assert.notNull(clazz, "Class must not be null");
		Assert.notNull(generics, "Generics array must not be null");
		TypeVariable<?>[] variables = clazz.getTypeParameters();
		Assert.isTrue(variables.length == generics.length, "Mismatched number of generics specified");

		Type[] arguments = new Type[generics.length];
		for (int i = 0; i < generics.length; i++) {
			ResolvableType generic = generics[i];
			Type argument = (generic != null ? generic.getType() : null);
			arguments[i] = (argument != null && !(argument instanceof TypeVariable) ? argument : variables[i]);
		}

		ParameterizedType syntheticType = new SyntheticParameterizedType(clazz, arguments);
		return forType(syntheticType, new TypeVariablesVariableResolver(variables, generics));
	}
}

4）forInstance 方法

        forInstance 方法首先对 instance 参数进行非空验证，通过验证后若该参数为 ResolvableTypeProvider 对象，则通过其 getResolvableType 方法获取其关联的 ResolvableType 对象，若存在则直接返回该对象，否则则使用该参数的 Class 对象执行 forClass 方法创建 ResolvableType 对象并返回；

public class ResolvableType implements Serializable {
	public static ResolvableType forInstance(Object instance) {
		Assert.notNull(instance, "Instance must not be null");
		if (instance instanceof ResolvableTypeProvider) {
			ResolvableType type = ((ResolvableTypeProvider) instance).getResolvableType();
			if (type != null) {
				return type;
			}
		}
		return ResolvableType.forClass(instance.getClass());
	}
}

5）forField 方法

        所有的 forField 方法首先都会对 field 参数进行非空验证，然后调用 forType 方法创建 ResolvableType 对象并返回，其中第一个参数直接使用 null，第二参数使用的是 field 参数创建的封装 FieldTypeProvider 对象，第三个参数在方法拥有以 implementation 开头的参数时，则使用该对象的 asVariableResolver 方法执行结果，否则也是 null；在方法传入了 nestingLevel 参数时则会通过 getNested 方法获取对应的嵌套对象。

public class ResolvableType implements Serializable {
	public static ResolvableType forField(Field field) {
		Assert.notNull(field, "Field must not be null");
		return forType(null, new FieldTypeProvider(field), null);
	}

	public static ResolvableType forField(Field field, Class<?> implementationClass) {
		Assert.notNull(field, "Field must not be null");
		ResolvableType owner = forType(implementationClass).as(field.getDeclaringClass());
		return forType(null, new FieldTypeProvider(field), owner.asVariableResolver());
	}

	public static ResolvableType forField(Field field, @Nullable ResolvableType implementationType) {
		Assert.notNull(field, "Field must not be null");
		ResolvableType owner = (implementationType != null ? implementationType : NONE);
		owner = owner.as(field.getDeclaringClass());
		return forType(null, new FieldTypeProvider(field), owner.asVariableResolver());
	}

	public static ResolvableType forField(Field field, int nestingLevel) {
		Assert.notNull(field, "Field must not be null");
		return forType(null, new FieldTypeProvider(field), null).getNested(nestingLevel);
	}

	public static ResolvableType forField(Field field, int nestingLevel, @Nullable Class<?> implementationClass) {
		Assert.notNull(field, "Field must not be null");
		ResolvableType owner = forType(implementationClass).as(field.getDeclaringClass());
		return forType(null, new FieldTypeProvider(field), owner.asVariableResolver()).getNested(nestingLevel);
	}
}

6）forConstructorParameter 方法

        forConstructorParameter 方法首先对 constructor 参数进行非空验证，随后使用所有入参值创建 MethodParameter 对象并执行 forMethodParameter 方法创建 ResolvableType 对象并返回。

public class ResolvableType implements Serializable {
	public static ResolvableType forConstructorParameter(Constructor<?> constructor, int parameterIndex) {
		Assert.notNull(constructor, "Constructor must not be null");
		return forMethodParameter(new MethodParameter(constructor, parameterIndex));
	}

	public static ResolvableType forConstructorParameter(Constructor<?> constructor, int parameterIndex,
			Class<?> implementationClass) {

		Assert.notNull(constructor, "Constructor must not be null");
		MethodParameter methodParameter = new MethodParameter(constructor, parameterIndex, implementationClass);
		return forMethodParameter(methodParameter);
	}
}

7）forMethodReturnType 方法

        forMethodReturnType 方法首先对 method 参数进行非空验证，随后使用所有入参值及 -1 创建 MethodParameter 对象并执行 forMethodParameter 方法创建 ResolvableType 对象并返回。

public class ResolvableType implements Serializable {
	public static ResolvableType forMethodReturnType(Method method) {
		Assert.notNull(method, "Method must not be null");
		return forMethodParameter(new MethodParameter(method, -1));
	}

	public static ResolvableType forMethodReturnType(Method method, Class<?> implementationClass) {
		Assert.notNull(method, "Method must not be null");
		MethodParameter methodParameter = new MethodParameter(method, -1, implementationClass);
		return forMethodParameter(methodParameter);
	}
}

8）forMethodParameter 方法

        没有 MethodParameter 类型参数的 forMethodParameter 方法首先对 method 参数进行非空验证，随后使用所有入参值创建 MethodParameter 对象并执行 forMethodParameter 方法创建 ResolvableType 对象并返回。

public class ResolvableType implements Serializable {
	public static ResolvableType forMethodParameter(Method method, int parameterIndex) {
		Assert.notNull(method, "Method must not be null");
		return forMethodParameter(new MethodParameter(method, parameterIndex));
	}

	public static ResolvableType forMethodParameter(Method method, int parameterIndex, Class<?> implementationClass) {
		Assert.notNull(method, "Method must not be null");
		MethodParameter methodParameter = new MethodParameter(method, parameterIndex, implementationClass);
		return forMethodParameter(methodParameter);
	}
}

        带 MethodParameter 类型参数的 forMethodParameter 方法首先对 methodParameter 参数进行非空验证，最后也是执行 forType 方法创建 ResolvableType 对象并返回，若存在 targetType 参数则将第一个参数设置为该参数值，否则将其置为 null，同时使用 methodParameter 参数创建 MethodParameterTypeProvider 对象作为其第二个参数，第三个参数则使用 methodParameter 参数的外部类获取的 VariableResolver 对象参数。

public class ResolvableType implements Serializable {
	public static ResolvableType forMethodParameter(MethodParameter methodParameter) {
		return forMethodParameter(methodParameter, (Type) null);
	}

	public static ResolvableType forMethodParameter(MethodParameter methodParameter,
			@Nullable ResolvableType implementationType) {

		Assert.notNull(methodParameter, "MethodParameter must not be null");
		implementationType = (implementationType != null ? implementationType :
				forType(methodParameter.getContainingClass()));
		ResolvableType owner = implementationType.as(methodParameter.getDeclaringClass());
		return forType(null, new MethodParameterTypeProvider(methodParameter), owner.asVariableResolver()).
				getNested(methodParameter.getNestingLevel(), methodParameter.typeIndexesPerLevel);
	}

	public static ResolvableType forMethodParameter(MethodParameter methodParameter, @Nullable Type targetType) {
		Assert.notNull(methodParameter, "MethodParameter must not be null");
		return forMethodParameter(methodParameter, targetType, methodParameter.getNestingLevel());
	}

	static ResolvableType forMethodParameter(
			MethodParameter methodParameter, @Nullable Type targetType, int nestingLevel) {

		ResolvableType owner = forType(methodParameter.getContainingClass()).as(methodParameter.getDeclaringClass());
		return forType(targetType, new MethodParameterTypeProvider(methodParameter), owner.asVariableResolver()).
				getNested(nestingLevel, methodParameter.typeIndexesPerLevel);
	}
}

9）forArrayComponent 方法

        forArrayComponent 方法首先对 componentType 参数进行非空验证，随后使用其元素的 Class 对象及 componentType 参数创建 ResolvableType 对象并返回。

public class ResolvableType implements Serializable {
	public static ResolvableType forArrayComponent(ResolvableType componentType) {
		Assert.notNull(componentType, "Component type must not be null");
		Class<?> arrayClass = Array.newInstance(componentType.resolve(), 0).getClass();
		return new ResolvableType(arrayClass, null, null, componentType);
	}
}

10）forType 方法

        forType 方法在 type 为空且 typeProvider 参数不为空时，将 type 参数值初始化为 typeProvider 参数提供的对象，若 type 参数还为 null，则直接返回 NONE 常量值；随后在 type 参数为 CLass 对象时，使用 type、typeProvider、variableResolver 参数及 null 值创建 ResolvableType 对象并返回；最后使用 type、typeProvider 与 variableResolver 参数创建 ResolvableType 对象将其保存到缓存中并返回该值。

public class ResolvableType implements Serializable {
	public static ResolvableType forType(@Nullable Type type) {
		return forType(type, null, null);
	}

	public static ResolvableType forType(@Nullable Type type, @Nullable ResolvableType owner) {
		VariableResolver variableResolver = null;
		if (owner != null) {
			variableResolver = owner.asVariableResolver();
		}
		return forType(type, variableResolver);
	}


	public static ResolvableType forType(ParameterizedTypeReference<?> typeReference) {
		return forType(typeReference.getType(), null, null);
	}

	static ResolvableType forType(@Nullable Type type, @Nullable VariableResolver variableResolver) {
		return forType(type, null, variableResolver);
	}

	static ResolvableType forType(
			@Nullable Type type, @Nullable TypeProvider typeProvider, @Nullable VariableResolver variableResolver) {

		if (type == null && typeProvider != null) {
			type = SerializableTypeWrapper.forTypeProvider(typeProvider);
		}
		if (type == null) {
			return NONE;
		}

		if (type instanceof Class) {
			return new ResolvableType(type, typeProvider, variableResolver, (ResolvableType) null);
		}

		cache.purgeUnreferencedEntries();

		ResolvableType resultType = new ResolvableType(type, typeProvider, variableResolver);
		ResolvableType cachedType = cache.get(resultType);
		if (cachedType == null) {
			cachedType = new ResolvableType(type, typeProvider, variableResolver, resultType.hash);
			cache.put(cachedType, cachedType);
		}
		resultType.resolved = cachedType.resolved;
		return resultType;
	}
}

1.8.4 VariableResolver 内部类

1）VariableResolver 接口

        VariableResolver 接口向外提供对 TypeVariable 对象的解析功能，其向外提供了 getSource 与 resolveVariable 两个方法，其中 getSource 方法用于获取解析源对象，resolveVariable 方法则用于指定变量的解析；

public class ResolvableType implements Serializable {
	interface VariableResolver extends Serializable {

		Object getSource();

		@Nullable
		ResolvableType resolveVariable(TypeVariable<?> variable);
	}
}

2）DefaultVariableResolver 类

        DefaultVariableResolver 类为 ResolvableType 类的通用解析类，其只有一个 ResolvableType 类型参数及直接为该属性赋值的构造方法，其 resolveVariable 方法直接调用 source 属性的 resolveVariable 方法并返回；

public class ResolvableType implements Serializable {
	private static class DefaultVariableResolver implements VariableResolver {

		private final ResolvableType source;

		DefaultVariableResolver(ResolvableType resolvableType) {
			this.source = resolvableType;
		}

		@Override
		@Nullable
		public ResolvableType resolveVariable(TypeVariable<?> variable) {
			return this.source.resolveVariable(variable);
		}

		@Override
		public Object getSource() {
			return this.source;
		}
	}
}

3）TypeVariablesVariableResolver 类

        TypeVariablesVariableResolver 类为提供对泛型对象的解析，其拥有 variables（泛型源 TypeVariable 对象数组）与 generics（泛型 ResolvableType 对象封装数组）两个属性，以及一个直接为这两个属性赋值的构造方法；其 resolveVariable 方法查询 variables 数组中与 variable 参数相等的元素索引值并返回 generics 属性对应元素值，而 getSource 方法直接返回 generics 属性值；

public class ResolvableType implements Serializable {
	private static class TypeVariablesVariableResolver implements VariableResolver {

		private final TypeVariable<?>[] variables;

		private final ResolvableType[] generics;

		public TypeVariablesVariableResolver(TypeVariable<?>[] variables, ResolvableType[] generics) {
			this.variables = variables;
			this.generics = generics;
		}

		@Override
		@Nullable
		public ResolvableType resolveVariable(TypeVariable<?> variable) {
			TypeVariable<?> variableToCompare = SerializableTypeWrapper.unwrap(variable);
			for (int i = 0; i < this.variables.length; i++) {
				TypeVariable<?> resolvedVariable = SerializableTypeWrapper.unwrap(this.variables[i]);
				if (ObjectUtils.nullSafeEquals(resolvedVariable, variableToCompare)) {
					return this.generics[i];
				}
			}
			return null;
		}

		@Override
		public Object getSource() {
			return this.generics;
		}
	}
}

1.8.5 SyntheticParameterizedType 内部类

1）属性及构造方法

        SyntheticParameterizedType 类拥有两个不同属性，rawType 属性为类对象而 typeArguments 属性则是对应的泛型对象数组，其构造方法也是直接将对应属性初始化为对应参数值；

public class ResolvableType implements Serializable {
	private static final class SyntheticParameterizedType implements ParameterizedType, Serializable {

		private final Type rawType;

		private final Type[] typeArguments;

		public SyntheticParameterizedType(Type rawType, Type[] typeArguments) {
			this.rawType = rawType;
			this.typeArguments = typeArguments;
		}
	}
}

2）类方法

        SyntheticParameterizedType 类的 getOwnerType、getRawType 与 getActualTypeArguments 方法分别返回 null、rawType 及 typeArguments 属性值；getTypeName 方法则返回 rawType 属性名 + typeArguments 泛型数组转化出的以 <> 包装的逗号分隔的泛型名字符串；

public class ResolvableType implements Serializable {
	private static final class SyntheticParameterizedType implements ParameterizedType, Serializable {
		@Override
		public String getTypeName() {
			String typeName = this.rawType.getTypeName();
			if (this.typeArguments.length > 0) {
				StringJoiner stringJoiner = new StringJoiner(", ", "<", ">");
				for (Type argument : this.typeArguments) {
					stringJoiner.add(argument.getTypeName());
				}
				return typeName + stringJoiner;
			}
			return typeName;
		}

		@Override
		@Nullable
		public Type getOwnerType() {
			return null;
		}

		@Override
		public Type getRawType() {
			return this.rawType;
		}

		@Override
		public Type[] getActualTypeArguments() {
			return this.typeArguments;
		}
	}
}

1.8.6 WildcardBounds 内部类

1）属性及构造方法

        WildcardBounds 内部类拥有保存泛型通配符类型的 kind 属性与保存泛型类型封装 ResolvableType 对象数组的 bounds 属性；其构造方法也将对应属性值初始化为对应参数值；

public class ResolvableType implements Serializable {
	private static class WildcardBounds {

		private final Kind kind;

		private final ResolvableType[] bounds;

		public WildcardBounds(Kind kind, ResolvableType[] bounds) {
			this.kind = kind;
			this.bounds = bounds;
		}
        
        enum Kind {UPPER, LOWER}
	}
}

2）类方法

        isSameKind 方法直接返回 bounds 的 kind 属性是否与当前 kind 属性想等；

public class ResolvableType implements Serializable {
	private static class WildcardBounds {
		public boolean isSameKind(WildcardBounds bounds) {
			return this.kind == bounds.kind;
		}
	}
}

         isAssignableFrom 方法则会判断 types 数组是否存在不满足 bounds 属性中的元素中是否不满足 isAssignable 方法的元素，存在时直接返回 false，否则直接返回 true；

public class ResolvableType implements Serializable {
	private static class WildcardBounds {
		public boolean isAssignableFrom(ResolvableType... types) {
			for (ResolvableType bound : this.bounds) {
				for (ResolvableType type : types) {
					if (!isAssignable(bound, type)) {
						return false;
					}
				}
			}
			return true;
		}
	}
}

        isAssignable 方法在 kind 属性为 UPPER 时，返回 source 属性是否为 from 的子类，否则返回 from 属性是否为 source 的子类；

public class ResolvableType implements Serializable {
	private static class WildcardBounds {
		private boolean isAssignable(ResolvableType source, ResolvableType from) {
			return (this.kind == Kind.UPPER ? source.isAssignableFrom(from) : from.isAssignableFrom(source));
		}

		public ResolvableType[] getBounds() {
			return this.bounds;
		}
	}
}

3）静态方法

        SyntheticParameterizedType 类只有一个 get 静态方法；get 方法递归调用 type 参数的 resolveType 方法直到其值不为 WildcardType 对象或为 NONE 常量值，在其为 NONE 常量值则直接返回 null；随后将递归获取的 ResolvableType 对象的 type 属性强转为 WildcardType 对象并根据其 getLowerBounds 方法执行结果来确定 Kind 值，同时将其对应 Bounds 数组保存到 bounds 变量中并将其转化为 ResolvableType 对象数组，并使用 kind 值与转化出的 ResolvableType 对象数组创建 WildcardBounds 对象并返回；

public class ResolvableType implements Serializable {
	private static class WildcardBounds {
		@Nullable
		public static WildcardBounds get(ResolvableType type) {
			ResolvableType resolveToWildcard = type;
			while (!(resolveToWildcard.getType() instanceof WildcardType)) {
				if (resolveToWildcard == NONE) {
					return null;
				}
				resolveToWildcard = resolveToWildcard.resolveType();
			}
			WildcardType wildcardType = (WildcardType) resolveToWildcard.type;
			Kind boundsType = (wildcardType.getLowerBounds().length > 0 ? Kind.LOWER : Kind.UPPER);
			Type[] bounds = (boundsType == Kind.UPPER ? wildcardType.getUpperBounds() : wildcardType.getLowerBounds());
			ResolvableType[] resolvableBounds = new ResolvableType[bounds.length];
			for (int i = 0; i < bounds.length; i++) {
				resolvableBounds[i] = ResolvableType.forType(bounds[i], type.variableResolver);
			}
			return new WildcardBounds(boundsType, resolvableBounds);
		}
	}
}

2 SimpleAutowireCandidateResolver 类

        SimpleAutowireCandidateResolver 类仅提供对 bean 定义检查的功能，其用于解析非注解修饰的主动注入候选项；

2.1 常量

        SimpleAutowireCandidateResolver 类只有一个单例 SimpleAutowireCandidateResolver 对象的 INSTANCE 常量。

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	public static final SimpleAutowireCandidateResolver INSTANCE = new SimpleAutowireCandidateResolver();
}

2.2 类方法

2.2.1 isAutowireCandidate 方法

        isAutowireCandidate 方法直接返回 bdHolder 参数中保存的对象注册表是否为主动注入候选对象；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		return bdHolder.getBeanDefinition().isAutowireCandidate();
	}
}

2.2.2 isRequired 方法

        isRequired 方法则返回 descriptor 参数对象是否必须；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	public boolean isRequired(DependencyDescriptor descriptor) {
		return descriptor.isRequired();
	}
}

 2.2.3 hasQualifier 方法

        hasQualifier 方法直接返回 false；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	public boolean hasQualifier(DependencyDescriptor descriptor) {
		return false;
	}
}

2.2.4 getSuggestedValue 方法

        getSuggestedValue 方法直接返回 null；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	@Nullable
	public Object getSuggestedValue(DependencyDescriptor descriptor) {
		return null;
	}
}

2.2.5 getLazyResolutionProxyIfNecessary 方法

        getLazyResolutionProxyIfNecessary 方法也直接返回 null；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	@Nullable
	public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
		return null;
	}
}

2.2.6 cloneIfNecessary 方法

        cloneIfNecessary 方法直接返回当前对象；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	public AutowireCandidateResolver cloneIfNecessary() {
		return this;
	}
}

3 GenericTypeAwareAutowireCandidateResolver 类

        GenericTypeAwareAutowireCandidateResolver 类提供基础自动注入候选对象解析功能，其用于解析泛型候选对象时进行匹配；

3.1 变量

        GenericTypeAwareAutowireCandidateResolver 类只有一个用于保存当前对象工厂的 beanFactory 属性，由于该类实现了 BeanFactoryAware 接口，因此该属性在对象工厂加载完成后调用 setBeanFactory 方法进行赋值。

public class GenericTypeAwareAutowireCandidateResolver extends SimpleAutowireCandidateResolver
		implements BeanFactoryAware, Cloneable {

	@Nullable
	private BeanFactory beanFactory;

	@Override
	public void setBeanFactory(BeanFactory beanFactory) {
		this.beanFactory = beanFactory;
	}

	@Nullable
	protected final BeanFactory getBeanFactory() {
		return this.beanFactory;
	}
}

3.2 类方法

3.2.1 isAutowireCandidate 方法

        isAutowireCandidate 方法在其不满足父类的 isAutowireCandidate 方法时直接返回 false，否则直接返回 checkGenericTypeMatch 方法结果；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		if (!super.isAutowireCandidate(bdHolder, descriptor)) {
			return false;
		}
		return checkGenericTypeMatch(bdHolder, descriptor);
	}
}

        checkGenericTypeMatch 方法在 descriptor 参数关联 type 属性为 Class 对象时直接返回 true，在 bdHolder 参数中保存的注册表对象为 RootBeanDefinition 时，将 targetType 局部变量初始化为其 targetType 属性值；若该属性值为 null 时，会将 cacheType 变量置为 true 并调用 getReturnTypeForFactoryMethod 方法将 targetType 变量值初始化为对象工厂方法的返回值类型；若还是未获取到类型值，则会进一步尝试通过 getResolvedDecoratedDefinition 方法获取 rdb 参数的目标对象注册表，并在其不为 null 时，会将 targetType 变量更新为其 targetType 属性值，但在该变量还为 null 时，则会尝试使用 getReturnTypeForFactoryMethod 方法进一步获取目标对象注册表的方法返回值对象来更新 targetType 变量；

        在上述流程后，若 targetType 变量值依然为 null，则在 beanFactory 属性不为 null 时，直接尝试从其中获取 bdHolder 中保存对象名的 Class 类型对象并在其不为 null时，创建该类型的封装 ResolvableType 对象来为 targetType 变量进行赋值；经过了该逻辑后，若 targetType 变量依然为 null、rbd 参数不为 null、rbd 参数定义的是对象类型 Class 且其没有对象工厂方法名时，在 rbd 参数关联类型不为 FactoryBean 对象时，将 targetType 变量更新为该对象类型；

        在 targetType 变量依然为 null 时直接返回 true，否则在 cacheType 为 true 时直接将 rbd 参数的 targetType 属性更新为 targetType 变量值，随后若 descriptor 支持回退匹配且 targetType 参数是否拥有任何无法解析的泛型或其类型为 Properties 时也直接返回 true；否则直接返回 descriptor 参数关联类型是否为 targetType 变量的父类；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	protected boolean checkGenericTypeMatch(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		ResolvableType dependencyType = descriptor.getResolvableType();
		if (dependencyType.getType() instanceof Class) {
			return true;
		}

		ResolvableType targetType = null;
		boolean cacheType = false;
		RootBeanDefinition rbd = null;
		if (bdHolder.getBeanDefinition() instanceof RootBeanDefinition) {
			rbd = (RootBeanDefinition) bdHolder.getBeanDefinition();
		}
		if (rbd != null) {
			targetType = rbd.targetType;
			if (targetType == null) {
				cacheType = true;
				targetType = getReturnTypeForFactoryMethod(rbd, descriptor);
				if (targetType == null) {
					RootBeanDefinition dbd = getResolvedDecoratedDefinition(rbd);
					if (dbd != null) {
						targetType = dbd.targetType;
						if (targetType == null) {
							targetType = getReturnTypeForFactoryMethod(dbd, descriptor);
						}
					}
				}
			}
		}

		if (targetType == null) {
			if (this.beanFactory != null) {
				Class<?> beanType = this.beanFactory.getType(bdHolder.getBeanName());
				if (beanType != null) {
					targetType = ResolvableType.forClass(ClassUtils.getUserClass(beanType));
				}
			}
			if (targetType == null && rbd != null && rbd.hasBeanClass() && rbd.getFactoryMethodName() == null) {
				Class<?> beanClass = rbd.getBeanClass();
				if (!FactoryBean.class.isAssignableFrom(beanClass)) {
					targetType = ResolvableType.forClass(ClassUtils.getUserClass(beanClass));
				}
			}
		}

		if (targetType == null) {
			return true;
		}
		if (cacheType) {
			rbd.targetType = targetType;
		}
		if (descriptor.fallbackMatchAllowed() &&
				(targetType.hasUnresolvableGenerics() || targetType.resolve() == Properties.class)) {
			return true;
		}
		return dependencyType.isAssignableFrom(targetType);
	}
}

        getReturnTypeForFactoryMethod 方法首先尝试获取 rbd 参数的 factoryMethodReturnType 属性为 returnType 变量赋值；若未获取到，则会通过 rbd 参数的 getResolvedFactoryMethod 方法获取工厂方法对象并在其不为 null 时使用该方法创建 ResolvableType 对象并保存到  returnType 变量中；若 returnType 变量还是为 null，直接返回 null，否则在 returnType 关联 Class 对象为 descriptor 参数的依赖类型的子类时直接返回 Class 对象；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Nullable
	protected ResolvableType getReturnTypeForFactoryMethod(RootBeanDefinition rbd, DependencyDescriptor descriptor) {
		ResolvableType returnType = rbd.factoryMethodReturnType;
		if (returnType == null) {
			Method factoryMethod = rbd.getResolvedFactoryMethod();
			if (factoryMethod != null) {
				returnType = ResolvableType.forMethodReturnType(factoryMethod);
			}
		}
		if (returnType != null) {
			Class<?> resolvedClass = returnType.resolve();
			if (resolvedClass != null && descriptor.getDependencyType().isAssignableFrom(resolvedClass)) {
				return returnType;
			}
		}
		return null;
	}
}

        getResolvedDecoratedDefinition 方法首先获取 rbd 参数保存的目标类型注册表对象，若其不为 null 且 beanFactory 属性为 ConfigurableListableBeanFactory 对象时，并在该属性中存在目标类型对象注册表时，通过其 getMergedBeanDefinition 方法获取其对象注册表对象并在其为 RootBeanDefinition 对象时直接返回该对象注册表，否则直接返回 null；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Nullable
	protected RootBeanDefinition getResolvedDecoratedDefinition(RootBeanDefinition rbd) {
		BeanDefinitionHolder decDef = rbd.getDecoratedDefinition();
		if (decDef != null && this.beanFactory instanceof ConfigurableListableBeanFactory) {
			ConfigurableListableBeanFactory clbf = (ConfigurableListableBeanFactory) this.beanFactory;
			if (clbf.containsBeanDefinition(decDef.getBeanName())) {
				BeanDefinition dbd = clbf.getMergedBeanDefinition(decDef.getBeanName());
				if (dbd instanceof RootBeanDefinition) {
					return (RootBeanDefinition) dbd;
				}
			}
		}
		return null;
	}
}

3.2.2 cloneIfNecessary 方法

        cloneIfNecessary 方法直接返回 Clone 方法执行结果；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	public AutowireCandidateResolver cloneIfNecessary() {
		try {
			return (AutowireCandidateResolver) clone();
		}
		catch (CloneNotSupportedException ex) {
			throw new IllegalStateException(ex);
		}
	}
}

4 QualifierAnnotationAutowireCandidateResolver 类

        QualifierAnnotationAutowireCandidateResolver 类向外提供了基于 Qualifier 注解的自动注入候选对象解析功能；

4.1 变量及构造方法

4.1.1 类变量

        GenericTypeAwareAutowireCandidateResolver 类拥有两个不同的类变量，其中 qualifierTypes 属性用于保存注入限制的 Set 集合，valueAnnotationType 属性则为表达式限制注解类型。

public class GenericTypeAwareAutowireCandidateResolver extends SimpleAutowireCandidateResolver
		implements BeanFactoryAware, Cloneable {
	private final Set<Class<? extends Annotation>> qualifierTypes = new LinkedHashSet<>(2);

	private Class<? extends Annotation> valueAnnotationType = Value.class;
}

4.1.2 构造方法

        GenericTypeAwareAutowireCandidateResolver 类拥有三个构造方法，其中无参构造方法直接将 Qualifier 注解对象与 javax.inject.Qualifier 注解对象全部保存到 qualifierTypes 属性中，值得注意的是，若 javax.inject.Qualifier 注解对象不存在则直接跳过，不会做任何特殊处理；其余两个构造方法都会在参数完成了非空验证后都会将入参值全部保存到 qualifierTypes 属性中。

public class GenericTypeAwareAutowireCandidateResolver extends SimpleAutowireCandidateResolver
		implements BeanFactoryAware, Cloneable {
	public QualifierAnnotationAutowireCandidateResolver() {
		this.qualifierTypes.add(Qualifier.class);
		try {
			this.qualifierTypes.add((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Qualifier",
							QualifierAnnotationAutowireCandidateResolver.class.getClassLoader()));
		}
		catch (ClassNotFoundException ex) {
		}
	}

	public QualifierAnnotationAutowireCandidateResolver(Class<? extends Annotation> qualifierType) {
		Assert.notNull(qualifierType, "'qualifierType' must not be null");
		this.qualifierTypes.add(qualifierType);
	}

	public QualifierAnnotationAutowireCandidateResolver(Set<Class<? extends Annotation>> qualifierTypes) {
		Assert.notNull(qualifierTypes, "'qualifierTypes' must not be null");
		this.qualifierTypes.addAll(qualifierTypes);
	}
}

4.2 类方法

4.2.1 isAutowireCandidate 方法

        isAutowireCandidate 方法只有在其满足父对象的 isAutowireCandidate 条件限制后才会进行当前限制的判断，若不满足父对象的 isAutowireCandidate 方法时直接返回 false；否则首先判断入参值是否满足 checkQualifiers 方法，并在其满足该条件后但不是通过方法参数注入时直接返回 true，而在通过方法参数进行注入时会进一步调用 checkQualifiers 方法验证方法参数是否满足限制，若满足才会返回 true；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		boolean match = super.isAutowireCandidate(bdHolder, descriptor);
		if (match) {
			match = checkQualifiers(bdHolder, descriptor.getAnnotations());
			if (match) {
				MethodParameter methodParam = descriptor.getMethodParameter();
				if (methodParam != null) {
					Method method = methodParam.getMethod();
					if (method == null || void.class == method.getReturnType()) {
						match = checkQualifiers(bdHolder, methodParam.getMethodAnnotations());
					}
				}
			}
		}
		return match;
	}
}

        checkQualifiers 方法在 annotationsToSearch 参数为 null 时直接返回 true；否则寻找 annotationsToSearch 中是否存在当前注解对象及其源注解都不满足限制条件的元素，若存在直接返回 false，否则返回 true；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	protected boolean checkQualifiers(BeanDefinitionHolder bdHolder, Annotation[] annotationsToSearch) {
		if (ObjectUtils.isEmpty(annotationsToSearch)) {
			return true;
		}
		SimpleTypeConverter typeConverter = new SimpleTypeConverter();
		for (Annotation annotation : annotationsToSearch) {
			Class<? extends Annotation> type = annotation.annotationType();
			boolean checkMeta = true;
			boolean fallbackToMeta = false;
			if (isQualifier(type)) {
				if (!checkQualifier(bdHolder, annotation, typeConverter)) {
					fallbackToMeta = true;
				}
				else {
					checkMeta = false;
				}
			}
			if (checkMeta) {
				boolean foundMeta = false;
				for (Annotation metaAnn : type.getAnnotations()) {
					Class<? extends Annotation> metaType = metaAnn.annotationType();
					if (isQualifier(metaType)) {
						foundMeta = true;
						if ((fallbackToMeta && StringUtils.isEmpty(AnnotationUtils.getValue(metaAnn))) ||
								!checkQualifier(bdHolder, metaAnn, typeConverter)) {
							return false;
						}
					}
				}
				if (fallbackToMeta && !foundMeta) {
					return false;
				}
			}
		}
		return true;
	}
}

        isQualifier 方法判断 qualifierTypes 属性中是否拥有 annotationType 参数；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	protected boolean isQualifier(Class<? extends Annotation> annotationType) {
		for (Class<? extends Annotation> qualifierType : this.qualifierTypes) {
			if (annotationType.equals(qualifierType) || annotationType.isAnnotationPresent(qualifierType)) {
				return true;
			}
		}
		return false;
	}
}

         checkQualifier 方法在 bdHolder 参数中的对象没有 annotation 注解且 annotation 参数没有任何属性值时直接返回 false；在 bdHolder 参数中的对象拥有 annotation 注解时将该注解对象保存到 qualifier 变量中，其尝试从 bd 参数及其目标类型上获取 annotion 注解对象并为 targetAnnotation 变量赋值，在赋值完成后 targetAnnotation 变量不为 null 且其值与 annotation 参数想等时直接返回 true；若未返回任何值时对 annotation 参数的所有属性值进行遍历，寻找其中是否存在与其元素的 value 值不想等的元素，若存在直接返回 false，否则在遍历完成后返回 false；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	protected boolean checkQualifier(
			BeanDefinitionHolder bdHolder, Annotation annotation, TypeConverter typeConverter) {

		Class<? extends Annotation> type = annotation.annotationType();
		RootBeanDefinition bd = (RootBeanDefinition) bdHolder.getBeanDefinition();

		AutowireCandidateQualifier qualifier = bd.getQualifier(type.getName());
		if (qualifier == null) {
			qualifier = bd.getQualifier(ClassUtils.getShortName(type));
		}
		if (qualifier == null) {
			Annotation targetAnnotation = getQualifiedElementAnnotation(bd, type);
			if (targetAnnotation == null) {
				targetAnnotation = getFactoryMethodAnnotation(bd, type);
			}
			if (targetAnnotation == null) {
				RootBeanDefinition dbd = getResolvedDecoratedDefinition(bd);
				if (dbd != null) {
					targetAnnotation = getFactoryMethodAnnotation(dbd, type);
				}
			}
			if (targetAnnotation == null) {
				if (getBeanFactory() != null) {
					try {
						Class<?> beanType = getBeanFactory().getType(bdHolder.getBeanName());
						if (beanType != null) {
							targetAnnotation = AnnotationUtils.getAnnotation(ClassUtils.getUserClass(beanType), type);
						}
					}
					catch (NoSuchBeanDefinitionException ex) {
					}
				}
				if (targetAnnotation == null && bd.hasBeanClass()) {
					targetAnnotation = AnnotationUtils.getAnnotation(ClassUtils.getUserClass(bd.getBeanClass()), type);
				}
			}
			if (targetAnnotation != null && targetAnnotation.equals(annotation)) {
				return true;
			}
		}

		Map<String, Object> attributes = AnnotationUtils.getAnnotationAttributes(annotation);
		if (attributes.isEmpty() && qualifier == null) {
			return false;
		}
		for (Map.Entry<String, Object> entry : attributes.entrySet()) {
			String attributeName = entry.getKey();
			Object expectedValue = entry.getValue();
			Object actualValue = null;
			if (qualifier != null) {
				actualValue = qualifier.getAttribute(attributeName);
			}
			if (actualValue == null) {
				actualValue = bd.getAttribute(attributeName);
			}
			if (actualValue == null && attributeName.equals(AutowireCandidateQualifier.VALUE_KEY) &&
					expectedValue instanceof String && bdHolder.matchesName((String) expectedValue)) {
				continue;
			}
			if (actualValue == null && qualifier != null) {
				actualValue = AnnotationUtils.getDefaultValue(annotation, attributeName);
			}
			if (actualValue != null) {
				actualValue = typeConverter.convertIfNecessary(actualValue, expectedValue.getClass());
			}
			if (!expectedValue.equals(actualValue)) {
				return false;
			}
		}
		return true;
	}
}

        getQualifiedElementAnnotation 用于获取 bd 参数关联拥有限定符注解类的 type 参数类型的注解对象；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Nullable
	protected Annotation getQualifiedElementAnnotation(RootBeanDefinition bd, Class<? extends Annotation> type) {
		AnnotatedElement qualifiedElement = bd.getQualifiedElement();
		return (qualifiedElement != null ? AnnotationUtils.getAnnotation(qualifiedElement, type) : null);
	}
}

        getFactoryMethodAnnotation 用于获取 bd 参数关联的对象工厂方法上的 type 参数类型的注解对象；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Nullable
	protected Annotation getFactoryMethodAnnotation(RootBeanDefinition bd, Class<? extends Annotation> type) {
		Method resolvedFactoryMethod = bd.getResolvedFactoryMethod();
		return (resolvedFactoryMethod != null ? AnnotationUtils.getAnnotation(resolvedFactoryMethod, type) : null);
	}
}

4.2.2 isRequired 方法

        isRequired 方法也是在其满足父对象的 isRequired 条件限制后才会判断 descriptor 对象的是否使用 required 属性为 true 的 Autowired 注解进行修饰；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	public boolean isRequired(DependencyDescriptor descriptor) {
		if (!super.isRequired(descriptor)) {
			return false;
		}
		Autowired autowired = descriptor.getAnnotation(Autowired.class);
		return (autowired == null || autowired.required());
	}
}

4.2.3 hasQualifier 方法

        hasQualifier 方法判断 descriptor 参数对象是否使用 qualifierTypes 属性相关注解进行修饰；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	public boolean hasQualifier(DependencyDescriptor descriptor) {
		for (Annotation ann : descriptor.getAnnotations()) {
			if (isQualifier(ann.annotationType())) {
				return true;
			}
		}
		return false;
	}
}

4.2.4 getSuggestedValue 方法

        getSuggestedValue 方法首先尝试从 descriptor 参数的所有注解对象中获取 Value 注解对象的 value 属性值；若无则会尝试从 descriptor 参数关联方法参数中的 Value 注解对象的 value 属性值，最后直接返回获取到的 value 值；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Override
	@Nullable
	public Object getSuggestedValue(DependencyDescriptor descriptor) {
		Object value = findValue(descriptor.getAnnotations());
		if (value == null) {
			MethodParameter methodParam = descriptor.getMethodParameter();
			if (methodParam != null) {
				value = findValue(methodParam.getMethodAnnotations());
			}
		}
		return value;
	}
}

        findValue 方法在 annotationsToSearch 不为 null 时直接查找其中的 valueAnnotationType 类型注解元素对象的属性值，若存在则会返回其中的 value 属性值；否则直接返回 null；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	@Nullable
	protected Object findValue(Annotation[] annotationsToSearch) {
		if (annotationsToSearch.length > 0) {
			AnnotationAttributes attr = AnnotatedElementUtils.getMergedAnnotationAttributes(
					AnnotatedElementUtils.forAnnotations(annotationsToSearch), this.valueAnnotationType);
			if (attr != null) {
				return extractValue(attr);
			}
		}
		return null;
	}
}

        extractValue 用于获取 attr 中的 value 属性值，不存在时直接抛出异常；

public class SimpleAutowireCandidateResolver implements AutowireCandidateResolver {
	protected Object extractValue(AnnotationAttributes attr) {
		Object value = attr.get(AnnotationUtils.VALUE);
		if (value == null) {
			throw new IllegalStateException("Value annotation must have a value attribute");
		}
		return value;
	}
}

5 ContextAnnotationAutowireCandidateResolver 类

        ContextAnnotationAutowireCandidateResolver 类为 AutowireCandidateResolver 接口的完全实现，其扩展了 Lazy 注解懒加载的解析，其只重写了 getLazyResolutionProxyIfNecessary 方法；

        getLazyResolutionProxyIfNecessary 方法在 descriptor 参数为设置延迟加载时直接返回 null，否则通过 buildLazyResolutionProxy 方法创建懒加载代理并返回；

public class ContextAnnotationAutowireCandidateResolver extends QualifierAnnotationAutowireCandidateResolver {
	@Override
	@Nullable
	public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
		return (isLazy(descriptor) ? buildLazyResolutionProxy(descriptor, beanName) : null);
	}
}

        isLazy 方法判断 descriptor 参数关联属性或方法参数是否使用 value 属性为 true 的 Lazy 注解进行修饰；

public class ContextAnnotationAutowireCandidateResolver extends QualifierAnnotationAutowireCandidateResolver {

	protected boolean isLazy(DependencyDescriptor descriptor) {
		for (Annotation ann : descriptor.getAnnotations()) {
			Lazy lazy = AnnotationUtils.getAnnotation(ann, Lazy.class);
			if (lazy != null && lazy.value()) {
				return true;
			}
		}
		MethodParameter methodParam = descriptor.getMethodParameter();
		if (methodParam != null) {
			Method method = methodParam.getMethod();
			if (method == null || void.class == method.getReturnType()) {
				Lazy lazy = AnnotationUtils.getAnnotation(methodParam.getAnnotatedElement(), Lazy.class);
				if (lazy != null && lazy.value()) {
					return true;
				}
			}
		}
		return false;
	}
}

        buildLazyResolutionProxy 方法首先对 beanFactory 属性进行非空验证，随后创建自定义实现的 TargetSource 对象，主要实现了 getTargetClass 与 getTarget 方法，其中 getTargetClass 方法直接获取 descriptor 参数的关联类型 Class 对象，getTarget 方法首先使用内部对象工厂解析目标对象，在未获取到目标对象时，根据 getTargetClass 方法结果，返回对应空对象，若为 Map、List 与 Set 集合对象时返回对应的空集合对象，否则直接抛出异常；否则在解析出的 autowiredBeanNames 集合不为空时，尝试调用 registerDependentBean 方法向对象工厂中注册依赖名，并在完成上述逻辑后，直接返回解析出的目标对象；

        在完成了 TargetSource 对象的创建后，使用该对象及 descriptor 参数的关联依赖类型创建 ProxyFactory 动态代理工厂并在最后返回代理对象；

public class ContextAnnotationAutowireCandidateResolver extends QualifierAnnotationAutowireCandidateResolver {
	protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
		BeanFactory beanFactory = getBeanFactory();
		Assert.state(beanFactory instanceof DefaultListableBeanFactory,
				"BeanFactory needs to be a DefaultListableBeanFactory");
		final DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;

		TargetSource ts = new TargetSource() {
			@Override
			public Class<?> getTargetClass() {
				return descriptor.getDependencyType();
			}
			@Override
			public boolean isStatic() {
				return false;
			}
			@Override
			public Object getTarget() {
				Set<String> autowiredBeanNames = (beanName != null ? new LinkedHashSet<>(1) : null);
				Object target = dlbf.doResolveDependency(descriptor, beanName, autowiredBeanNames, null);
				if (target == null) {
					Class<?> type = getTargetClass();
					if (Map.class == type) {
						return Collections.emptyMap();
					}
					else if (List.class == type) {
						return Collections.emptyList();
					}
					else if (Set.class == type || Collection.class == type) {
						return Collections.emptySet();
					}
					throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(),
							"Optional dependency not present for lazy injection point");
				}
				if (autowiredBeanNames != null) {
					for (String autowiredBeanName : autowiredBeanNames) {
						if (dlbf.containsBean(autowiredBeanName)) {
							dlbf.registerDependentBean(autowiredBeanName, beanName);
						}
					}
				}
				return target;
			}
			@Override
			public void releaseTarget(Object target) {
			}
		};

		ProxyFactory pf = new ProxyFactory();
		pf.setTargetSource(ts);
		Class<?> dependencyType = descriptor.getDependencyType();
		if (dependencyType.isInterface()) {
			pf.addInterface(dependencyType);
		}
		return pf.getProxy(dlbf.getBeanClassLoader());
	}
}

三 InitDestroyAnnotationBeanPostProcessor 类

1 属性

        InitDestroyAnnotationBeanPostProcessor 类用于处理初始化与销毁注解；其中第一个属性为用于标识初始化方法与销毁方法注解类型的 initAnnotationType 与 destroyAnnotationType 属性、还有一个用于标识执行顺序的 order 属性，默认为最大值、用于缓存生命周期元数据的 lifecycleMetadataCache 及一个标识空生命周期元数据对象的 emptyLifecycleMetadata 属性；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {

	private final transient LifecycleMetadata emptyLifecycleMetadata =
			new LifecycleMetadata(Object.class, Collections.emptyList(), Collections.emptyList()) {
				@Override
				public void checkConfigMembers(RootBeanDefinition beanDefinition) {
				}
				@Override
				public void invokeInitMethods(Object target, String beanName) {
				}
				@Override
				public void invokeDestroyMethods(Object target, String beanName) {
				}
				@Override
				public boolean hasDestroyMethods() {
					return false;
				}
			};


	protected transient Log logger = LogFactory.getLog(getClass());

	@Nullable
	private Class<? extends Annotation> initAnnotationType;

	@Nullable
	private Class<? extends Annotation> destroyAnnotationType;

	private int order = Ordered.LOWEST_PRECEDENCE;

	@Nullable
	private final transient Map<Class<?>, LifecycleMetadata> lifecycleMetadataCache = new ConcurrentHashMap<>(256);

	public void setInitAnnotationType(Class<? extends Annotation> initAnnotationType) {
		this.initAnnotationType = initAnnotationType;
	}

	public void setDestroyAnnotationType(Class<? extends Annotation> destroyAnnotationType) {
		this.destroyAnnotationType = destroyAnnotationType;
	}

	public void setOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		return this.order;
	}
}

2 类方法

2.1 postProcessMergedBeanDefinition 方法

         postProcessMergedBeanDefinition 方法在通过 findLifecycleMetadata 方法创建 LifecycleMetadata 对象后并使用 beanDefinition 执行其的 checkConfigMembers 方法向对象注册表中注册初始化与销毁方法；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		LifecycleMetadata metadata = findLifecycleMetadata(beanType);
		metadata.checkConfigMembers(beanDefinition);
	}
}

        findLifecycleMetadata 方法在 lifecycleMetadataCache 缓存为 null 时直接执行 buildLifecycleMetadata 方法创建 LifecycleMetadata 对象并返回，否则首先尝试从该缓存中获取 clazz 对应的元数据，获取到时直接返回缓存对象，否则 buildLifecycleMetadata 方法创建 LifecycleMetadata 对象并保存到 lifecycleMetadataCache 缓存中同时返回；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
		if (this.lifecycleMetadataCache == null) {
			return buildLifecycleMetadata(clazz);
		}
		LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
		if (metadata == null) {
			synchronized (this.lifecycleMetadataCache) {
				metadata = this.lifecycleMetadataCache.get(clazz);
				if (metadata == null) {
					metadata = buildLifecycleMetadata(clazz);
					this.lifecycleMetadataCache.put(clazz, metadata);
				}
				return metadata;
			}
		}
		return metadata;
	}
}

         buildLifecycleMetadata 方法在 clazz 参数没有使用 initAnnotationType 与 destroyAnnotationType 注解进行修饰时直接返回 emptyLifecycleMetadata 空生命周期元数据，然后寻找 clazz 参数及其所有父类中使用 initAnnotationType 与 destroyAnnotationType 注解修饰方法并使用 LifecycleElement 类对其进行封装，最后在查询完毕后，使用 clazz 、查询到的初始化方法与销毁方法封装对象数组创建 LifecycleMetadata 对象并返回；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
		if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(this.initAnnotationType, this.destroyAnnotationType))) {
			return this.emptyLifecycleMetadata;
		}

		List<LifecycleElement> initMethods = new ArrayList<>();
		List<LifecycleElement> destroyMethods = new ArrayList<>();
		Class<?> targetClass = clazz;

		do {
			final List<LifecycleElement> currInitMethods = new ArrayList<>();
			final List<LifecycleElement> currDestroyMethods = new ArrayList<>();

			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
				if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
					LifecycleElement element = new LifecycleElement(method);
					currInitMethods.add(element);
					if (logger.isTraceEnabled()) {
						logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
					}
				}
				if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
					currDestroyMethods.add(new LifecycleElement(method));
					if (logger.isTraceEnabled()) {
						logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
					}
				}
			});

			initMethods.addAll(0, currInitMethods);
			destroyMethods.addAll(currDestroyMethods);
			targetClass = targetClass.getSuperclass();
		}
		while (targetClass != null && targetClass != Object.class);

		return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
				new LifecycleMetadata(clazz, initMethods, destroyMethods));
	}
}

2.2 postProcessBeforeInitialization 方法

         postProcessBeforeInitialization 方法首先通过 findLifecycleMetadata 查询 bean 参数对应的生命周期元数据并调用其 invokeInitMethods 方法执行初始化方法并在执行完成后返回 bean 参数；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
		try {
			metadata.invokeInitMethods(bean, beanName);
		}
		catch (InvocationTargetException ex) {
			throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
		}
		return bean;
	}
}

2.3 postProcessAfterInitialization 方法

         postProcessAfterInitialization 方法不执行任何逻辑直接返回 bean 参数；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}

2.4 postProcessBeforeDestruction 方法

         postProcessBeforeDestruction 方法首先通过 findLifecycleMetadata 查询 bean 参数对应的生命周期元数据并调用其 invokeDestroyMethods 方法执行销毁方法；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	@Override
	public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
		LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
		try {
			metadata.invokeDestroyMethods(bean, beanName);
		}
		catch (InvocationTargetException ex) {
			String msg = "Destroy method on bean with name '" + beanName + "' threw an exception";
			if (logger.isDebugEnabled()) {
				logger.warn(msg, ex.getTargetException());
			}
			else {
				logger.warn(msg + ": " + ex.getTargetException());
			}
		}
		catch (Throwable ex) {
			logger.warn("Failed to invoke destroy method on bean with name '" + beanName + "'", ex);
		}
	}
}

2.5 requiresDestruction 方法

         requiresDestruction 方法获取 bean 参数对应的生命周期元数据并然后其使用拥有销毁方法；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	@Override
	public boolean requiresDestruction(Object bean) {
		return findLifecycleMetadata(bean.getClass()).hasDestroyMethods();
	}
}

3 LifecycleElement 内部类

3.1 属性及构造方法

3.1.1 类属性

         LifecycleElement 类用于封装方法对象，其拥有保存封装 Method 方法对象的 method 属性与方法名标识的 identifier 属性；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private static class LifecycleElement {
		private final Method method;

		private final String identifier;

		public Method getMethod() {
			return this.method;
		}

		public String getIdentifier() {
			return this.identifier;
		}
	}
}

3.1.2 构造方法

         LifecycleElement 类只有一个构造方法，其只有一个 Method 类型参数，在创建过程中首先对 method 参数的参数个数进行空验证，即不为空直接报错；验证通过后首先将 method 属性初始化为 method 参数值，随后在若 mothod 为私有方法时将 identifer 属性初始化为全限定类名 + 方法名，否则直接初始化为方法名；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private static class LifecycleElement {
		public LifecycleElement(Method method) {
			if (method.getParameterCount() != 0) {
				throw new IllegalStateException("Lifecycle method annotation requires a no-arg method: " + method);
			}
			this.method = method;
			this.identifier = (Modifier.isPrivate(method.getModifiers()) ?
					ClassUtils.getQualifiedMethodName(method) : method.getName());
		}
	}
}

3.2 invoke 方法

         invoke 方法直接执行 method 属性的 invoke 方法；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private static class LifecycleElement {
		public void invoke(Object target) throws Throwable {
			ReflectionUtils.makeAccessible(this.method);
			this.method.invoke(target, (Object[]) null);
		}
	}
}

4 LifecycleMetadata 内部类

4.1 属性及构造方法

4.1.1 类属性

        LifecycleMetadata 类用于封装类以向外提供对生命周期元数据的处理，其中 targerClass 属性保存的时封装的 Class 类型对象、initMethods 与 checkedInitMethods 属性分别保存所有初始化方法元数据封装集合与通过验证后的初始化方法元数据封装集合及保存所有销毁方法元数据封装集合与通过验证后的销毁方法元数据封装集合的 destroyMethods 与 checkedDestroyMethods 属性；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private class LifecycleMetadata {

		private final Class<?> targetClass;

		private final Collection<LifecycleElement> initMethods;

		private final Collection<LifecycleElement> destroyMethods;

		@Nullable
		private volatile Set<LifecycleElement> checkedInitMethods;

		@Nullable
		private volatile Set<LifecycleElement> checkedDestroyMethods;
	}
}

4.1.2 构造方法

        LifecycleMetadata 类只有一个分别将 targetClass、initMethods 与 destroyMethods 属性初始化为对应的入参属性值；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private class LifecycleMetadata {
		public LifecycleMetadata(Class<?> targetClass, Collection<LifecycleElement> initMethods,
				Collection<LifecycleElement> destroyMethods) {

			this.targetClass = targetClass;
			this.initMethods = initMethods;
			this.destroyMethods = destroyMethods;
		}
	}
}

4.2 类方法

4.2.1 checkConfigMembers 方法

        checkConfigMembers 方法分别将 beanDefinition 中未注册 initMethods 与 destroyMethods 属性中的元素注册到该对象注册表并保存到 checkedInitMethods 与 checkedDestroyMethods 属性中；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private class LifecycleMetadata {
		public void checkConfigMembers(RootBeanDefinition beanDefinition) {
			Set<LifecycleElement> checkedInitMethods = new LinkedHashSet<>(this.initMethods.size());
			for (LifecycleElement element : this.initMethods) {
				String methodIdentifier = element.getIdentifier();
				if (!beanDefinition.isExternallyManagedInitMethod(methodIdentifier)) {
					beanDefinition.registerExternallyManagedInitMethod(methodIdentifier);
					checkedInitMethods.add(element);
					if (logger.isTraceEnabled()) {
						logger.trace("Registered init method on class [" + this.targetClass.getName() + "]: " + element);
					}
				}
			}
			Set<LifecycleElement> checkedDestroyMethods = new LinkedHashSet<>(this.destroyMethods.size());
			for (LifecycleElement element : this.destroyMethods) {
				String methodIdentifier = element.getIdentifier();
				if (!beanDefinition.isExternallyManagedDestroyMethod(methodIdentifier)) {
					beanDefinition.registerExternallyManagedDestroyMethod(methodIdentifier);
					checkedDestroyMethods.add(element);
					if (logger.isTraceEnabled()) {
						logger.trace("Registered destroy method on class [" + this.targetClass.getName() + "]: " + element);
					}
				}
			}
			this.checkedInitMethods = checkedInitMethods;
			this.checkedDestroyMethods = checkedDestroyMethods;
		}
	}
}

4.2.2 invokeInitMethods 方法

        invokeInitMethods 方法在 checkedInitMethods 属性不为空依次执行所有元素，否则依次执行 initMethods 属性中的所有元素；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private class LifecycleMetadata {
		public void invokeInitMethods(Object target, String beanName) throws Throwable {
			Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
			Collection<LifecycleElement> initMethodsToIterate =
					(checkedInitMethods != null ? checkedInitMethods : this.initMethods);
			if (!initMethodsToIterate.isEmpty()) {
				for (LifecycleElement element : initMethodsToIterate) {
					if (logger.isTraceEnabled()) {
						logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
					}
					element.invoke(target);
				}
			}
		}
	}
}

4.2.3 hasDestroyMethods 方法

        hasDestroyMethods 方法直接返回 checkedDestroyMethods 与 destroyMethods 属性是否全没有任何元素；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private class LifecycleMetadata {
		public boolean hasDestroyMethods() {
			Collection<LifecycleElement> checkedDestroyMethods = this.checkedDestroyMethods;
			Collection<LifecycleElement> destroyMethodsToUse =
					(checkedDestroyMethods != null ? checkedDestroyMethods : this.destroyMethods);
			return !destroyMethodsToUse.isEmpty();
		}
	}
}

四 CommonAnnotationBeanPostProcessor 类

1 属性及构造方法

1.1 常量

        CommonAnnotationBeanPostProcessor 拥有三个常量，其中 webServiceRefClass 属性保存的是 webService 服务声明注解，ejbClass 属性保存的则是 EJB 服务声明注解，最后一个常量为 resourceAnnotationTypes，其保存的则是资源声明注解 set 集合；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {

	@Nullable
	private static final Class<? extends Annotation> webServiceRefClass;

	@Nullable
	private static final Class<? extends Annotation> ejbClass;

	private static final Set<Class<? extends Annotation>> resourceAnnotationTypes = new LinkedHashSet<>(4);
}

        CommonAnnotationBeanPostProcessor 的三个常量都是在静态代码块中进行赋值，其首先分别将 webServiceRefClass 与 ejbClass 常量加载为 javax.xml.ws.WebServiceRef 与 javax.ejb. EJB 注解对象，随后首先向 resourceAnnotationTypes 常量中添加 Resource 对象，随后将加载到的 webServiceRefClass 与 ejbClass 常量值依次添加到 resourceAnnotationTypes 常量中；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	static {
		webServiceRefClass = loadAnnotationType("javax.xml.ws.WebServiceRef");
		ejbClass = loadAnnotationType("javax.ejb.EJB");

		resourceAnnotationTypes.add(Resource.class);
		if (webServiceRefClass != null) {
			resourceAnnotationTypes.add(webServiceRefClass);
		}
		if (ejbClass != null) {
			resourceAnnotationTypes.add(ejbClass);
		}
	}
}

         loadAnnotationType 方法直接尝试加载 name 参数对应类并将其转化为 Annotation 注解类型对象并返回，若未找到 name 对应类时直接返回 null。

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	@Nullable
	private static Class<? extends Annotation> loadAnnotationType(String name) {
		try {
			return (Class<? extends Annotation>)
					ClassUtils.forName(name, CommonAnnotationBeanPostProcessor.class.getClassLoader());
		}
		catch (ClassNotFoundException ex) {
			return null;
		}
	}
}

1.2 类属性

        CommonAnnotationBeanPostProcessor 类的 ignoredResourceTypes 属性用于保存注入时需忽略的类名，fallbackToDefaultTypeMatch 属性则标识是否需要会退匹配注入类型，默认为 true，alwaysUseJndiLookup 属性则是表明检索资源时是否需要从 jndiFactory 中查询 mappedName 对象，jndiFactory、resourceFactory 及 beanFactory 三个对象工厂属性分别保存的是 jndi 对象工厂、资源对象工厂及当前工厂对象，embeddedValueResolver 属性保存的是字符串解析对象，injectionMetadataCache 属性则是注入元数据的缓存；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {

	private final Set<String> ignoredResourceTypes = new HashSet<>(1);

	private boolean fallbackToDefaultTypeMatch = true;

	private boolean alwaysUseJndiLookup = false;

	private transient BeanFactory jndiFactory = new SimpleJndiBeanFactory();

	@Nullable
	private transient BeanFactory resourceFactory;

	@Nullable
	private transient BeanFactory beanFactory;

	@Nullable
	private transient StringValueResolver embeddedValueResolver;

	private final transient Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap<>(256);

	public void ignoreResourceType(String resourceType) {
		Assert.notNull(resourceType, "Ignored resource type must not be null");
		this.ignoredResourceTypes.add(resourceType);
	}

	public void setFallbackToDefaultTypeMatch(boolean fallbackToDefaultTypeMatch) {
		this.fallbackToDefaultTypeMatch = fallbackToDefaultTypeMatch;
	}

	public void setAlwaysUseJndiLookup(boolean alwaysUseJndiLookup) {
		this.alwaysUseJndiLookup = alwaysUseJndiLookup;
	}

	public void setJndiFactory(BeanFactory jndiFactory) {
		Assert.notNull(jndiFactory, "BeanFactory must not be null");
		this.jndiFactory = jndiFactory;
	}

	public void setResourceFactory(BeanFactory resourceFactory) {
		Assert.notNull(resourceFactory, "BeanFactory must not be null");
		this.resourceFactory = resourceFactory;
	}

	@Override
	public void setBeanFactory(BeanFactory beanFactory) {
		Assert.notNull(beanFactory, "BeanFactory must not be null");
		this.beanFactory = beanFactory;
		if (this.resourceFactory == null) {
			this.resourceFactory = beanFactory;
		}
		if (beanFactory instanceof ConfigurableBeanFactory) {
			this.embeddedValueResolver = new EmbeddedValueResolver((ConfigurableBeanFactory) beanFactory);
		}
	}
}

1.3 构造方法

        CommonAnnotationBeanPostProcessor 类只有一个构造方法，其分别将 Ordered.LOWEST_PRECEDENCE - 3、PostConstruct 类型及 PreDestroy 类型保存到 order、initAnnotationType 及 destroyAnnotationType 属性中，并在最后将 javax.xml.ws.WebServiceContext 添加到 ignoredResourceTypes 属性中 ；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	public CommonAnnotationBeanPostProcessor() {
		setOrder(Ordered.LOWEST_PRECEDENCE - 3);
		setInitAnnotationType(PostConstruct.class);
		setDestroyAnnotationType(PreDestroy.class);
		ignoreResourceType("javax.xml.ws.WebServiceContext");
	}
}

        ignoreResourceType 方法在完成了 resourceType 参数的非空验证后，将其添加到 ignoredResourceTypes 属性中；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	public void ignoreResourceType(String resourceType) {
		Assert.notNull(resourceType, "Ignored resource type must not be null");
		this.ignoredResourceTypes.add(resourceType);
	}
}

2 类方法

2.1 postProcessMergedBeanDefinition 方法

        postProcessMergedBeanDefinition 方法在执行完父对象的 postProcessMergedBeanDefinition 方法完成对对象初始化和销毁方法元数据的处理后，执行 findResourceMetadata 方法创建 findResourceMetadata 对象并使用该对象对 beanDefinition 参数执行 checkConfigMembers 方法；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
		InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
		metadata.checkConfigMembers(beanDefinition);
	}
}

        findResourceMetadata 方法首先尝试从 injectionMetadataCache 中获取 beanName 或 clazz 类名对应的 InjectionMetadata 对象，并在该对象需要刷新时，调用 buildResourceMetadata 对象创建 InjectionMetadata 对象并将其添加到 injectionMetadataCache 缓存中并返回；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private InjectionMetadata findResourceMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
		String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
		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 = buildResourceMetadata(clazz);
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
			}
		}
		return metadata;
	}
}

        buildResourceMetadata 首先在 clazz 参数没有 resourceAnnotationTypes 属性所包含的注解时，直接返回 InjectionMetadata 的 EMPTY 空 InjectionMetadata 对象；随后对 clazz 及其所有父类中所有使用 webServiceRefClass、ejbClass 属性及 Resource 注解对象修饰的字段与方法对象创建 InjectedElement 对象数组，并在最后使用该对象数组创建 InjectionMetadata 对象并返回；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private InjectionMetadata buildResourceMetadata(Class<?> clazz) {
		if (!AnnotationUtils.isCandidateClass(clazz, resourceAnnotationTypes)) {
			return InjectionMetadata.EMPTY;
		}

		List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
		Class<?> targetClass = clazz;

		do {
			final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

			ReflectionUtils.doWithLocalFields(targetClass, field -> {
				if (webServiceRefClass != null && field.isAnnotationPresent(webServiceRefClass)) {
					if (Modifier.isStatic(field.getModifiers())) {
						throw new IllegalStateException("@WebServiceRef annotation is not supported on static fields");
					}
					currElements.add(new WebServiceRefElement(field, field, null));
				}
				else if (ejbClass != null && field.isAnnotationPresent(ejbClass)) {
					if (Modifier.isStatic(field.getModifiers())) {
						throw new IllegalStateException("@EJB annotation is not supported on static fields");
					}
					currElements.add(new EjbRefElement(field, field, null));
				}
				else if (field.isAnnotationPresent(Resource.class)) {
					if (Modifier.isStatic(field.getModifiers())) {
						throw new IllegalStateException("@Resource annotation is not supported on static fields");
					}
					if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
						currElements.add(new ResourceElement(field, field, null));
					}
				}
			});

			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
					return;
				}
				if (method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
					if (webServiceRefClass != null && bridgedMethod.isAnnotationPresent(webServiceRefClass)) {
						if (Modifier.isStatic(method.getModifiers())) {
							throw new IllegalStateException("@WebServiceRef annotation is not supported on static methods");
						}
						if (method.getParameterCount() != 1) {
							throw new IllegalStateException("@WebServiceRef annotation requires a single-arg method: " + method);
						}
						PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
						currElements.add(new WebServiceRefElement(method, bridgedMethod, pd));
					}
					else if (ejbClass != null && bridgedMethod.isAnnotationPresent(ejbClass)) {
						if (Modifier.isStatic(method.getModifiers())) {
							throw new IllegalStateException("@EJB annotation is not supported on static methods");
						}
						if (method.getParameterCount() != 1) {
							throw new IllegalStateException("@EJB annotation requires a single-arg method: " + method);
						}
						PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
						currElements.add(new EjbRefElement(method, bridgedMethod, pd));
					}
					else if (bridgedMethod.isAnnotationPresent(Resource.class)) {
						if (Modifier.isStatic(method.getModifiers())) {
							throw new IllegalStateException("@Resource annotation is not supported on static methods");
						}
						Class<?>[] paramTypes = method.getParameterTypes();
						if (paramTypes.length != 1) {
							throw new IllegalStateException("@Resource annotation requires a single-arg method: " + method);
						}
						if (!this.ignoredResourceTypes.contains(paramTypes[0].getName())) {
							PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
							currElements.add(new ResourceElement(method, bridgedMethod, pd));
						}
					}
				}
			});

			elements.addAll(0, currElements);
			targetClass = targetClass.getSuperclass();
		}
		while (targetClass != null && targetClass != Object.class);

		return InjectionMetadata.forElements(elements, clazz);
	}
}

2.2 resetBeanDefinition 方法

        resetBeanDefinition 方法直接移除 injectionMetadataCache 缓存中的 beanName 参数对应的缓存值；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	@Override
	public void resetBeanDefinition(String beanName) {
		this.injectionMetadataCache.remove(beanName);
	}
}

2.3 postProcessProperties 方法

        postProcessProperties 方法在执行 findResourceMetadata 方法获取对应的 InjectionMetadata 对象后执行其 inject 方法将对象注入到该元数据中；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
		InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
		try {
			metadata.inject(bean, beanName, pvs);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
		}
		return pvs;
	}
}

3 InjectionMetadata 类

3.1 变量及构造方法

3.1.1 常量

        InjectionMetadata 类只有一个空 InjectionMetadata 对象的常量 EMPTY，其将 checkConfigMembers、inject 及 clear 方法的方法体置为空，同时 needsRefresh 方法直接返回 false；

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) {
		}
	};
}

3.1.2 类变量

        InjectionMetadata 类用三个不同的属性，其中 targetClass 属性保存的是关联类对象，injectedElements 属性保存的是原始注入元素集合而 checkedElements 属性则保存的是通过验证的注入元素 Set 集合；

public class InjectionMetadata {
	private final Class<?> targetClass;

	private final Collection<InjectedElement> injectedElements;

	@Nullable
	private volatile Set<InjectedElement> checkedElements;
}

 3.1.3 构造方法

        InjectionMetadata 类只有一个将 targetClass 与 injectedElements 属性初始化为对应入参值；

public class InjectionMetadata {
	public InjectionMetadata(Class<?> targetClass, Collection<InjectedElement> elements) {
		this.targetClass = targetClass;
		this.injectedElements = elements;
	}
}

3.2 类方法

3.2.1 needsRefresh 方法

        needsRefresh 方法直接返回 clazz 入参值是否等于 targetClass 属性；

public class InjectionMetadata {
	protected boolean needsRefresh(Class<?> clazz) {
		return this.targetClass != clazz;
	}
}

3.2.2 checkConfigMembers 方法

        checkConfigMembers 方法将 injectedElements 中还未注入到 beanDefinition 参数的元素注册到 beanDefinition 参数中同时将其保存到 checkedElements 属性中；

public class InjectionMetadata {
	public void checkConfigMembers(RootBeanDefinition beanDefinition) {
		Set<InjectedElement> checkedElements = new LinkedHashSet<>(this.injectedElements.size());
		for (InjectedElement element : this.injectedElements) {
			Member member = element.getMember();
			if (!beanDefinition.isExternallyManagedConfigMember(member)) {
				beanDefinition.registerExternallyManagedConfigMember(member);
				checkedElements.add(element);
			}
		}
		this.checkedElements = checkedElements;
	}
}

3.2.3 inject 方法

        inject 方法目标对象注入到 checkedElements 或 injectedElements 的所有元素中；

public class InjectionMetadata {
	public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
		Collection<InjectedElement> checkedElements = this.checkedElements;
		Collection<InjectedElement> elementsToIterate =
				(checkedElements != null ? checkedElements : this.injectedElements);
		if (!elementsToIterate.isEmpty()) {
			for (InjectedElement element : elementsToIterate) {
				element.inject(target, beanName, pvs);
			}
		}
	}
}

3.2.4 clear 方法

        clear 方法调用 checkedElements 或 injectedElements 的所有元素的 clearPropertySkipping 方法来跳过 pvs 参数属性；

public class InjectionMetadata {
	public void clear(@Nullable PropertyValues pvs) {
		Collection<InjectedElement> checkedElements = this.checkedElements;
		Collection<InjectedElement> elementsToIterate =
				(checkedElements != null ? checkedElements : this.injectedElements);
		if (!elementsToIterate.isEmpty()) {
			for (InjectedElement element : elementsToIterate) {
				element.clearPropertySkipping(pvs);
			}
		}
	}
}

3.3 静态方法

3.3.1 forElements 方法

        forElements 方法直接使用两个入参创建 InjectionMetadata 对象并返回。

public class InjectionMetadata {
	public static InjectionMetadata forElements(Collection<InjectedElement> elements, Class<?> clazz) {
		return (elements.isEmpty() ? new InjectionMetadata(clazz, Collections.emptyList()) :
				new InjectionMetadata(clazz, elements));
	}
}

3.3.2 needsRefresh 方法

        needsRefresh 方法直接返回 metadata 参数是否为 null 或 metadata 的 needsRefresh 方法直接结果。

public class InjectionMetadata {
	public static boolean needsRefresh(@Nullable InjectionMetadata metadata, Class<?> clazz) {
		return (metadata == null || metadata.needsRefresh(clazz));
	}
}

3.4 InjectedElement 内部类

3.4.1 属性及构造方法

        InjectedElement 类拥有 4 个属性，其中 member 属性用于保存注入属性或方法对象，isField 属性则是当前元素是否为属性字段，pd 则是属性访问器对象以及用于标识当前元素是否需要跳过。

public class InjectionMetadata {
	public abstract static class InjectedElement {

		protected final Member member;

		protected final boolean isField;

		@Nullable
		protected final PropertyDescriptor pd;

		@Nullable
		protected volatile Boolean skip;
	}
}

        InjectedElement 类的构造方法直接将 member 与 pd 属性初始化为对应入参值，同时将 isfield 属性更新为 member 参数是否为 Field 对象。

public class InjectionMetadata {
	public abstract static class InjectedElement {
		protected InjectedElement(Member member, @Nullable PropertyDescriptor pd) {
			this.member = member;
			this.isField = (member instanceof Field);
			this.pd = pd;
		}
	}
}

3.4.2 getResourceType 方法

        getResourceType 方法在 isField 属性为 true 时，直接将 member 转化为 Field 对象并返回其类型，否则在 pd 属性不为 null 时，返回其属性类型；否则将会将 member 转化为 Method 对象的第一个参数参数类型；

public class InjectionMetadata {
	public abstract static class InjectedElement {
		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];
			}
		}
	}
}

3.4.3 checkResourceType 方法

        checkResourceType 方法判断当前对象关联类型是否为 resourceType 子类或父类；

public class InjectionMetadata {
	public abstract static class InjectedElement {
		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() + "]");
				}
			}
		}
	}
}

3.4.4 inject 方法

        inject 方法判断当前对象关联类型是否为 resourceType 子类或父类；

public class InjectionMetadata {
	public abstract static class InjectedElement {
		protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
				throws Throwable {

			if (this.isField) {
				Field field = (Field) this.member;
				ReflectionUtils.makeAccessible(field);
				field.set(target, getResourceToInject(target, requestingBeanName));
			}
			else {
				if (checkPropertySkipping(pvs)) {
					return;
				}
				try {
					Method method = (Method) this.member;
					ReflectionUtils.makeAccessible(method);
					method.invoke(target, getResourceToInject(target, requestingBeanName));
				}
				catch (InvocationTargetException ex) {
					throw ex.getTargetException();
				}
			}
		}

		@Nullable
		protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
			return null;
		}
	}
}

        checkPropertySkipping 方法在 skip 属性不为 null 时直接返回该属性值，在 pvs 参数为 null 时将 skip 属性置为 false 并返回 false；随后在 pd 属性不为 null 时，若 pvs 参数中是否包含 bd 属性时将 skip 属性置为 true 并返回 true，而在 pvs 参数为 MutablePropertyValues 对象时将 pd 属性注册为已处理过，并在最后将 skip 置为 false 并返回 false；

public class InjectionMetadata {
	public abstract static class InjectedElement {
		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) {
					if (pvs.contains(this.pd.getName())) {
						this.skip = true;
						return true;
					}
					else if (pvs instanceof MutablePropertyValues) {
						((MutablePropertyValues) pvs).registerProcessedProperty(this.pd.getName());
					}
				}
				this.skip = false;
				return false;
			}
		}
	}
}

 3.4.4 clearPropertySkipping 方法

        clearPropertySkipping 方法在 pvs 参数为 null 时直接返回，否则若 skip 属性为 false、pd 属性不为 null 且 pvs 参数为 MutablePropertyValues 对象时，则会清除 pvs 中的 pd 属性注册标识；

public class InjectionMetadata {
	public abstract static class InjectedElement {
		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());
				}
			}
		}
	}
}

4 LookupElement 内部类

4.1 变量及构造方法

4.1.1 类变量

        LookupElement 类用于向泛型字段或 set 方法中注入对象；其拥有四个不同的属性字段，name 属性保存的是 Resource 注解的 name 属性值，或在其为空时为属性名称、isDefaultName 属性为 Resource 注解是否未设置 name 属性标识、lookupType 属性保存的是 Resource 注解的 type 属性值，或在其为空时为属性类型及保存 Resource 注解的 lookup 或 mappedName 属性值的 mappedName 属性。

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	protected abstract static class LookupElement extends InjectionMetadata.InjectedElement {

		protected String name = "";

		protected boolean isDefaultName = false;

		protected Class<?> lookupType = Object.class;

		@Nullable
		protected String mappedName;

		public final String getName() {
			return this.name;
		}

		public final Class<?> getLookupType() {
			return this.lookupType;
		}
	}
}

4.1.2 构造方法

        在 LookupElement 对象的创建过程中直接使用入参值执行父类的构造方法；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	protected abstract static class LookupElement extends InjectionMetadata.InjectedElement {
		public LookupElement(Member member, @Nullable PropertyDescriptor pd) {
			super(member, pd);
		}
	}
}

4.2 类方法

4.2.1 getDependencyDescriptor 方法

        getDependencyDescriptor 方法使用 member 与 lookupType 属性创建 LookupDependencyDescriptor 对象并返回；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	protected abstract static class LookupElement extends InjectionMetadata.InjectedElement {
		public final DependencyDescriptor getDependencyDescriptor() {
			if (this.isField) {
				return new LookupDependencyDescriptor((Field) this.member, this.lookupType);
			}
			else {
				return new LookupDependencyDescriptor((Method) this.member, this.lookupType);
			}
		}
	}
}

5 ResourceElement 内部类

5.1 变量及构造方法

5.1.1 类变量

        ResourceElement 类继承了 LookupElement 类，扩展了其 Resource 注解的解析及懒加载功能，其只有一个用于标识是否需要懒加载的 lazyLookup 属性，即 Lazy 注解设置的；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private class ResourceElement extends LookupElement {
		private final boolean lazyLookup;
	}
}

5.1.2 构造方法

        ResourceElement 类构造方法首先也是使用 member 与 pd 属性执行父类的构造方法，随后将 isDefaultName 属性值更新为 ae 参数的 Resource 注解是否未设置 name 属性值，为 true 时，会将 resourceName 变量更新为 member 关联属性名，否则直接将 resourceName 变量设置为 Resource 注解的 name 属性值并在 embeddedValueResolver 属性不为空时，进一步使用该属性的 resolveStringValue 方法处理 Resource 注解的 name 属性值来对 resourceName 变量值进行更新；随后在 Resource 注解的 type 属性值为 Object 对象时，执行 checkResourceType 对该属性进行验证，否则将 resourceType 局部变量值更新为 getResourceType 方法执行结果；最后分别将 name、lookupType、mappedName 及 lazyLookup 属性分别更新为 resourceName 变量值、resourceType 变量值、Resource 注解的 lookup 或 mappedName 属性值及 Lazy 注解值；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private class ResourceElement extends LookupElement {
		public ResourceElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {
			super(member, pd);
			Resource resource = ae.getAnnotation(Resource.class);
			String resourceName = resource.name();
			Class<?> resourceType = resource.type();
			this.isDefaultName = !StringUtils.hasLength(resourceName);
			if (this.isDefaultName) {
				resourceName = this.member.getName();
				if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
					resourceName = Introspector.decapitalize(resourceName.substring(3));
				}
			}
			else if (embeddedValueResolver != null) {
				resourceName = embeddedValueResolver.resolveStringValue(resourceName);
			}
			if (Object.class != resourceType) {
				checkResourceType(resourceType);
			}
			else {
				// No resource type specified... check field/method.
				resourceType = getResourceType();
			}
			this.name = (resourceName != null ? resourceName : "");
			this.lookupType = resourceType;
			String lookupValue = resource.lookup();
			this.mappedName = (StringUtils.hasLength(lookupValue) ? lookupValue : resource.mappedName());
			Lazy lazy = ae.getAnnotation(Lazy.class);
			this.lazyLookup = (lazy != null && lazy.value());
		}
	}
}

5.2 类方法

5.2.1 getResourceToInject 方法

        getResourceToInject 方法在 lazyLookup 为 true 时，使用当前对象与 requestingBeanName 属性执行 buildLazyResourceProxy 方法执行懒加载代理对象并返回，否则使用当前对象及 requestingBeanName 参数执行 getResource 方法创建 Resource 对象并返回；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private class ResourceElement extends LookupElement {
		@Override
		protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
			return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
					getResource(this, requestingBeanName));
		}
	}
}

         buildLazyResourceProxy 方法直接创建 TargetSource 对象，并重写了其中的 getTargetClass、isStatic、getTarget 及 releaseTarget 方法，其中 getTargetClass 方法直接返回 element 参数的 lookupType 属性值，isStatic 方法直接返回 false，getTarget 方法直接使用 element 与 requestingBeanName 参数执行 getResource 方法并返回，而 releaseTarget 方法没有任何实现；随后使用创建的 TargetSource 对象构造 ProxyFactory 对象工厂并执行其 getProxy 方法创建代理对象并返回；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	protected Object buildLazyResourceProxy(final LookupElement element, final @Nullable String requestingBeanName) {
		TargetSource ts = new TargetSource() {
			@Override
			public Class<?> getTargetClass() {
				return element.lookupType;
			}
			@Override
			public boolean isStatic() {
				return false;
			}
			@Override
			public Object getTarget() {
				return getResource(element, requestingBeanName);
			}
			@Override
			public void releaseTarget(Object target) {
			}
		};

		ProxyFactory pf = new ProxyFactory();
		pf.setTargetSource(ts);
		if (element.lookupType.isInterface()) {
			pf.addInterface(element.lookupType);
		}
		ClassLoader classLoader = (this.beanFactory instanceof ConfigurableBeanFactory ?
				((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() : null);
		return pf.getProxy(classLoader);
	}
}

        getResource 方法在 element 的 mappedName 属性不为空时，直接从 jndiFactory 对象工厂中获取 mappedName 属性对应对象并返回；随后在 alwaysUseJndiLookup 属性为 true 时，则尝试从 jndiFactory 对象工厂中获取 element 的 name 属性关联对象并返回；之后在 resourceFactory 不为空时直接执行 autowireResource 方法并返回，否则直接抛出异常；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	protected Object getResource(LookupElement element, @Nullable String requestingBeanName)
			throws NoSuchBeanDefinitionException {

		if (StringUtils.hasLength(element.mappedName)) {
			return this.jndiFactory.getBean(element.mappedName, element.lookupType);
		}
		if (this.alwaysUseJndiLookup) {
			return this.jndiFactory.getBean(element.name, element.lookupType);
		}
		if (this.resourceFactory == null) {
			throw new NoSuchBeanDefinitionException(element.lookupType,
					"No resource factory configured - specify the 'resourceFactory' property");
		}
		return autowireResource(this.resourceFactory, element, requestingBeanName);
	}
}

        autowireResource 方法在 factory 参数为 AutowireCapableBeanFactory 对象，同时在 fallbackToDefaultTypeMatch 属性、element 参数的 isDefaultName 属性全为 true 且 factory 参数中不包含 element 参数关联对象时，通过 factory 的 resolveDependency 方法获取 requestingBeanName 关联对象并更新 autowiredBeanNames 变量值，未获取到时直接抛出异常时；否则会分别将 resource 与 autowiredBeanNames 变量值更新为使用 factory 参数获取的 element 关联对象及该参数关联名称；之后在 factory 为 ConfigurableBeanFactory 对象时，将 autowiredBeanNames 中的所有元素与 requestingBeanName 参数对照关系向 factory 注册依赖映射，并在最后返回 resource 变量值；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	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)) {
				autowiredBeanNames = new LinkedHashSet<>();
				resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
				if (resource == null) {
					throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
				}
			}
			else {
				resource = beanFactory.resolveBeanByName(name, descriptor);
				autowiredBeanNames = Collections.singleton(name);
			}
		}
		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;
	}
}

6 WebServiceRefElement 内部类

6.1 变量及构造方法

6.1.1 类变量

        WebServiceRefElement 类也继承了 LookupElement 类，扩展了其对 webService 相关参数解析；该类拥有两个参数，其中 elementType 属性保存的是当前元素属性对象，而 wsdlLocation 则保存的是 webService 属性对应的地址；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private class WebServiceRefElement extends LookupElement {

		private final Class<?> elementType;

		private final String wsdlLocation;
	}
}

 6.1.2 构造方法

        WebServiceRefElement 类只有一个构造方法，其首先也是使用 member 与 pd 参数执行父类的构造方法；随后使用 WebServiceRef 注解利用创建 ResourceElement 对象的逻辑分别为 name、elementType、lookupType、isDefaultName 及 mappedName 属性进行赋值，同时将 wsdlLocation 属性初始化为 WebServiceRef 注解对象的 wsdlLocation 属性值；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private class WebServiceRefElement extends LookupElement {
		public WebServiceRefElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {
			super(member, pd);
			WebServiceRef resource = ae.getAnnotation(WebServiceRef.class);
			String resourceName = resource.name();
			Class<?> resourceType = resource.type();
			this.isDefaultName = !StringUtils.hasLength(resourceName);
			if (this.isDefaultName) {
				resourceName = this.member.getName();
				if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
					resourceName = Introspector.decapitalize(resourceName.substring(3));
				}
			}
			if (Object.class != resourceType) {
				checkResourceType(resourceType);
			}
			else {
				resourceType = getResourceType();
			}
			this.name = resourceName;
			this.elementType = resourceType;
			if (Service.class.isAssignableFrom(resourceType)) {
				this.lookupType = resourceType;
			}
			else {
				this.lookupType = resource.value();
			}
			this.mappedName = resource.mappedName();
			this.wsdlLocation = resource.wsdlLocation();
		}
	}
}

6.2 类方法

6.2.1 getResourceToInject 方法

        getResourceToInject 方法首先尝试使用当前对象与 requestingBeanName 参数执行 getResource 方法并使用其结果为 service 变量进行赋值；若在该方法的执行过程中未查询到关联对象注册表时，在 lookupType 属性为 Service 对象时直接抛出异常，随后若 wsdlLocation 属性不为空时，尝试获取 lookupType 属性的 WebServiceClient 注解对象，并在不存在该注解时直接抛出异常，否则将 service 变量更新为创建的 lookupType 对象，而在 wsdlLocation 属性为空时直接创建空 lookupType 对象；最后使用 service 变量的 getPort 方法获取 elementType 属性关联节点并返回；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private class WebServiceRefElement extends LookupElement {
		@Override
		protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
			Service service;
			try {
				service = (Service) getResource(this, requestingBeanName);
			}
			catch (NoSuchBeanDefinitionException notFound) {
				if (Service.class == this.lookupType) {
					throw new IllegalStateException("No resource with name '" + this.name + "' found in context, " +
							"and no specific JAX-WS Service subclass specified. The typical solution is to either specify " +
							"a LocalJaxWsServiceFactoryBean with the given name or to specify the (generated) Service " +
							"subclass as @WebServiceRef(...) value.");
				}
				if (StringUtils.hasLength(this.wsdlLocation)) {
					try {
						Constructor<?> ctor = this.lookupType.getConstructor(URL.class, QName.class);
						WebServiceClient clientAnn = this.lookupType.getAnnotation(WebServiceClient.class);
						if (clientAnn == null) {
							throw new IllegalStateException("JAX-WS Service class [" + this.lookupType.getName() +
									"] does not carry a WebServiceClient annotation");
						}
						service = (Service) BeanUtils.instantiateClass(ctor,
								new URL(this.wsdlLocation), new QName(clientAnn.targetNamespace(), clientAnn.name()));
					}
					catch (NoSuchMethodException ex) {
						throw new IllegalStateException("JAX-WS Service class [" + this.lookupType.getName() +
								"] does not have a (URL, QName) constructor. Cannot apply specified WSDL location [" +
								this.wsdlLocation + "].");
					}
					catch (MalformedURLException ex) {
						throw new IllegalArgumentException(
								"Specified WSDL location [" + this.wsdlLocation + "] isn't a valid URL");
					}
				}
				else {
					service = (Service) BeanUtils.instantiateClass(this.lookupType);
				}
			}
			return service.getPort(this.elementType);
		}
	}
}

7 EjbRefElement 内部类

7.1 变量及构造方法

7.1.1 类变量

        EjbRefElement 类中只有一个保存对象名的 beanName 属性；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private class EjbRefElement extends LookupElement {
		private final String beanName;
	}
}

7.1.2 构造方法

        EjbRefElement 类的构造方法在使用 member 与 pd 参数执行父类的构造方法，同时使用修饰 ae 参数的 EJB 注解对象的属性值去更新 LookupElement 参数的属性及 beanName 属性；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private class EjbRefElement extends LookupElement {
		public EjbRefElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {
			super(member, pd);
			EJB resource = ae.getAnnotation(EJB.class);
			String resourceBeanName = resource.beanName();
			String resourceName = resource.name();
			this.isDefaultName = !StringUtils.hasLength(resourceName);
			if (this.isDefaultName) {
				resourceName = this.member.getName();
				if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
					resourceName = Introspector.decapitalize(resourceName.substring(3));
				}
			}
			Class<?> resourceType = resource.beanInterface();
			if (Object.class != resourceType) {
				checkResourceType(resourceType);
			}
			else {
				resourceType = getResourceType();
			}
			this.beanName = resourceBeanName;
			this.name = resourceName;
			this.lookupType = resourceType;
			this.mappedName = resource.mappedName();
		}
	}
}

7.2 类方法

7.2.1 getResourceToInject 方法

        getResourceToInject 方法在 beanName 属性不为空时，若 beanFactory 属性中包含名为 beanName 属性的对象时，则会从 beanFactory 属性中获取对应对象，若 requestingBeanName 参数不为空且 beanFactory 属性为 ConfigurableBeanFactory 对象时则同时会向其中注册依赖映射同时返回获取到对象；而在 beanFactory 属性中没有名为 beanName 属性的对象、isDefaultName 属性且 mappedName 属性为空时直接抛出异常，若不满足上述条件则使用当前对象与 requestingBeanName 参数执行 getResource 方法获取对象并返回。

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private class EjbRefElement extends LookupElement {
		@Override
		protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
			if (StringUtils.hasLength(this.beanName)) {
				if (beanFactory != null && beanFactory.containsBean(this.beanName)) {
					Object bean = beanFactory.getBean(this.beanName, this.lookupType);
					if (requestingBeanName != null && beanFactory instanceof ConfigurableBeanFactory) {
						((ConfigurableBeanFactory) beanFactory).registerDependentBean(this.beanName, requestingBeanName);
					}
					return bean;
				}
				else if (this.isDefaultName && !StringUtils.hasLength(this.mappedName)) {
					throw new NoSuchBeanDefinitionException(this.beanName,
							"Cannot resolve 'beanName' in local BeanFactory. Consider specifying a general 'name' value instead.");
				}
			}
			return getResource(this, requestingBeanName);
		}
	}
}

8 LookupDependencyDescriptor 内部类

8.1 变量及构造方法

8.1.1 类变量

        LookupDependencyDescriptor 类中只有一个保存查询类型的 lookupType 属性；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private static class LookupDependencyDescriptor extends DependencyDescriptor {
		private final Class<?> lookupType;
	}
}

8.1.2 构造方法

        LookupDependencyDescriptor 类拥有两个不同的构造方法，其分别使用 Field 或 Method 对象创建本对象，在创建过程中，首先使用参数执行父类的构造方法同时将 lookupType 属性初始化为 lookupType 参数；

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private static class LookupDependencyDescriptor extends DependencyDescriptor {
		public LookupDependencyDescriptor(Field field, Class<?> lookupType) {
			super(field, true);
			this.lookupType = lookupType;
		}

		public LookupDependencyDescriptor(Method method, Class<?> lookupType) {
			super(new MethodParameter(method, 0), true);
			this.lookupType = lookupType;
		}
	}
}

8.2 类方法

8.2.1 getDependencyType 方法

        LookupDependencyDescriptor 类只重写了 getDependencyType 方法，其直接返回 lookupType 属性值。

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
	private static class LookupDependencyDescriptor extends DependencyDescriptor {
		@Override
		public Class<?> getDependencyType() {
			return this.lookupType;
		}
	}
}

五 EventListenerMethodProcessor 类

1 属性及构造方法

1.1 类变量

        EventListenerMethodProcessor 拥有 5 个不同的属性，其中 applicationContext 与 beanFactory 属性分别保存的是当前所使用的上下文及使用的对象工厂、eventListenerFactories 属性保存的是当前所使用的时间监听器工厂列表、evaluator 属性则是事件表达式计算器及用于保存为使用注解修饰的 Class 对象 set 集合的 nonAnnotatedClasses 属性；

public class EventListenerMethodProcessor
		implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor {

	@Nullable
	private ConfigurableApplicationContext applicationContext;

	@Nullable
	private ConfigurableListableBeanFactory beanFactory;

	@Nullable
	private List<EventListenerFactory> eventListenerFactories;

	private final EventExpressionEvaluator evaluator = new EventExpressionEvaluator();

	private final Set<Class<?>> nonAnnotatedClasses = Collections.newSetFromMap(new ConcurrentHashMap<>(64));
}

2 类方法

2.1 setApplicationContext 方法

        setApplicationContext 方法首先验证了 applicationContext 参数是否为 ConfigurableApplicationContext 对象，通过后将该参数转换为 ConfigurableApplicationContext 对象并使用该值来初始化 applicationContext 属性；

public class EventListenerMethodProcessor
		implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor {
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) {
		Assert.isTrue(applicationContext instanceof ConfigurableApplicationContext,
				"ApplicationContext does not implement ConfigurableApplicationContext");
		this.applicationContext = (ConfigurableApplicationContext) applicationContext;
	}
}

2.2 postProcessBeanFactory 方法

        postProcessBeanFactory 方法首先将 beanFactory 属性更新为 beanFactory 参数值，同时将其中所有的 EventListenerFactory 对象排好序然后保存到 eventListenerFactories 属性之中；

public class EventListenerMethodProcessor
		implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		this.beanFactory = beanFactory;

		Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false);
		List<EventListenerFactory> factories = new ArrayList<>(beans.values());
		AnnotationAwareOrderComparator.sort(factories);
		this.eventListenerFactories = factories;
	}
}

2.3 afterSingletonsInstantiated 方法

        afterSingletonsInstantiated 方法对 beanFactory 中的所有对象进行遍历，使用 processBean 方法对其中的非作用域代理对象进行处理；

public class EventListenerMethodProcessor
		implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor {
	@Override
	public void afterSingletonsInstantiated() {
		ConfigurableListableBeanFactory beanFactory = this.beanFactory;
		Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");
		String[] beanNames = beanFactory.getBeanNamesForType(Object.class);
		for (String beanName : beanNames) {
			if (!ScopedProxyUtils.isScopedTarget(beanName)) {
				Class<?> type = null;
				try {
					type = AutoProxyUtils.determineTargetClass(beanFactory, beanName);
				}
				catch (Throwable ex) {
					if (logger.isDebugEnabled()) {
						logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);
					}
				}
				if (type != null) {
					if (ScopedObject.class.isAssignableFrom(type)) {
						try {
							Class<?> targetClass = AutoProxyUtils.determineTargetClass(
									beanFactory, ScopedProxyUtils.getTargetBeanName(beanName));
							if (targetClass != null) {
								type = targetClass;
							}
						}
						catch (Throwable ex) {
							if (logger.isDebugEnabled()) {
								logger.debug("Could not resolve target bean for scoped proxy '" + beanName + "'", ex);
							}
						}
					}
					try {
						processBean(beanName, type);
					}
					catch (Throwable ex) {
						throw new BeanInitializationException("Failed to process @EventListener " +
								"annotation on bean with name '" + beanName + "'", ex);
					}
				}
			}
		}
	}
}

        processBean 方法在 nonAnnotatedClasses 属性不包含 targetType 参数或其不可能存在使用 EventListener 注解修饰的方法时直接返回；否则获取 targetType 类中所有使用 EventListener 注解修饰的方法对象，若不存在则将 targetType 参数值添加到 nonAnnotatedClasses 属性中并返回，随后将方法中存在 eventListenerFactories 属性支持的元素使用 aop 进行代理并添加到 applicationContext 属性中；

public class EventListenerMethodProcessor
		implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor {
	private void processBean(final String beanName, final Class<?> targetType) {
		if (!this.nonAnnotatedClasses.contains(targetType) &&
				AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&
				!isSpringContainerClass(targetType)) {

			Map<Method, EventListener> annotatedMethods = null;
			try {
				annotatedMethods = MethodIntrospector.selectMethods(targetType,
						(MethodIntrospector.MetadataLookup<EventListener>) method ->
								AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));
			}
			catch (Throwable ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Could not resolve methods for bean with name '" + beanName + "'", ex);
				}
			}

			if (CollectionUtils.isEmpty(annotatedMethods)) {
				this.nonAnnotatedClasses.add(targetType);
				if (logger.isTraceEnabled()) {
					logger.trace("No @EventListener annotations found on bean class: " + targetType.getName());
				}
			}
			else {
				ConfigurableApplicationContext context = this.applicationContext;
				Assert.state(context != null, "No ApplicationContext set");
				List<EventListenerFactory> factories = this.eventListenerFactories;
				Assert.state(factories != null, "EventListenerFactory List not initialized");
				for (Method method : annotatedMethods.keySet()) {
					for (EventListenerFactory factory : factories) {
						if (factory.supportsMethod(method)) {
							Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
							ApplicationListener<?> applicationListener =
									factory.createApplicationListener(beanName, targetType, methodToUse);
							if (applicationListener instanceof ApplicationListenerMethodAdapter) {
								((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);
							}
							context.addApplicationListener(applicationListener);
							break;
						}
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug(annotatedMethods.size() + " @EventListener methods processed on bean '" +
							beanName + "': " + annotatedMethods);
				}
			}
		}
	}
}

        isSpringContainerClass 判断类是否为未使用 Component 注解修饰的 org.springframework 包中类。

public class EventListenerMethodProcessor
		implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor {
	private static boolean isSpringContainerClass(Class<?> clazz) {
		return (clazz.getName().startsWith("org.springframework.") &&
				!AnnotatedElementUtils.isAnnotated(ClassUtils.getUserClass(clazz), Component.class));
	}
}

六 EventListenerFactory 对象

 1 EventListenerFactory 接口

        EventListenerFactory 接口向外提供了 ApplicationListener 对象的创建功能，supportsMethod 方法判断是否支持指定方法对象，createApplicationListener 方法用于创建 ApplicationListener 对象；

public interface EventListenerFactory {

	boolean supportsMethod(Method method);

	ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method);

}

2 DefaultEventListenerFactory 类

2.1 类属性

        DefaultEventListenerFactory 类只有一个用于排序的 order 属性，其值为 LOWEST_PRECEDENCE，表明其为最后执行的工厂对象；

public class DefaultEventListenerFactory implements EventListenerFactory, Ordered {

	private int order = LOWEST_PRECEDENCE;

	public void setOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		return this.order;
	}

}

2.2 类方法

2.2.1 supportsMethod 方法

        supportsMethod 方法直接返回 true，表明其支持任何 EventListener 注解修饰的方法对象；

public class DefaultEventListenerFactory implements EventListenerFactory, Ordered {
	@Override
	public boolean supportsMethod(Method method) {
		return true;
	}
}

2.2.2 createApplicationListener 方法

        createApplicationListener 方法直接使用所有入参值创建 ApplicationListenerMethodAdapter 对象并返回；

public class DefaultEventListenerFactory implements EventListenerFactory, Ordered {
	@Override
	public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {
		return new ApplicationListenerMethodAdapter(beanName, type, method);
	}
}

3 TransactionalEventListenerFactory 类

3.1 类属性

        TransactionalEventListenerFactory 类也只有一个用于排序的 order 属性，其值为50；

public class TransactionalEventListenerFactory implements EventListenerFactory, Ordered {

	private int order = 50;

	public void setOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		return this.order;
	}

}

3.2 类方法

3.2.1 supportsMethod 方法

        supportsMethod 方法直接返回 method 参数是否使用 TransactionalEventListener 注解进行修饰；

public class TransactionalEventListenerFactory implements EventListenerFactory, Ordered {
	@Override
	public boolean supportsMethod(Method method) {
		return AnnotatedElementUtils.hasAnnotation(method, TransactionalEventListener.class);
	}
}

3.2.2 createApplicationListener 方法

        createApplicationListener 方法直接使用所有入参值创建 ApplicationListenerMethodTransactionalAdapter 对象并返回；

public class TransactionalEventListenerFactory implements EventListenerFactory, Ordered {
	@Override
	public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {
		return new ApplicationListenerMethodTransactionalAdapter(beanName, type, method);
	}
}

4 ApplicationListenerMethodAdapter 类

4.1 属性与构造方法

4.1.1 常量

        ApplicationListenerMethodAdapter 类只有标识当前是否拥有 org.reactivestreams.Publisher 类的 reactiveStreamsPresent 常量；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	private static final boolean reactiveStreamsPresent = ClassUtils.isPresent(
			"org.reactivestreams.Publisher", ApplicationListenerMethodAdapter.class.getClassLoader());

}

4.1.2 类变量

        ApplicationListenerMethodAdapter 类拥有保存对象名的 beanName 属性、保存目标非桥接方法对象的 method 属性、保存的 AOP 代理方法对象的 targetMethod 属性、使用 targetMethod 属性与目标类创建的 AnnotatedElementKey 对象的 methodKey 方法、declaredEventTypes 属性保存的是监听 ResolvableType 对象 List 集合对象、condition 属性保存的则是 EventListener 注解的 condition 属性，即激发条件、保存监听起顺序的 order 属性与分别保存上下文对象与表达式执行器对象的 applicationContext 与 evaluator 属性；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	private final String beanName;

	private final Method method;

	private final Method targetMethod;

	private final AnnotatedElementKey methodKey;

	private final List<ResolvableType> declaredEventTypes;

	@Nullable
	private final String condition;

	private final int order;

	@Nullable
	private ApplicationContext applicationContext;

	@Nullable
	private EventExpressionEvaluator evaluator;

	@Override
	public boolean supportsSourceType(@Nullable Class<?> sourceType) {
		return true;
	}

	@Override
	public int getOrder() {
		return this.order;
	}

	protected Object getTargetBean() {
		Assert.notNull(this.applicationContext, "ApplicationContext must no be null");
		return this.applicationContext.getBean(this.beanName);
	}

	@Nullable
	protected String getCondition() {
		return this.condition;
	}
}

4.1.3 构造方法

        在 ApplicationListenerMethodAdapter 对象创建过程中，首先将 beanName 属性初始化为 beanName 参数值，随后将非桥接方法与代理方法分别保存到 method 与 targetMethod 属性中，随后使用 targetMethod 属性与 targetClass 参数创建 AnnotatedElementKey 对象为 methodKey 属性赋值，随后使用 targetMethod 的 EventListener 注解属性为 declaredEventTypes 与 condition 属性赋值，最后对 order 属性进行初始化。

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	public ApplicationListenerMethodAdapter(String beanName, Class<?> targetClass, Method method) {
		this.beanName = beanName;
		this.method = BridgeMethodResolver.findBridgedMethod(method);
		this.targetMethod = (!Proxy.isProxyClass(targetClass) ?
				AopUtils.getMostSpecificMethod(method, targetClass) : this.method);
		this.methodKey = new AnnotatedElementKey(this.targetMethod, targetClass);

		EventListener ann = AnnotatedElementUtils.findMergedAnnotation(this.targetMethod, EventListener.class);
		this.declaredEventTypes = resolveDeclaredEventTypes(method, ann);
		this.condition = (ann != null ? ann.condition() : null);
		this.order = resolveOrder(this.targetMethod);
	}

}

        resolveDeclaredEventTypes 方法在 method 参数拥有多于一个参数时直接抛出异常，在 ann 参数不为空且其 classes 属性值不为空时，将其所有元素转换为 ResolvableType 对象 list 集合并返回；否则在 method 参数只有一个参数时返回该参数转换的单 ResolvableType 对象 list 集合并返回，否则直接抛出异常；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	private static List<ResolvableType> resolveDeclaredEventTypes(Method method, @Nullable EventListener ann) {
		int count = method.getParameterCount();
		if (count > 1) {
			throw new IllegalStateException(
					"Maximum one parameter is allowed for event listener method: " + method);
		}

		if (ann != null) {
			Class<?>[] classes = ann.classes();
			if (classes.length > 0) {
				List<ResolvableType> types = new ArrayList<>(classes.length);
				for (Class<?> eventType : classes) {
					types.add(ResolvableType.forClass(eventType));
				}
				return types;
			}
		}

		if (count == 0) {
			throw new IllegalStateException(
					"Event parameter is mandatory for event listener method: " + method);
		}
		return Collections.singletonList(ResolvableType.forMethodParameter(method, 0));
	}

}

        resolveOrder 方法在 method 拥有 Order 注解时直接返回其 value 属性值，否则直接返回 0；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	private static int resolveOrder(Method method) {
		Order ann = AnnotatedElementUtils.findMergedAnnotation(method, Order.class);
		return (ann != null ? ann.value() : 0);
	}
}

4.2 类方法

4.2.1 init 方法

         init 方法直接将 applicationContext 与 evaluator 属性更新为对应参数值；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	void init(ApplicationContext applicationContext, EventExpressionEvaluator evaluator) {
		this.applicationContext = applicationContext;
		this.evaluator = evaluator;
	}
}

4.2.2 onApplicationEvent 方法

         onApplicationEvent 方法直接使用 event 参数执行 processEvent 方法；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	@Override
	public void onApplicationEvent(ApplicationEvent event) {
		processEvent(event);
	}
}

        processEvent 方法首先使用 resolveArguments 方法获取方法入参对象；并在使用 shouldHandle 方法通过条件验证后，调用 doInvoke 方法执行当前方法并在其结果不为 null 时进一步调用 handleResult 方法对结果进行处理；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	public void processEvent(ApplicationEvent event) {
		Object[] args = resolveArguments(event);
		if (shouldHandle(event, args)) {
			Object result = doInvoke(args);
			if (result != null) {
				handleResult(result);
			}
			else {
				logger.trace("No result object given - no result to handle");
			}
		}
	}
}

        resolveArguments 方法首先通过 getResolvableType 方法获取 declaredEventTypes 属性中与 event 参数匹配的元素对象，若不存在则直接返回 null；而在 method 属性没有任何参数时直接返回空 Object 对象数组，之后若 getResolvableType 获取到的元素不为 ApplicationEvent 对象且 event 参数为 PayloadApplicationEvent 对象时，在 event 的载荷为  getResolvableType 获取到的元素对应的对象时，则会将 event 的载荷包装为单元素 Object 对象数组并返回；否则直接将 event 参数封装为单元素 Object 对象数组并返回。

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	@Nullable
	protected Object[] resolveArguments(ApplicationEvent event) {
		ResolvableType declaredEventType = getResolvableType(event);
		if (declaredEventType == null) {
			return null;
		}
		if (this.method.getParameterCount() == 0) {
			return new Object[0];
		}
		Class<?> declaredEventClass = declaredEventType.toClass();
		if (!ApplicationEvent.class.isAssignableFrom(declaredEventClass) &&
				event instanceof PayloadApplicationEvent) {
			Object payload = ((PayloadApplicationEvent<?>) event).getPayload();
			if (declaredEventClass.isInstance(payload)) {
				return new Object[] {payload};
			}
		}
		return new Object[] {event};
	}
}

        getResolvableType 首先在 event 为 PayloadApplicationEvent 对象时，使用 payloadType 局部变量保存其泛型对象；随后查找 declaredEventTypes 属性中不为 ApplicationEvent 类但为 payloadType 对象父类或为 event 参数类型的元素并返回，未查询到时直接返回；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	@Nullable
	private ResolvableType getResolvableType(ApplicationEvent event) {
		ResolvableType payloadType = null;
		if (event instanceof PayloadApplicationEvent) {
			PayloadApplicationEvent<?> payloadEvent = (PayloadApplicationEvent<?>) event;
			ResolvableType eventType = payloadEvent.getResolvableType();
			if (eventType != null) {
				payloadType = eventType.as(PayloadApplicationEvent.class).getGeneric();
			}
		}
		for (ResolvableType declaredEventType : this.declaredEventTypes) {
			Class<?> eventClass = declaredEventType.toClass();
			if (!ApplicationEvent.class.isAssignableFrom(eventClass) &&
					payloadType != null && declaredEventType.isAssignableFrom(payloadType)) {
				return declaredEventType;
			}
			if (eventClass.isInstance(event)) {
				return declaredEventType;
			}
		}
		return null;
	}
}

        shouldHandle 方法在 args 参数为 null 时直接返回 false，而在 condition 属性值为空时直接返回 true ；否则在通过对 evaluator 属性的非空验证后，返回该计算器对 condition 属性条件表达式进行判断并返回判断结果；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	private boolean shouldHandle(ApplicationEvent event, @Nullable Object[] args) {
		if (args == null) {
			return false;
		}
		String condition = getCondition();
		if (StringUtils.hasText(condition)) {
			Assert.notNull(this.evaluator, "EventExpressionEvaluator must not be null");
			return this.evaluator.condition(
					condition, event, this.targetMethod, this.methodKey, args, this.applicationContext);
		}
		return true;
	}
}

        doInvoke 方法在 beanName 对应对象为 null 时直接返回 null，否则使用 args 参数执行目标对象的 method 属性方法并返回；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	@Nullable
	protected Object doInvoke(Object... args) {
		Object bean = getTargetBean();
		if (bean.equals(null)) {
			return null;
		}

		ReflectionUtils.makeAccessible(this.method);
		try {
			return this.method.invoke(bean, args);
		}
		catch (IllegalArgumentException ex) {
			assertTargetBean(this.method, bean, args);
			throw new IllegalStateException(getInvocationErrorMessage(bean, ex.getMessage(), args), ex);
		}
		catch (IllegalAccessException ex) {
			throw new IllegalStateException(getInvocationErrorMessage(bean, ex.getMessage(), args), ex);
		}
		catch (InvocationTargetException ex) {
			Throwable targetException = ex.getTargetException();
			if (targetException instanceof RuntimeException) {
				throw (RuntimeException) targetException;
			}
			else {
				String msg = getInvocationErrorMessage(bean, "Failed to invoke event listener method", args);
				throw new UndeclaredThrowableException(targetException, msg);
			}
		}
	}
}

        handleResult 方法在 reactiveStreamsPresent 属性为 true 时，会调用 ReactiveResultHandler 对象的 subscribeToPublisher 方法进一步发布其结果，在其结果为 true 时直接返回，在 result 参数为 CompletionStage 对象时，在其异步执行完毕后，若 ex 为 null 且 event 结果不为 null 时进一步调用 publishEvent 发布事件，在 result 为 ListenableFuture 对象时，则会将 publishEvents 方法加入其回调流程中，否则直接调用 publishEvents 进一步发布事件；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	protected void handleResult(Object result) {
		if (reactiveStreamsPresent && new ReactiveResultHandler().subscribeToPublisher(result)) {
			if (logger.isTraceEnabled()) {
				logger.trace("Adapted to reactive result: " + result);
			}
		}
		else if (result instanceof CompletionStage) {
			((CompletionStage<?>) result).whenComplete((event, ex) -> {
				if (ex != null) {
					handleAsyncError(ex);
				}
				else if (event != null) {
					publishEvent(event);
				}
			});
		}
		else if (result instanceof ListenableFuture) {
			((ListenableFuture<?>) result).addCallback(this::publishEvents, this::handleAsyncError);
		}
		else {
			publishEvents(result);
		}
	}
}

        publishEvents 方法在 result 参数为数组或 Collection 集合时，逐一调用 publishEvent 方法发布其中元素，否则直接调用 publishEvent 方法直接发布 result 参数对象；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	private void publishEvents(Object result) {
		if (result.getClass().isArray()) {
			Object[] events = ObjectUtils.toObjectArray(result);
			for (Object event : events) {
				publishEvent(event);
			}
		}
		else if (result instanceof Collection<?>) {
			Collection<?> events = (Collection<?>) result;
			for (Object event : events) {
				publishEvent(event);
			}
		}
		else {
			publishEvent(result);
		}
	}

	private void publishEvent(@Nullable Object event) {
		if (event != null) {
			Assert.notNull(this.applicationContext, "ApplicationContext must not be null");
			this.applicationContext.publishEvent(event);
		}
	}
}

4.3 内部类

4.3.1 ReactiveResultHandler 类

         ReactiveResultHandler 类只有一个 subscribeToPublisher 方法，该方法首先从 ReactiveAdapterRegistry 中获取与 result 参数类型匹配的 ReactiveAdapter 适配器对象，在其不为 null 时，调用其 toPublisher 方法将 result 参数适配到 Reactive Streams 流中来订阅 EventPublicationSubscriber 对象；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	private class ReactiveResultHandler {

		public boolean subscribeToPublisher(Object result) {
			ReactiveAdapter adapter = ReactiveAdapterRegistry.getSharedInstance().getAdapter(result.getClass());
			if (adapter != null) {
				adapter.toPublisher(result).subscribe(new EventPublicationSubscriber());
				return true;
			}
			return false;
		}
	}
}

4.3.2 EventPublicationSubscriber 类

         EventPublicationSubscriber 类实现了 onSubscribe、onNext、onError 及 onComplete 方法，onSubscribe 方法直接调用 s 参数的 request 方法为其设置最大整型值，onNext 方法直接调用 publishEvents 方法，onError 方法则是直接调用 handleAsyncError 方法及 onComplete 方法没有任何实现；

public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
	private class EventPublicationSubscriber implements Subscriber<Object> {

		@Override
		public void onSubscribe(Subscription s) {
			s.request(Integer.MAX_VALUE);
		}

		@Override
		public void onNext(Object o) {
			publishEvents(o);
		}

		@Override
		public void onError(Throwable t) {
			handleAsyncError(t);
		}

		@Override
		public void onComplete() {
		}
	}
}