¿Es posible comprobar en tiempo de ejecución si es o no una anotación de TYPE_USE está presente en una interfaz dentro de una declaración implementos?

newlogic:

Considera lo siguiente:

class A implements @X B, C, @X D {}

¿Es posible recuperar en tiempo de ejecución si es o no la declaración contiene implementos @X en cada una de las interfaces de aplicación?

Así, en el ejemplo anterior, para B la respuesta es sí, sin ninguna C y D sí.

Si es así, ¿cómo podría lograr esto?

repollo:

Sí, esto es posible con Class#getAnnotatedInterfaces().

Devuelve una matriz de AnnotatedTypeobjetos que representan el uso de tipos de especificar superinterfaces de la entidad que representa este Classobjeto. (El uso de tipo Foopara especificar un superinterfaz en '... implementos Foo' es distinta de la declaración de tipo Foo.)

[...]

Por ejemplo:

package com.example;

import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.reflect.AnnotatedType;

import static java.lang.annotation.ElementType.TYPE_USE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

public class Main {

  public static void main(String[] args) {
    for (AnnotatedType type : A.class.getAnnotatedInterfaces()) {
      System.out.println(type.getType());
      for (Annotation annotation : type.getAnnotations()) {
        System.out.println("\t" + annotation);
      }
      System.out.println();
    }
  }

  @Retention(RUNTIME)
  @Target(TYPE_USE)
  @interface X {
    String value();
  }

  interface B {}
  interface C {}
  interface D {}

  static class A implements @X("Hello, ") B, C, @X("World!") D {}
}

Salida:

interface com.example.Main$B
    @com.example.Main$X("Hello, ")

interface com.example.Main$C

interface com.example.Main$D
    @com.example.Main$X("World!")

Otros métodos similares incluyen:

• Class#getAnnotatedSuperclass()
• Method#getAnnotatedReturnType()
• Parameter#getAnnotatedType()

Tenga en cuenta que AnnotatedTypetiene subtipos tales como AnnotatedParameterizedType. Que este último nos dejó interfaz de conseguir las anotaciones presentan en argumentos de tipo:

• AnnotatedParameterizedType#getAnnotatedActualTypeArguments()

Para saber si existe o no una AnnotatedTypees una instancia de un subtipo requiere una instanceofprueba (a menos que ya se sabe con certeza).