Spring 元信息

ClassMetadata

  1. public interface ClassMetadata {
  3.     /**
  4.      * 类名
  5.      */
  6.     String getClassName();
  8.     /**
  9.      * 是否是接口
  10.      */
  11.     boolean isInterface();
  13.     /**
  14.      * 是否是注解
  15.      */
  16.     boolean isAnnotation();
  18.     /**
  19.      * 是否是超类
  20.      */
  21.     boolean isAbstract();
  23.     /**
  24.      * 是否允许创建,实例化
  25.      */
  26.     default boolean isConcrete() {
  27.         return !(isInterface() || isAbstract());
  28.     }
  30.     /**
  31.      * 是否有final修饰
  32.      */
  33.     boolean isFinal();
  35.     /**
  36.      * 是否独立
  37.      */
  38.     boolean isIndependent();
  40.     /**
  41.      * 是否有内部类
  42.      */
  43.     default boolean hasEnclosingClass() {
  44.         return (getEnclosingClassName() != null);
  45.     }
  47.     /**
  48.      * 是否是基础类
  49.      */
  50.     @Nullable
  51.     String getEnclosingClassName();
  53.     /**
  54.      * 是否有父类
  55.      */
  56.     default boolean hasSuperClass() {
  57.         return (getSuperClassName() != null);
  58.     }
  60.     /**
  61.      * 父类名称
  62.      */
  63.     @Nullable
  64.     String getSuperClassName();
  66.     /**
  67.      * 实现类名称列表
  68.      */
  69.     String[] getInterfaceNames();
  71.     /**
  72.      * 成员列表
  73.      * @since 3.1
  74.      */
  75.     String[] getMemberClassNames();
  77. }

image-20200824094154847

AnnotatedTypeMetadata

  1. public interface AnnotatedTypeMetadata {
  3.     /**
  4.      * 获取所有注解
  5.      */
  6.     MergedAnnotations getAnnotations();
  8.     /**
  9.      * 是否有注解
  10.      */
  11.     default boolean isAnnotated(String annotationName) {
  12.         return getAnnotations().isPresent(annotationName);
  13.     }
  15.     /**
  16.      * 获取注解的属性
  17.      */
  18.     @Nullable
  19.     default Map<String, Object> getAnnotationAttributes(String annotationName) {
  20.         return getAnnotationAttributes(annotationName, false);
  21.     }
  22.     // 省略其他
  24. }

AnnotationMetadata

  1. public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata {
  3.    /**
  4.      * 获取注解名称,全类名
  5.     */
  6.    default Set<String> getAnnotationTypes() {
  7.       return getAnnotations().stream()
  8.             .filter(MergedAnnotation::isDirectlyPresent)
  9.             .map(annotation -> annotation.getType().getName())
  10.             .collect(Collectors.toCollection(LinkedHashSet::new));
  11.    }
  13.    /**
  14.      * 注解全类名
  15.     */
  16.    default Set<String> getMetaAnnotationTypes(String annotationName) {
  17.       MergedAnnotation<?> annotation = getAnnotations().get(annotationName, MergedAnnotation::isDirectlyPresent);
  18.       if (!annotation.isPresent()) {
  19.          return Collections.emptySet();
  20.       }
  21.       return MergedAnnotations.from(annotation.getType(), SearchStrategy.INHERITED_ANNOTATIONS).stream()
  22.             .map(mergedAnnotation -> mergedAnnotation.getType().getName())
  23.             .collect(Collectors.toCollection(LinkedHashSet::new));
  24.    }
  26.    /**
  27.      * 是否包含某个注解
  28.     */
  29.    default boolean hasAnnotation(String annotationName) {
  30.       return getAnnotations().isDirectlyPresent(annotationName);
  31.    }
  33.    /**
  34.      * 是否被某个注解标记过
  35.     */
  36.    default boolean hasMetaAnnotation(String metaAnnotationName) {
  37.       return getAnnotations().get(metaAnnotationName,
  38.             MergedAnnotation::isMetaPresent).isPresent();
  39.    }
  41.    /**
  42.      * 是否有注解,类里面有一个注解就返回true
  43.     */
  44.    default boolean hasAnnotatedMethods(String annotationName) {
  45.       return !getAnnotatedMethods(annotationName).isEmpty();
  46.    }
  48.    /**
  49.      * 获取包含注解的方法
  50.     */
  51.    Set<MethodMetadata> getAnnotatedMethods(String annotationName);
  54.    /**
  55.      * 通过反射创建一个注解的元信息
  56.     */
  57.    static AnnotationMetadata introspect(Class<?> type) {
  58.       return StandardAnnotationMetadata.from(type);
  59.    }
  61. }

