注解驱动编程-MetadataReader以及多层次@Component注解派生及解析原理

骑猪看日落 2021-08-26 17:01 246阅读 0赞

可以结合这篇一起看：[https://blog.csdn.net/f641385712/article/details/88765470][https_blog.csdn.net_f641385712_article_details_88765470]

**元数据：数据的数据**。比如Class就是一种元数据。`Metadata`在`org.springframework.core.type`包名下，还有用于读取的子包`classreading`也是重要知识点。此体系大致的类结构列出如下图：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70 2][]  
  
可以看到顶层接口有两个：`ClassMetadata`和`AnnotatedTypeMetadata`

**元注解**：可以申明在其他注解上的注解，@Component、@Repeatable、@Documented 都属于元注解；

**注解的派生性**：注解A 申明了 @Component注解，则在bean的扫描中，被注解A标准的Class 也会被注册为Bean；  
Spring前期的每个版本都对派生性进行了解析的升级，从一层派生、二层派生到最终的递归扫描，目前已经完全支持。

**Spring版本**：5.0.6.RELEASE

**访问者模式**：分离数据结构与数据操作，解耦。可参考[https://blog.csdn.net/z69183787/article/details/78270406][https_blog.csdn.net_z69183787_article_details_78270406]

众所周知，Spring在扫描需要注入的Bean的过程中 会从 如下链路进行查找：

1、ClassPathBeanDefinitionScanner\#doScan

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    		Assert.notEmpty(basePackages, "At least one base package must be specified");
    		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
    		for (String basePackage : basePackages) {
    			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
    			for (BeanDefinition candidate : candidates) {

2、ClassPathScanningCandidateComponentProvider\#findCandidateComponents

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
    		if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
    			return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
    		}
    		else {
    			return scanCandidateComponents(basePackage);
    		}
    	}

3、进入private方法：ClassPathScanningCandidateComponentProvider\#scanCandidateComponents  
按照 classpath\*:/packages/\*\*/\*.class 路径规则找到所有匹配的class文件形成Resource数组，其实可以i发现后续的匹配都是基于MetadataReader信息的，所以MetadataReader的获取和数据结构在整个扫描及注册过程中起着重要的作用

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    		Set<BeanDefinition> candidates = new LinkedHashSet<>();
    		try {
    			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
    					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
    			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
    			boolean traceEnabled = logger.isTraceEnabled();
    			boolean debugEnabled = logger.isDebugEnabled();
    			for (Resource resource : resources) {
    				if (traceEnabled) {
    					logger.trace("Scanning " + resource);
    				}
    				if (resource.isReadable()) {
    					try {
    						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
    						if (isCandidateComponent(metadataReader)) {
    							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
    							sbd.setResource(resource);
    							sbd.setSource(resource);
    							if (isCandidateComponent(sbd)) {
    								if (debugEnabled) {
    									logger.debug("Identified candidate component class: " + resource);
    								}
    								candidates.add(sbd);
    							}
    							else {
    								if (debugEnabled) {
    									logger.debug("Ignored because not a concrete top-level class: " + resource);
    								}
    							}
    						}

4、使用元数据Reader工厂类CachingMetadataReaderFactory生成元信息读取类-SimpleMetadataReader，SimpleMetadataReader实现了 接口 MetadataReader：包括了class的元信息，annotation的元数据信息

blic interface MetadataReader {
    
    	/**
    	 * Return the resource reference for the class file.
    	 */
    	Resource getResource();
    
    	/**
    	 * Read basic class metadata for the underlying class.
    	 */
    	ClassMetadata getClassMetadata();
    
    	/**
    	 * Read full annotation metadata for the underlying class,
    	 * including metadata for annotated methods.
    	 */
    	AnnotationMetadata getAnnotationMetadata();
    
    }

SimpleMetadataReader 构造函数如下：可以发现所需的 annotationMetadata 元数据信息 就是 当下生成的 访问者 AnnotationMetadataReadingVisitor，之后会讲到这个类中是如何保存了所有 annotation相关的信息和数据结构。

SimpleMetadataReader(Resource resource, @Nullable ClassLoader classLoader) throws IOException {
    		InputStream is = new BufferedInputStream(resource.getInputStream());
    		ClassReader classReader;
    		try {
    			classReader = new ClassReader(is);
    		}
    		catch (IllegalArgumentException ex) {
    			throw new NestedIOException("ASM ClassReader failed to parse class file - " +
    					"probably due to a new Java class file version that isn't supported yet: " + resource, ex);
    		}
    		finally {
    			is.close();
    		}
    
    		AnnotationMetadataReadingVisitor visitor = new AnnotationMetadataReadingVisitor(classLoader);
    		classReader.accept(visitor, ClassReader.SKIP_DEBUG);
    
    		this.annotationMetadata = visitor;
    		// (since AnnotationMetadataReadingVisitor extends ClassMetadataReadingVisitor)
    		this.classMetadata = visitor;
    		this.resource = resource;
    	}

5、构造函数内部将某一个Resource的字节码读取至流中，并生成ClassReader（通过字节码的形式读取类信息，包括属性、方法、注解等）

6、ClassReader中的accept方法，分别访问和获取了 类的 类信息、注解、属性、方法等。访问类上的注解时，构造AnnotationMetadataReadingVisitor，注解元数据visitor。利用访问者模式，对ClassReader中的类信息进行解析

public void accept(final ClassVisitor classVisitor,
                final Attribute[] attrs, final int flags) {
            int u = header; // current offset in the class file
            char[] c = new char[maxStringLength]; // buffer used to read strings
    
            Context context = new Context();
            context.attrs = attrs;
            context.flags = flags;
            context.buffer = c;
            ......
            ......
            //跳过其他的解析，直接来到访问注解的地方
         // visits the class annotations and type annotations
            if (ANNOTATIONS && anns != 0) {
                for (int i = readUnsignedShort(anns), v = anns + 2; i > 0; --i) {
                    v = readAnnotationValues(v + 2, c, true,
                            classVisitor.visitAnnotation(readUTF8(v, c), true));
                }
            }
            if (ANNOTATIONS && ianns != 0) {
                for (int i = readUnsignedShort(ianns), v = ianns + 2; i > 0; --i) {
                    v = readAnnotationValues(v + 2, c, true,
                            classVisitor.visitAnnotation(readUTF8(v, c), false));
                }
            }
            if (ANNOTATIONS && tanns != 0) {
                for (int i = readUnsignedShort(tanns), v = tanns + 2; i > 0; --i) {
                    v = readAnnotationTarget(context, v);
                    v = readAnnotationValues(v + 2, c, true,
                            classVisitor.visitTypeAnnotation(context.typeRef,
                                    context.typePath, readUTF8(v, c), true));
                }
            }
            if (ANNOTATIONS && itanns != 0) {
                for (int i = readUnsignedShort(itanns), v = itanns + 2; i > 0; --i) {
                    v = readAnnotationTarget(context, v);
                    v = readAnnotationValues(v + 2, c, true,
                            classVisitor.visitTypeAnnotation(context.typeRef,
                                    context.typePath, readUTF8(v, c), false));
                }
            }

7、可以明显发现在readAnnotationValues方法中回调了AnnotationMetadataReadingVisitor中的visitAnnotation方法用来获取注解className

（除此之外，在解析完类上的注解以后，在readMethod（解析类中method的时候）也会访问method上的注解，同样也是通过AnnotationMetadataReadingVisitor 中的 visitMethod方法，使用MethodMetadataReadingVisitor填充methodMetadataSet 方法元数据 ）

注：观察发现，获取属性Field上的注解并非是使用的上述雷同的方式，使用的是ClassMetadataReadingVisitor中的内部类EmptyFieldVisitor类（没有细看，好像获取不到注解信息）

@Override
    	public AnnotationVisitor visitAnnotation(final String desc, boolean visible) {
    		String className = Type.getType(desc).getClassName();
    		this.annotationSet.add(className);
    		return new AnnotationAttributesReadingVisitor(
    				className, this.attributesMap, this.metaAnnotationMap, this.classLoader);
    	}
    
    @Override
    	public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
    		// Skip bridge methods - we're only interested in original annotation-defining user methods.
    		// On JDK 8, we'd otherwise run into double detection of the same annotated method...
    		if ((access & Opcodes.ACC_BRIDGE) != 0) {
    			return super.visitMethod(access, name, desc, signature, exceptions);
    		}
    		return new MethodMetadataReadingVisitor(name, access, getClassName(),
    				Type.getReturnType(desc).getClassName(), this.classLoader, this.methodMetadataSet);
    	}

8、返回一个新的vistor-AnnotationAttributesReadingVisitor，用于ClassReader中后续对 注解本身属性值的获取（MethodMetadataReadingVisitor中使用的也是这个visitor，用于采集方法上的注解元数据）

9、回到ClassReader中，观察readAnnotationValues方法的源码，基本就是使用生成的AnnotationAttributesReadingVisitor 解析 annotation attribute的值，并使用visitEnd进行收尾

private int readAnnotationValues(int v, final char[] buf,
                final boolean named, final AnnotationVisitor av) {
            int i = readUnsignedShort(v);
            v += 2;
            if (named) {
                for (; i > 0; --i) {
                    v = readAnnotationValue(v + 2, buf, readUTF8(v, buf), av);
                }
            } else {
                for (; i > 0; --i) {
                    v = readAnnotationValue(v, buf, null, av);
                }
            }
            if (av != null) {
                av.visitEnd();
            }
            return v;
        }

10、readAnnotationValue根据读取到的annotation属性名以及AnnotationAttributesReadingVisitor进行value的读取，其中会使用

到AnnotationAttributesReadingVisitor的父类AbstractRecursiveAnnotationVisitor的visit方法，不赘述

11、最后会使用AnnotationAttributesReadingVisitor自身的方法 visitEnd进行收尾，采用了递归的方式查找元注解，支持多层次@Component的派生性，可以明显看到代码中的递归逻辑

final class AnnotationAttributesReadingVisitor extends RecursiveAnnotationAttributesVisitor {
    
    	private final MultiValueMap<String, AnnotationAttributes> attributesMap;
    
    	private final Map<String, Set<String>> metaAnnotationMap;
    
    
    	public AnnotationAttributesReadingVisitor(String annotationType,
    			MultiValueMap<String, AnnotationAttributes> attributesMap, Map<String, Set<String>> metaAnnotationMap,
    			@Nullable ClassLoader classLoader) {
    
    		super(annotationType, new AnnotationAttributes(annotationType, classLoader), classLoader);
    		this.attributesMap = attributesMap;
    		this.metaAnnotationMap = metaAnnotationMap;
    	}
    
    
    	@Override
    	public void visitEnd() {
    		super.visitEnd();
    
    		Class<?> annotationClass = this.attributes.annotationType();
    		if (annotationClass != null) {
    			List<AnnotationAttributes> attributeList = this.attributesMap.get(this.annotationType);
    			if (attributeList == null) {
    				this.attributesMap.add(this.annotationType, this.attributes);
    			}
    			else {
    				attributeList.add(0, this.attributes);
    			}
    			Set<Annotation> visited = new LinkedHashSet<>();
    			Annotation[] metaAnnotations = AnnotationUtils.getAnnotations(annotationClass);
    			if (!ObjectUtils.isEmpty(metaAnnotations)) {
    				for (Annotation metaAnnotation : metaAnnotations) {
    					if (!AnnotationUtils.isInJavaLangAnnotationPackage(metaAnnotation)) {
    						recursivelyCollectMetaAnnotations(visited, metaAnnotation);
    					}
    				}
    			}
    			Set<String> metaAnnotationTypeNames = new LinkedHashSet<>(visited.size());
    			for (Annotation ann : visited) {
    				metaAnnotationTypeNames.add(ann.annotationType().getName());
    			}
    			this.metaAnnotationMap.put(annotationClass.getName(), metaAnnotationTypeNames);
    		}
    	}
    
    	private void recursivelyCollectMetaAnnotations(Set<Annotation> visited, Annotation annotation) {
    		Class<? extends Annotation> annotationType = annotation.annotationType();
    		String annotationName = annotationType.getName();
    		if (!AnnotationUtils.isInJavaLangAnnotationPackage(annotationName) && visited.add(annotation)) {
    			try {
    				// Only do attribute scanning for public annotations; we'd run into
    				// IllegalAccessExceptions otherwise, and we don't want to mess with
    				// accessibility in a SecurityManager environment.
    				if (Modifier.isPublic(annotationType.getModifiers())) {
    					this.attributesMap.add(annotationName,
    							AnnotationUtils.getAnnotationAttributes(annotation, false, true));
    				}
    				for (Annotation metaMetaAnnotation : annotationType.getAnnotations()) {
    					recursivelyCollectMetaAnnotations(visited, metaMetaAnnotation);
    				}
    			}
    			catch (Throwable ex) {
    				if (logger.isDebugEnabled()) {
    					logger.debug("Failed to introspect meta-annotations on [" + annotation + "]: " + ex);
    				}
    			}
    		}
    	}
    
    }

12、可以发现的是 在 AnnotationMetadataReadingVisitor 构造 AnnotationAttributesReadingVisitor 属性解析器时，将AnnotationMetadataReadingVisitor对象中的

*  className：对应 AnnotationAttributesReadingVisitor 的 annotationType：当前字节码读取到的注解ClassName
 *  attributesMap \# LinkedMultiValueMap<String, AnnotationAttributes>：存放的是顶层注解与所有元注解与属性值的对应关系，AnnotationAttributes的底层实现实际上就是一个linkedhashmap
 *  metaAnnotationMap \# Map<String, Set<String>>：元注解Map，保存了顶层注解Annotation className和它的所有元注解（即根据递归查找找到的Annotation ClassName）
 *  classLoader：类加载器

在AnnotationAttributesReadingVisitor对象中，有如下属性

*  annotationType：一级父类RecursiveAnnotationAttributesVisitor的属性 对应传入的className，当前注解的全类名
 *  attributesMap ：同上
 *  metaAnnotationMap \# Map<String, Set<String>>：同上
 *  classLoader：同上
 *  attributes：二级父类AbstractRecursiveAnnotationVisitor的属性，存放当前AnnotationAttributes对象，包含annotationType和classLoader

在visitEnd方式中递归查找元注解时分别对attributesMap 及 metaAnnotationMap 进行填充。

最后：AnnotationMetadataReadingVisitor 对象提供如下get方法，获取和注解相关的数据信息

1、返回当前class的顶层注解（即直接标注在candidate bean上的 annotation）

public Set<String> getAnnotationTypes() { return this.annotationSet; }

2、根据顶层注解获取它的所有元注解className

public Set<String> getMetaAnnotationTypes(String annotationName) {
    		return this.metaAnnotationMap.get(annotationName);
    	}

3、是否包含某个顶层注解

public boolean hasAnnotation(String annotationName) {
    		return this.annotationSet.contains(annotationName);
    	}

4、是否包含某个元注解（可以理解为深层次注解），顶层注解除外

@Override
    	public boolean hasMetaAnnotation(String metaAnnotationType) {
    		Collection<Set<String>> allMetaTypes = this.metaAnnotationMap.values();
    		for (Set<String> metaTypes : allMetaTypes) {
    			if (metaTypes.contains(metaAnnotationType)) {
    				return true;
    			}
    		}
    		return false;
    	}

5、是否被注解（顶层+元注解）

@Override
    	public boolean isAnnotated(String annotationName) {
    		return (!AnnotationUtils.isInJavaLangAnnotationPackage(annotationName) &&
    				this.attributesMap.containsKey(annotationName));
    	}

6、获取注解的属性，可以自行查看源码

@Override
    	@Nullable
    	public AnnotationAttributes getAnnotationAttributes(String annotationName) {
    		return getAnnotationAttributes(annotationName, false);
    	}
    
    	@Override
    	@Nullable
    	public AnnotationAttributes getAnnotationAttributes(String annotationName, boolean classValuesAsString) {
    		AnnotationAttributes raw = AnnotationReadingVisitorUtils.getMergedAnnotationAttributes(
    				this.attributesMap, this.metaAnnotationMap, annotationName);
    		if (raw == null) {
    			return null;
    		}
    		return AnnotationReadingVisitorUtils.convertClassValues(
    				"class '" + getClassName() + "'", this.classLoader, raw, classValuesAsString);
    	}
    
    	@Override
    	@Nullable
    	public MultiValueMap<String, Object> getAllAnnotationAttributes(String annotationName) {
    		return getAllAnnotationAttributes(annotationName, false);
    	}

[https_blog.csdn.net_f641385712_article_details_88765470]: https://blog.csdn.net/f641385712/article/details/88765470
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70]: /images/20210527/32c0ec1c575c490c9456133b835a6f7b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70 1]: /images/20210527/9414bcfe41c24274a23f716f2ca3916c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70 2]: /images/20210527/52b7b3842ddb4fcd9f22231a33ba8a56.png
[https_blog.csdn.net_z69183787_article_details_78270406]: https://blog.csdn.net/z69183787/article/details/78270406