Spring对注解(Annotation)处理源码分析2——解析和注入注解配置的资源

 

1.类内部的注解，如：@Autowire、@Value、@Required、@Resource以及EJB和WebSerivce相关的注解，是容器对Bean对象实例化和依赖注入时，通过容器中注册的Bean后置处理器处理这些注解的。

2.Spring中处理注解的Bean后置处理器：

当使用Spring的注解功能时，在Spring配置文件中添加如下配置开启Spring的注解处理器：

<context:annotation-config> < context:component-scan >  

 

上面的配置将隐式地向Spring容器注册、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor以及这4个专门用于处理注解的Bean后置处理器。

下面将具体介绍这4个注解后置处理器。

:

是Spring容器专门处理配置了自动依赖注入装配相关注解(@Autowire、@Value以及其他JSR-330注解)的Bean后置处理器，其主要功能源码如下：

(1).的构造方法：

AutowiredAnnotationBeanPostProcessor只有一个的构造方法，其源码如下：

public AutowiredAnnotationBeanPostProcessor() { //后置处理器将处理@Autowire注解 this.autowiredAnnotationTypes.add(Autowired.class); //后置处理器将处理@Value注解 this.autowiredAnnotationTypes.add(Value.class); //获取当前类的类加载器 ClassLoader cl = AutowiredAnnotationBeanPostProcessor.class.getClassLoader(); try { //后置处理器将处理javax.inject.Inject JSR-330注解 this.autowiredAnnotationTypes.add((Class<? extends Annotation>) cl.loadClass("javax.inject.Inject")); logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring"); } catch (ClassNotFoundException ex) { // JSR-330 API not available - simply skip. } }  

 

(2).为指定类选择其合适的构造方法：

容器对指定类进行自动依赖注入装配(autowiring)时，容器需要对Bean调用合适的构造方法创建实例对象，AutowiredAnnotationBeanPostProcessor为指定类选择相应的构造方法，源码如下：

//为自动依赖注入装配Bean选择合适的构造方法 public Constructor[] determineCandidateConstructors(Class beanClass, String beanName) throws BeansException { //首先从容器的缓存中查找是否有指定Bean的构造方法 Constructor[] candidateConstructors = this.candidateConstructorsCache.get(beanClass); ／/容器缓存中没有给定类的构造方法 if (candidateConstructors == null) { //线程同步以确保容器中数据一致性 synchronized (this.candidateConstructorsCache) { candidateConstructors = this.candidateConstructorsCache.get(beanClass); if (candidateConstructors == null) { //通过JDK反射机制，获取指定类的中所有声明的构造方法 Constructor[] rawCandidates = beanClass.getDeclaredConstructors(); //存放候选构造方法的集合 List<Constructor> candidates = new ArrayList<Constructor>(rawCandidates.length); //autowire注解中required属性指定的构造方法 Constructor requiredConstructor = null; //默认的构造方法 Constructor defaultConstructor = null; //遍历所有的构造方法，检查是否添加了autowire注解，以及是否 //指定了required属性 for (Constructor<?> candidate : rawCandidates) { //获取指定类中所有关于autowire的注解(Annotation) Annotation annotation = findAutowiredAnnotation(candidate); //如果指定类中有关于antowire的注解 if (annotation != null) { //如果antowire注解中指定了required属性 if (requiredConstructor != null) { throw new BeanCreationException("Invalid autowire-marked constructor: " + candidate + ". Found another constructor with 'required' Autowired annotation: " + requiredConstructor); } //如果autowire注解的参数列表为空 if (candidate.getParameterTypes().length == 0) { throw new IllegalStateException( "Autowired annotation requires at least one argument: " + candidate); } //获取autowire注解中required属性值 boolean required = determineRequiredStatus(annotation); //如果获取到autowire注解中required的属性值 if (required) { //如果候选构造方法集合不为空 if (!candidates.isEmpty()) { throw new BeanCreationException( "Invalid autowire-marked constructors: " + candidates + ". Found another constructor with 'required' Autowired annotation: " + requiredConstructor); } //当前的构造方法就是required属性所配置的构造方法 requiredConstructor = candidate; } //将当前的构造方法添加到哦啊候选构造方法集合中 candidates.add(candidate); } //如果类中没有autowire的相关注解，并且构造方法参数列表为空 else if (candidate.getParameterTypes().length == 0) { //当前的构造方法是默认构造方法 defaultConstructor = candidate; } } //如果候选构造方法集合不为空 if (!candidates.isEmpty()) { //如果所有的构造方法都没有配置required属性，且有默认构造方法 if (requiredConstructor == null && defaultConstructor != null) { //将默认构造方法添加到候选构造方法列表 candidates.add(defaultConstructor); } //将候选构造方法集合转换为数组 candidateConstructors = candidates.toArray(new Constructor[candidates.size()]); } //如果候选构造方法集合为空，则创建一个空的数组 else { candidateConstructors = new Constructor[0]; } //将类的候选构造方法集合存放到容器的缓存中 this.candidateConstructorsCache.put(beanClass, candidateConstructors); } } } //返回指定类的候选构造方法数组，如果没有返回null return (candidateConstructors.length > 0 ? candidateConstructors : null); }  

 

(3).AutowiredAnnotationBeanPostProcessor对方法和属性的依赖注入：

当Spring容器对配置了autowire相关注解的Bean进行依赖注入时，后置处理器对属性和对象进行自动注入处理，源码如下：

//处理类中的属性 public PropertyValues postProcessPropertyValues( PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException { //获取指定类中autowire相关注解的元信息 InjectionMetadata metadata = findAutowiringMetadata(bean.getClass()); try { //对Bean的属性进行自动注入 metadata.inject(bean, beanName, pvs); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex); } return pvs; } //处理对象的注入 public void processInjection(Object bean) throws BeansException { //获取给定Bean的Class对象 Class<?> clazz = bean.getClass(); //获取给定类中autowire相关注解元信息 InjectionMetadata metadata = findAutowiringMetadata(clazz); try { //对Bean对象进行自动注入 metadata.inject(bean, null, null); } catch (Throwable ex) { throw new BeanCreationException("Injection of autowired dependencies failed for class [" + clazz + "]", ex); } } //获取给定类的autowire相关注解元信息 private InjectionMetadata findAutowiringMetadata(Class clazz) { //首先从容器中查找是否有给定类的autowire相关注解元信息 InjectionMetadata metadata = this.injectionMetadataCache.get(clazz); if (metadata == null) { synchronized (this.injectionMetadataCache) { metadata = this.injectionMetadataCache.get(clazz); if (metadata == null) { //解析给定类autowire相关注解元信息 metadata = buildAutowiringMetadata(clazz); //将得到的给定类autowire相关注解元信息存储在容器缓存中 this.injectionMetadataCache.put(clazz, metadata); } } } return metadata; } //解析给定类autowire相关注解元信息 private InjectionMetadata buildAutowiringMetadata(Class clazz) { //创建一个存放注解元信息的集合 LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>(); Class<?> targetClass = clazz; //递归遍历当前类及其所有基类，解析全部注解元信息 do { //创建一个存储当前正在处理类注解元信息的集合 LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<InjectionMetadata.InjectedElement>(); //利用JDK反射机制获取给定类中所有的声明字段，获取字段上的注解信息 for (Field field : targetClass.getDeclaredFields()) { //获取给定字段上的注解 Annotation annotation = findAutowiredAnnotation(field); if (annotation != null) { //如果给定字段是静态的(Static)，则直接遍历下一个字段 if (Modifier.isStatic(field.getModifiers())) { if (logger.isWarnEnabled()) { logger.warn("Autowired annotation is not supported on static fields: " + field); } continue; } //判断注解的required属性值是否有效 boolean required = determineRequiredStatus(annotation); //将当前字段元信息封装，添加在返回的集合中 currElements.add(new AutowiredFieldElement(field, required)); } } //利用JDK反射机制获取给定类中所有的声明方法，获取方法上的注解信息 for (Method method : targetClass.getDeclaredMethods()) { //获取给定方法上的所有注解 Annotation annotation = findAutowiredAnnotation(method); if (annotation != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) { //如果方法是静态的，则直接遍历下一个方法 if (Modifier.isStatic(method.getModifiers())) { if (logger.isWarnEnabled()) { logger.warn("Autowired annotation is not supported on static methods: " + method); } continue; } //如果方法的参数列表为空 if (method.getParameterTypes().length == 0) { if (logger.isWarnEnabled()) { logger.warn("Autowired annotation should be used on methods with actual parameters: " + method); } } //判断注解的required属性值是否有效 boolean required = determineRequiredStatus(annotation); //获取当前方法的属性描述符，即方法是可读的(readable)getter方法， //还是可写的(writeable)setter方法 PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method); //将方法元信息封装添加到返回的元信息集合中 currElements.add(new AutowiredMethodElement(method, required, pd)); } } //将当前类的注解元信息存放到注解元信息集合中 elements.addAll(0, currElements); //获取给定类的父类 targetClass = targetClass.getSuperclass(); } //如果给定类有基类，并且基类不是Object，则递归获取其基类的元信息 while (targetClass != null && targetClass != Object.class); return new InjectionMetadata(clazz, elements); } //获取给定对象的autowire相关注解 private Annotation findAutowiredAnnotation(AccessibleObject ao) { //遍历所有autowire相关的注解:@Autowire、@Value以及JSR-330等 for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) { //获取给定对象上的指定类型的注解 Annotation annotation = ao.getAnnotation(type); if (annotation != null) { return annotation; } } return null; }  

 

(4).AutowiredAnnotation