MethodMetadata

  1. public interface MethodMetadata extends AnnotatedTypeMetadata {
  3.     /**
  4.      * 方法名称
  5.      */
  6.     String getMethodName();
  8.     /**
  9.      * 方法全路径
  10.      */
  11.     String getDeclaringClassName();
  13.     /**
  14.      * 返回值类型
  15.      */
  16.     String getReturnTypeName();
  18.     /**
  19.      * 是不是abstrac修饰
  20.      */
  21.     boolean isAbstract();
  23.     /**
  24.      * 是否 static 修饰
  25.      */
  26.     boolean isStatic();
  28.     /**
  29.      * 是否 final 修饰
  30.      */
  31.     boolean isFinal();
  33.     /**
  34.      * 是否重载
  35.      */
  36.     boolean isOverridable();
  38. }

MetadataReader

  1. public interface MetadataReader {
  3.     /**
  4.      * Return the resource reference for the class file.
  5.      *
  6.      * 获取资源
  7.      */
  8.     Resource getResource();
  10.     /**
  11.      * Read basic class metadata for the underlying class.
  12.      * 获取类的元信息
  13.      */
  14.     ClassMetadata getClassMetadata();
  16.     /**
  17.      * Read full annotation metadata for the underlying class,
  18.      * including metadata for annotated methods.
  19.      *
  20.      * 获取注解的元信息
  21.      */
  22.     AnnotationMetadata getAnnotationMetadata();
  24. }

MetadataReaderFactory

  • 用来创建 MetadataReader
  1. public interface MetadataReaderFactory {
  3.     /**
  4.      * Obtain a MetadataReader for the given class name.
  5.      * @param className the class name (to be resolved to a ".class" file)
  6.      * @return a holder for the ClassReader instance (never {@code null})
  7.      * @throws IOException in case of I/O failure
  8.      */
  9.     MetadataReader getMetadataReader(String className) throws IOException;
  11.     /**
  12.      * Obtain a MetadataReader for the given resource.
  13.      * @param resource the resource (pointing to a ".class" file)
  14.      * @return a holder for the ClassReader instance (never {@code null})
  15.      * @throws IOException in case of I/O failure
  16.      */
  17.     MetadataReader getMetadataReader(Resource resource) throws IOException;
  19. }
  • 接口解释的差不多了.接下来看一些实现

