第二十六章 注解元数据

public interface AnnotatedTypeMetadata {

    /**
     * 获取所有注解
     */
    MergedAnnotations getAnnotations();

    /**
     * 是否有注解, 是否被参数注解修饰
     */
    default boolean isAnnotated(String annotationName) {
        return getAnnotations().isPresent(annotationName);
    }

    /**
     * 获取注解的属性
     */
    @Nullable
    default Map<String, Object> getAnnotationAttributes(String annotationName) {
        return getAnnotationAttributes(annotationName, false);
    }

    /**
     * 获取注解属性表
     */
    @Nullable
    default Map<String, Object> getAnnotationAttributes(String annotationName,
            boolean classValuesAsString) {

        MergedAnnotation<Annotation> annotation = getAnnotations().get(annotationName,
                null, MergedAnnotationSelectors.firstDirectlyDeclared());
        if (!annotation.isPresent()) {
            return null;
        }
        return annotation.asAnnotationAttributes(Adapt.values(classValuesAsString, true));
    }

    /**
     * 获取注解的属性表
     */
    @Nullable
    default MultiValueMap<String, Object> getAllAnnotationAttributes(String annotationName) {
        return getAllAnnotationAttributes(annotationName, false);
    }

    /**
     * 获取注解属性表
     */
    @Nullable
    default MultiValueMap<String, Object> getAllAnnotationAttributes(
            String annotationName, boolean classValuesAsString) {

        Adapt[] adaptations = Adapt.values(classValuesAsString, true);
        return getAnnotations().stream(annotationName)
                .filter(MergedAnnotationPredicates.unique(MergedAnnotation::getMetaTypes))
                .map(MergedAnnotation::withNonMergedAttributes)
                .collect(MergedAnnotationCollectors.toMultiValueMap(map ->
                        map.isEmpty() ? null : map, adaptations));
    }

}

public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata {

   /**
     * 获取注解名称,全类名
    */
   default Set<String> getAnnotationTypes() {
      return getAnnotations().stream()
            // 判断是否直接使用注解
            .filter(MergedAnnotation::isDirectlyPresent)
            // 获取注解的名字
            .map(annotation -> annotation.getType().getName())
            // 转换成set
            .collect(Collectors.toCollection(LinkedHashSet::new));
   }

   /**
     * 注解全类名
    */
   default Set<String> getMetaAnnotationTypes(String annotationName) {
      // 获取注解合并后的结果
      MergedAnnotation<?> annotation = getAnnotations().get(annotationName, MergedAnnotation::isDirectlyPresent);
      // 判断注解是否使用
      if (!annotation.isPresent()) {
         // 不使用直接返回空
         return Collections.emptySet();
      }
      // 注解使用 继承查找获得所有注解名称(类名)
      return MergedAnnotations.from(annotation.getType(), SearchStrategy.INHERITED_ANNOTATIONS).stream()
            .map(mergedAnnotation -> mergedAnnotation.getType().getName())
            .collect(Collectors.toCollection(LinkedHashSet::new));
   }

   /**
     * 是否包含某个注解
    */
   default boolean hasAnnotation(String annotationName) {
      return getAnnotations().isDirectlyPresent(annotationName);
   }

   /**
     * 是否被某个注解标记过
    */
   default boolean hasMetaAnnotation(String metaAnnotationName) {
      return getAnnotations().get(metaAnnotationName,
            MergedAnnotation::isMetaPresent).isPresent();
   }

   /**
     * 是否有注解,类里面有一个注解就返回true
    */
   default boolean hasAnnotatedMethods(String annotationName) {
      return !getAnnotatedMethods(annotationName).isEmpty();
   }

   /**
     * 获取包含注解的方法
    */
   Set<MethodMetadata> getAnnotatedMethods(String annotationName);


   /**
     * 通过反射创建一个注解的元信息
    */
   static AnnotationMetadata introspect(Class<?> type) {
      return StandardAnnotationMetadata.from(type);
   }

}

@Component
public class A {

}

@Configuration
public class C {

}

@Test
void testAnn() {
   AnnotationMetadata introspect = AnnotationMetadata.introspect(C.class);
   System.out.println(introspect.hasAnnotation(Component.class.getName()));
   System.out.println(introspect.hasMetaAnnotation(Component.class.getName()));
}

false
true

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {}

@Deprecated
public StandardAnnotationMetadata(Class<?> introspectedClass, boolean nestedAnnotationsAsMap) {
   super(introspectedClass);
   this.mergedAnnotations = MergedAnnotations.from(introspectedClass,
         SearchStrategy.INHERITED_ANNOTATIONS, RepeatableContainers.none(),
         AnnotationFilter.NONE);
   this.nestedAnnotationsAsMap = nestedAnnotationsAsMap;
}

@Nullable
default Map<String, Object> getAnnotationAttributes(String annotationName,
        boolean classValuesAsString) {

    MergedAnnotation<Annotation> annotation = getAnnotations().get(annotationName,
            null, MergedAnnotationSelectors.firstDirectlyDeclared());
    if (!annotation.isPresent()) {
        return null;
    }
    return annotation.asAnnotationAttributes(Adapt.values(classValuesAsString, true));
}

@ComponentScans(
    value =  {
        @ComponentScan()
    }
)

@Component(value = "abcd")
public class A {

}

@Test
void annAttribute() throws InvocationTargetException, IllegalAccessException {
   A a = new A();
   Class<? extends A> aClass = a.getClass();
   Annotation[] annotations = aClass.getAnnotations();

   Map<String, Map<String, Object>> annotationAttributes = new HashMap<>();

   for (Annotation annotation : annotations) {
      Class<? extends Annotation> annClass = annotation.annotationType();

      String name = annClass.getName();
      Method[] declaredMethods = annClass.getDeclaredMethods();

      Map<String, Object> oneAnnotationAttributes = new HashMap<>();

      for (Method declaredMethod : declaredMethods) {
         String annAtrrName = declaredMethod.getName();
         Object invoke = declaredMethod.invoke(annotation);
         oneAnnotationAttributes.put(annAtrrName, invoke);

      }
      annotationAttributes.put(name, oneAnnotationAttributes);
   }

   System.out.println();
}