StandardClassMetadata

  • 通过 JAVA 反射来获取类的元信息

  • 这个类采用的方式是 Java class 的方法,通过构造方法来填写一个 Class 对象. 之后使用这个对象的方法

  1. public class StandardClassMetadata implements ClassMetadata {
  3.    private final Class<?> introspectedClass;
  5.    @Deprecated
  6.    public StandardClassMetadata(Class<?> introspectedClass) {
  7.       Assert.notNull(introspectedClass, "Class must not be null");
  8.       this.introspectedClass = introspectedClass;
  9.    }
  11.    /**
  12.     * Return the underlying Class.
  13.     */
  14.    public final Class<?> getIntrospectedClass() {
  15.       return this.introspectedClass;
  16.    }
  19.    @Override
  20.    public String getClassName() {
  21.       return this.introspectedClass.getName();
  22.    }
  24.    @Override
  25.    public boolean isInterface() {
  26.       return this.introspectedClass.isInterface();
  27.    }
  29.    @Override
  30.    public boolean isAnnotation() {
  31.       return this.introspectedClass.isAnnotation();
  32.    }
  34.    @Override
  35.    public boolean isAbstract() {
  36.       return Modifier.isAbstract(this.introspectedClass.getModifiers());
  37.    }
  39.    @Override
  40.    public boolean isFinal() {
  41.       return Modifier.isFinal(this.introspectedClass.getModifiers());
  42.    }
  44.    @Override
  45.    public boolean isIndependent() {
  46.       return (!hasEnclosingClass() ||
  47.             (this.introspectedClass.getDeclaringClass() != null &&
  48.                   Modifier.isStatic(this.introspectedClass.getModifiers())));
  49.    }
  51.    @Override
  52.    @Nullable
  53.    public String getEnclosingClassName() {
  54.       Class<?> enclosingClass = this.introspectedClass.getEnclosingClass();
  55.       return (enclosingClass != null ? enclosingClass.getName() : null);
  56.    }
  58.    @Override
  59.    @Nullable
  60.    public String getSuperClassName() {
  61.       Class<?> superClass = this.introspectedClass.getSuperclass();
  62.       return (superClass != null ? superClass.getName() : null);
  63.    }
  65.    @Override
  66.    public String[] getInterfaceNames() {
  67.       Class<?>[] ifcs = this.introspectedClass.getInterfaces();
  68.       String[] ifcNames = new String[ifcs.length];
  69.       for (int i = 0; i < ifcs.length; i++) {
  70.          ifcNames[i] = ifcs[i].getName();
  71.       }
  72.       return ifcNames;
  73.    }
  75.    @Override
  76.    public String[] getMemberClassNames() {
  77.       LinkedHashSet<String> memberClassNames = new LinkedHashSet<>(4);
  78.       for (Class<?> nestedClass : this.introspectedClass.getDeclaredClasses()) {
  79.          memberClassNames.add(nestedClass.getName());
  80.       }
  81.       return StringUtils.toStringArray(memberClassNames);
  82.    }
  84. }

StandardMethodMetadata

  • 通过 java 反射获取方法的元信息
  • 构造方法传递一个 method
    • 如果这个方法有注解，会进行注解的解析
  1. public class StandardMethodMetadata implements MethodMetadata {
  3.    private final Method introspectedMethod;
  5.    private final boolean nestedAnnotationsAsMap;
  7.    private final MergedAnnotations mergedAnnotations;
  9.    @Deprecated
  10.    public StandardMethodMetadata(Method introspectedMethod) {
  11.       this(introspectedMethod, false);
  12.    }
  15.    @Deprecated
  16.    public StandardMethodMetadata(Method introspectedMethod, boolean nestedAnnotationsAsMap) {
  17.       Assert.notNull(introspectedMethod, "Method must not be null");
  18.       this.introspectedMethod = introspectedMethod;
  19.       this.nestedAnnotationsAsMap = nestedAnnotationsAsMap;
  20.       this.mergedAnnotations = MergedAnnotations.from(
  21.             introspectedMethod, SearchStrategy.DIRECT, RepeatableContainers.none());
  22.    }
  25.    @Override
  26.    public MergedAnnotations getAnnotations() {
  27.       return this.mergedAnnotations;
  28.    }
  30.    /**
  31.     * Return the underlying Method.
  32.     */
  33.    public final Method getIntrospectedMethod() {
  34.       return this.introspectedMethod;
  35.    }
  37.    @Override
  38.    public String getMethodName() {
  39.       return this.introspectedMethod.getName();
  40.    }
  42.    @Override
  43.    public String getDeclaringClassName() {
  44.       return this.introspectedMethod.getDeclaringClass().getName();
  45.    }
  47.    @Override
  48.    public String getReturnTypeName() {
  49.       return this.introspectedMethod.getReturnType().getName();
  50.    }
  52.    @Override
  53.    public boolean isAbstract() {
  54.       return Modifier.isAbstract(this.introspectedMethod.getModifiers());
  55.    }
  57.    @Override
  58.    public boolean isStatic() {
  59.       return Modifier.isStatic(this.introspectedMethod.getModifiers());
  60.    }
  62.    @Override
  63.    public boolean isFinal() {
  64.       return Modifier.isFinal(this.introspectedMethod.getModifiers());
  65.    }
  67.    @Override
  68.    public boolean isOverridable() {
  69.       return !isStatic() && !isFinal() && !isPrivate();
  70.    }
  72.    private boolean isPrivate() {
  73.       return Modifier.isPrivate(this.introspectedMethod.getModifiers());
  74.    }
  76.    @Override
  77.    @Nullable
  78.    public Map<String, Object> getAnnotationAttributes(String annotationName, boolean classValuesAsString) {
  79.       if (this.nestedAnnotationsAsMap) {
  80.          return MethodMetadata.super.getAnnotationAttributes(annotationName, classValuesAsString);
  81.       }
  82.       return AnnotatedElementUtils.getMergedAnnotationAttributes(this.introspectedMethod,
  83.             annotationName, classValuesAsString, false);
  84.    }
  86.     /**
  87.      * 获取所有注解的信息
  88.      */
  89.    @Override
  90.    @Nullable
  91.    public MultiValueMap<String, Object> getAllAnnotationAttributes(String annotationName, boolean classValuesAsString) {
  92.       if (this.nestedAnnotationsAsMap) {
  93.          return MethodMetadata.super.getAllAnnotationAttributes(annotationName, classValuesAsString);
  94.       }
  95.       return AnnotatedElementUtils.getAllAnnotationAttributes(this.introspectedMethod,
  96.             annotationName, classValuesAsString, false);
  97.    }
  99. }

StandardAnnotationMetadata

  • StandardAnnotationMetadata 是 StandardClassMetadata 的子类

  • 还是一个基于 JAVA 反射做的一个类

  • 获取注解属性 map

  1. @Override
  2. @Nullable
  3. public Map<String, Object> getAnnotationAttributes(String annotationName, boolean classValuesAsString) {
  4.    if (this.nestedAnnotationsAsMap) {
  5.       return AnnotationMetadata.super.getAnnotationAttributes(annotationName, classValuesAsString);
  6.    }
  7.    return AnnotatedElementUtils.getMergedAnnotationAttributes(
  8.          getIntrospectedClass(), annotationName, classValuesAsString, false);
  9. }
  • org.springframework.core.annotation.AnnotatedElementUtils#getMergedAnnotationAttributes(java.lang.reflect.AnnotatedElement, java.lang.String, boolean, boolean)
    • org.springframework.core.annotation.AnnotatedElementUtils#getAnnotationAttributes
      • org.springframework.core.annotation.MergedAnnotation#asAnnotationAttributes
  1. @Nullable
  2. public static AnnotationAttributes getMergedAnnotationAttributes(AnnotatedElement element,
  3.         String annotationName, boolean classValuesAsString, boolean nestedAnnotationsAsMap) {
  5.     MergedAnnotation<?> mergedAnnotation = getAnnotations(element)
  6.             .get(annotationName, null, MergedAnnotationSelectors.firstDirectlyDeclared());
  7.     return getAnnotationAttributes(mergedAnnotation, classValuesAsString, nestedAnnotationsAsMap);
  8. }
  • 查看这个方法的源码借助测试类org.springframework.core.annotation.AnnotatedElementUtilsTests#getMergedAnnotationAttributesOnClassWithLocalAnnotation
  • getAnnotations() 方法

getAnnotations

  • org.springframework.core.annotation.MergedAnnotations#from(java.lang.reflect.AnnotatedElement, org.springframework.core.annotation.MergedAnnotations.SearchStrategy, org.springframework.core.annotation.RepeatableContainers)

    • org.springframework.core.annotation.TypeMappedAnnotations#from(java.lang.reflect.AnnotatedElement, org.springframework.core.annotation.MergedAnnotations.SearchStrategy, org.springframework.core.annotation.RepeatableContainers, org.springframework.core.annotation.AnnotationFilter)

  • 最终我们找到的代码如下

  1. static MergedAnnotations from(AnnotatedElement element, SearchStrategy searchStrategy,
  2.       RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter) {
  4.    if (AnnotationsScanner.isKnownEmpty(element, searchStrategy)) {
  5.       return NONE;
  6.    }
  7.    return new TypeMappedAnnotations(element, searchStrategy, repeatableContainers, annotationFilter);
  8. }
  • 判断是否为空. 为空返回 None，不会为空构造出一个对象 org.springframework.core.annotation.TypeMappedAnnotations

MergedAnnotations

  1. public interface MergedAnnotations extends Iterable<MergedAnnotation<Annotation>> {
  3.     //确定注解是否存在
  4.     <A extends Annotation> boolean isPresent(Class<A> annotationType);
  5.     //注解是否直接存在
  6.     <A extends Annotation> boolean isDirectlyPresent(Class<A> annotationType);
  7.     // 获取匹配的注解
  8.     <A extends Annotation> MergedAnnotation<A> get(Class<A> annotationType);
  9.         // 省略其他
  11. }

  • 这个接口中还有两个方法

    1. of 将多个MergedAnnotations合并

    2. from

      将多个注解合并

SearchStrategy

  1. enum SearchStrategy {
  3.    /**
  4.     * Find only directly declared annotations, without considering
  5.     * {@link Inherited @Inherited} annotations and without searching
  6.     * superclasses or implemented interfaces.
  7.         *
  8.         * 直接查找
  9.     */
  10.    DIRECT,
  12.    /**
  13.     * Find all directly declared annotations as well as any
  14.     * {@link Inherited @Inherited} superclass annotations. This strategy
  15.     * is only really useful when used with {@link Class} types since the
  16.     * {@link Inherited @Inherited} annotation is ignored for all other
  17.     * {@linkplain AnnotatedElement annotated elements}. This strategy does
  18.     * not search implemented interfaces.
  19.         *
  20.         * 继承查找
  21.     */
  22.    INHERITED_ANNOTATIONS,
  24.    /**
  25.     * Find all directly declared and superclass annotations. This strategy
  26.     * is similar to {@link #INHERITED_ANNOTATIONS} except the annotations
  27.     * do not need to be meta-annotated with {@link Inherited @Inherited}.
  28.     * This strategy does not search implemented interfaces.
  29.         * 查找当前类和父类的注解
  30.     */
  31.    SUPERCLASS,
  33.    /**
  34.     * Perform a full search of the entire type hierarchy, including
  35.     * superclasses and implemented interfaces. Superclass annotations do
  36.     * not need to be meta-annotated with {@link Inherited @Inherited}.
  37.     */
  38.    TYPE_HIERARCHY,
  40.    /**
  41.     * Perform a full search of the entire type hierarchy on the source
  42.     * <em>and</em> any enclosing classes. This strategy is similar to
  43.     * {@link #TYPE_HIERARCHY} except that {@linkplain Class#getEnclosingClass()
  44.     * enclosing classes} are also searched. Superclass annotations do not
  45.     * need to be meta-annotated with {@link Inherited @Inherited}. When
  46.     * searching a {@link Method} source, this strategy is identical to
  47.     * {@link #TYPE_HIERARCHY}.
  48.     */
  49.    TYPE_HIERARCHY_AND_ENCLOSING_CLASSES
  50. }
  • org.springframework.core.annotation.TypeMappedAnnotations#get(java.lang.String, java.util.function.Predicate<? super org.springframework.core.annotation.MergedAnnotation<A>>, org.springframework.core.annotation.MergedAnnotationSelector<A>)
  1. @Override
  2. public <A extends Annotation> MergedAnnotation<A> get(String annotationType,
  3.       @Nullable Predicate<? super MergedAnnotation<A>> predicate,
  4.       @Nullable MergedAnnotationSelector<A> selector) {
  5.        // 匹配校验
  6.    if (this.annotationFilter.matches(annotationType)) {
  7.       return MergedAnnotation.missing();
  8.    }
  9.    MergedAnnotation<A> result = scan(annotationType,
  10.          new MergedAnnotationFinder<>(annotationType, predicate, selector));
  11.    return (result != null ? result : MergedAnnotation.missing());
  12. }

Scan

org.springframework.core.annotation.AnnotationsScanner#scan(C, java.lang.reflect.AnnotatedElement, org.springframework.core.annotation.MergedAnnotations.SearchStrategy, org.springframework.core.annotation.AnnotationsProcessor<C,R>, java.util.function.BiPredicate<C,java.lang.Class<?>>)

  1. @Nullable
  2. static <C, R> R scan(C context, AnnotatedElement source, SearchStrategy searchStrategy,
  3.       AnnotationsProcessor<C, R> processor, @Nullable BiPredicate<C, Class<?>> classFilter) {
  5.    R result = process(context, source, searchStrategy, processor, classFilter);
  6.    return processor.finish(result);
  7. }

在这个里面重点关注PROCESS方法

  1. @Nullable
  2. private static <C, R> R process(C context, AnnotatedElement source,
  3.       SearchStrategy searchStrategy, AnnotationsProcessor<C, R> processor,
  4.       @Nullable BiPredicate<C, Class<?>> classFilter) {
  6.    if (source instanceof Class) {
  7.       return processClass(context, (Class<?>) source, searchStrategy, processor, classFilter);
  8.    }
  9.    if (source instanceof Method) {
  10.       return processMethod(context, (Method) source, searchStrategy, processor, classFilter);
  11.    }
  12.    return processElement(context, source, processor, classFilter);
  13. }

测试类

  1.     @Transactional("TxConfig")
  2.     static class TxConfig {
  3.     }

显然这是一个类他会走processClass方法

  • 根据扫描方式进行扫描
  1. @Nullable
  2. private static <C, R> R processClass(C context, Class<?> source,
  3.       SearchStrategy searchStrategy, AnnotationsProcessor<C, R> processor,
  4.       @Nullable BiPredicate<C, Class<?>> classFilter) {
  6.    switch (searchStrategy) {
  7.       case DIRECT:
  8.          return processElement(context, source, processor, classFilter);
  9.       case INHERITED_ANNOTATIONS:
  10.          return processClassInheritedAnnotations(context, source, searchStrategy, processor, classFilter);
  11.       case SUPERCLASS:
  12.          return processClassHierarchy(context, source, processor, classFilter, false, false);
  13.       case TYPE_HIERARCHY:
  14.          return processClassHierarchy(context, source, processor, classFilter, true, false);
  15.       case TYPE_HIERARCHY_AND_ENCLOSING_CLASSES:
  16.          return processClassHierarchy(context, source, processor, classFilter, true, true);
  17.    }
  18.    throw new IllegalStateException("Unsupported search strategy " + searchStrategy);
  19. }
  • 扫描的形式就不贴出完整代码了

finish就包装一下返回.

  • 此时org.springframework.core.annotation.AnnotatedElementUtils#getMergedAnnotationAttributes(java.lang.reflect.AnnotatedElement, java.lang.String, boolean, boolean)这个方法走到了最后一步org.springframework.core.annotation.AnnotatedElementUtils#getAnnotationAttributes

  • 最后的组装 map 方法

    org.springframework.core.annotation.TypeMappedAnnotation#asMap(java.util.function.Function<org.springframework.core.annotation.MergedAnnotation<?>,T>, org.springframework.core.annotation.MergedAnnotation.Adapt...)

  1. @Override
  2. public AnnotationAttributes asAnnotationAttributes(Adapt... adaptations) {
  3.    return asMap(mergedAnnotation -> new AnnotationAttributes(mergedAnnotation.getType()), adaptations);
  4. }
  1. @Override
  2. public <T extends Map<String, Object>> T asMap(Function<MergedAnnotation<?>, T> factory, Adapt... adaptations) {
  3.    T map = factory.apply(this);
  4.    Assert.state(map != null, "Factory used to create MergedAnnotation Map must not return null");
  5.    AttributeMethods attributes = this.mapping.getAttributes();
  6.    for (int i = 0; i < attributes.size(); i++) {
  7.       Method attribute = attributes.get(i);
  8.       Object value = (isFiltered(attribute.getName()) ? null :
  9.             getValue(i, getTypeForMapOptions(attribute, adaptations)));
  10.       if (value != null) {
  11.          map.put(attribute.getName(),
  12.                adaptValueForMapOptions(attribute, value, map.getClass(), factory, adaptations));
  13.       }
  14.    }
  15.    return map;
  16. }

  • 获取属性列表,循环, 放入 map 返回.

    map

    ​ key: 注解的函数

    ​ value: 函数对应的值

  1. @Transactional("TxConfig")
  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target({ElementType.TYPE, ElementType.METHOD})
  3. @Inherited
  4. @interface Transactional {
  6.    String value() default "";
  8.    String qualifier() default "transactionManager";
  10.    boolean readOnly() default false;
  11. }

如果是上面这样的结构那么返回值为

  1. value:TxConfig
  2. qulifiter:transactionManager
  3. readOnlay:false

image-20200824104529315

SimpleMetadataReader

  • 构造方法传递三个参数直接使用

    ```java final class SimpleMetadataReader implements MetadataReader {

    private static final int PARSING_OPTIONS = ClassReader.SKIP_DEBUG

    1.      | ClassReader.SKIP_CODE | ClassReader.SKIP_FRAMES;

    private final Resource resource;

    private final AnnotationMetadata annotationMetadata;

  1.  SimpleMetadataReader(Resource resource, @Nullable ClassLoader classLoader) throws IOException {
  2.     SimpleAnnotationMetadataReadingVisitor visitor = new SimpleAnnotationMetadataReadingVisitor(classLoader);
  3.     getClassReader(resource).accept(visitor, PARSING_OPTIONS);
  4.     this.resource = resource;
  5.     this.annotationMetadata = visitor.getMetadata();
  6.  }
  8.  private static ClassReader getClassReader(Resource resource) throws IOException {
  9.     try (InputStream is = new BufferedInputStream(resource.getInputStream())) {
  10.        try {
  11.           return new ClassReader(is);
  12.        }
  13.        catch (IllegalArgumentException ex) {
  14.           throw new NestedIOException("ASM ClassReader failed to parse class file - " +
  15.                 "probably due to a new Java class file version that isn't supported yet: " + resource, ex);
  16.        }
  17.     }
  18.  }
  21.  @Override
  22.  public Resource getResource() {
  23.     return this.resource;
  24.  }
  26.  @Override
  27.  public ClassMetadata getClassMetadata() {
  28.     return this.annotationMetadata;
  29.  }
  31.  @Override
  32.  public AnnotationMetadata getAnnotationMetadata() {
  33.     return this.annotationMetadata;
  34.  }

}

  2. ## SimpleMetadataReaderFactory
  4. - 关注点为如何获取`MetadataReader`
  5.   1. 通过资源直接 new 出来
  6.   2. 通过 className 转换成资源地址,
  7.   3. 将资源地址转换成`Resource`对象
  8.   4. new 出来
  10. ```java
  11. @Override
  12. public MetadataReader getMetadataReader(String className) throws IOException {
  13.    try {
  14.       String resourcePath = ResourceLoader.CLASSPATH_URL_PREFIX +
  15.             ClassUtils.convertClassNameToResourcePath(className) + ClassUtils.CLASS_FILE_SUFFIX;
  16.       Resource resource = this.resourceLoader.getResource(resourcePath);
  17.       return getMetadataReader(resource);
  18.    }
  19.    catch (FileNotFoundException ex) {
  20.       // Maybe an inner class name using the dot name syntax? Need to use the dollar syntax here...
  21.       // ClassUtils.forName has an equivalent check for resolution into Class references later on.
  22.       int lastDotIndex = className.lastIndexOf('.');
  23.       if (lastDotIndex != -1) {
  24.          String innerClassName =
  25.                className.substring(0, lastDotIndex) + '$' + className.substring(lastDotIndex + 1);
  26.          String innerClassResourcePath = ResourceLoader.CLASSPATH_URL_PREFIX +
  27.                ClassUtils.convertClassNameToResourcePath(innerClassName) + ClassUtils.CLASS_FILE_SUFFIX;
  28.          Resource innerClassResource = this.resourceLoader.getResource(innerClassResourcePath);
  29.          if (innerClassResource.exists()) {
  30.             return getMetadataReader(innerClassResource);
  31.          }
  32.       }
  33.       throw ex;
  34.    }
  35. }
  37. @Override
  38. public MetadataReader getMetadataReader(Resource resource) throws IOException {
  39.    return new SimpleMetadataReader(resource, this.resourceLoader.getClassLoader());
  40. }