Analyse de l'annotation Java

Aperçu

　　　　　　 Java dans1.5L'introduction des annotations Annotation, également appelées annotations Java, sont une métadonnée syntaxique qui peut être directement utilisée dans le code source, les classes/Méthodes/Variables/Paramètres/Le nom du paquet et d'autres peuvent être annotés. Contrairement aux balises Javadoc, le compilateur peut conserver le code des annotations lors de la génération des fichiers class, et peut-être pour conserver les annotations pendant le processus d'exécution du programme (run-（time）Il est possible d'utiliser des annotations, le Java Virtual Machine conservera les annotations, de sorte que les informations relatives aux annotations Annotation peuvent être obtenues par reflection.

Annotions intégrées

En fait, nous rencontrons souvent des annotations dans la vie quotidienne, telles que @Override, @Deprecated, etc., ce sont des annotations intégrées dans JDK, regardons d'abord quels sont les principaux types d'annotations intégrées en Java.
　•Les annotations agissant sur le code Java
◦@Override vérifie si une méthode est une méthode redéfinie, si cette méthode n'est pas trouvée dans la classe parente ou dans l'interface implémentée, une erreur de compilation se produira.
　◦@Deprecated marque une méthode ou une classe comme obsolète, un avertissement sera généré pendant le processus de compilation si cette classe ou cette méthode est utilisée
　◦@SuppressWarnings notifie le compilateur d'ignorer les avertissements concernant les paramètres marqués
　◦@SafeVarargs ignore les avertissements concernant l'appel de méthodes ou de constructeurs contenant des paramètres génériques1.7Nouvelle annotation
　◦@FunctionalInterface indique que l'interface déclarée sera utilisée comme interface fonctionnelle1.8Nouvelle annotation

•Les annotations appliquées à d'autres annotations sont appelées annotations métadonnées (Meta Annotation)
◦@Retention indique quand l'annotation marquée est utilisée (c'est-à-dire quand l'annotation est conservée)
■Ne reste que dans le code source, est rejeté pendant le processus de compilation (RetentionPolicy.RUNTIME)
　■Les annotations sont conservées pendant le processus de compilation et ignorées lors du chargement du fichier class (RetentionPolicy.CLASS)
　■Les annotations sont lues au moment du chargement du fichier class, c'est-à-dire que les annotations sont disponibles au cours de l'exécution, et les informations d'annotation peuvent être obtenues via la réflexion (RetentionPolicy.RUNTIME)

　◦@Documented indique que lors de la génération de Javadoc, l'annotation marquée sera écrite dans le document Javadoc
　◦@Target indique la portée de l'annotation marquée
■ElementType.TYPE: utilisé pour décrire la classe, l'interface (y compris les types d'annotations) ou la déclaration enum
　■ElementType.FIELD: utilisé pour décrire le champ
　■ElementType.METHOD: utilisé pour décrire la méthode
　■ElementType.PARAMETER: utilisé pour décrire le paramètre
　■ElementType.CONSTRUCTOR: utilisé pour décrire le constructeur
　■ElementType.LOCAL_VARIABLE: utilisé pour décrire la variable locale
　■ElementType.ANNOTATION_TYPE: utilisé pour décrire l'annotation
　■ElementType.PACKAGE: utilisé pour décrire le paquet

　◦@Inherited indique que l'annotation marquée est héritée, c'est-à-dire qu'une annotation modifiée par @Inherited utilisée pour une classe aura également un effet sur les sous-classes de cette classe.
　◦@Repeatable indique que l'annotation marquée peut agir plusieurs fois sur le même objet,1.9Nouvelle annotation

　Annotation personnalisée

Comme mentionné précédemment, beaucoup d'annotations, concentrons-nous sur les annotations métadonnées, lorsque nous définissons des annotations personnalisées, nous utilisons généralement des annotations métadonnées pour nous aider. Le format des annotations personnalisées est public @interface nomDeLAnnotation {corps} ; l'utilisation de @interface pour définir des annotations hérite automatiquement de l'interface java.lang.annotation.Annotation. Lors de la définition des annotations personnalisées, il ne peut pas hériter d'autres annotations ou interfaces. Les méthodes déclarées dans les annotations sont en réalité des paramètres d'annotations, le nom de la méthode est le nom du paramètre, le type de retour est le type du paramètre, et la valeur par défaut peut être déclarée via default.

Définir une annotation personnalisée est simple, utiliser @interface pour définir une annotation, comme suit.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
public @interface ClassInfo {
 String author() default "Wang";
 String date();
 String comments();
}

Une annotation personnalisée nommée ClassInfo a été définie, selon @Retention, cette annotation restera toujours, c'est-à-dire qu'elle restera valide pendant l'exécution du programme ; @Target(ElementType.TYPE) indique que l'annotation ClassInfo agit sur la déclaration de classes, interfaces ou enum ; @Documented
L'information ClassInfo peut être écrite dans le document Javadoc.

Revenons à quelques paramètres d'annotations dans les annotations personnalisées, il y a trois paramètres d'annotations, les paramètres d'annotations peuvent être définis avec une valeur par défaut, par exemple, le paramètre d'annotation author, la valeur par défaut est Wang, les deux autres paramètres n'ont pas de valeur par défaut.

Revenons à une autre annotation personnalisée.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodInfo {
 String description() default "Pas de description";
 String date();
}

Cette annotation personnalisée MethodInfo agit sur la méthode, pendant que le programme s'exécute, cette annotation existe également ; elle contient deux paramètres d'annotations.

La définition des paramètres de annotations (définition de la méthode), ne peut être modifiée que par les modificateurs d'accès public ou default, le type des paramètres prend en charge les types suivants.
　•Les huit types de données de base (byte, int, short, long, float, double, char, boolean)
　•Type String
　•Type Class
　•Type enum
　•Type Annotation
　•Tous les types d'arrays

Utilisation des annotations

En plus des deux annotations mentionnées ci-dessus, une annotation de portée Field a été ajoutée.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface FieldInfo {
 String type();
 String name();
}

Si les paramètres des annotations personnalisées ne sont pas déclarés avec une valeur par défaut, il est nécessaire de donner une valeur à ces paramètres lors de l'utilisation de l'annotation personnalisée, sinon le compilateur会产生错误。

Voyons le code d'utilisation des annotations :

@ClassInfo(author = "wang",
  date = "2016/9/13",
  comments = "annotation demo")
public class AnnotationDemo {
 @FieldInfo(type = "public", name = "firstField")
 public int firstField;
 @FieldInfo(type = "private", name = "secondField")
 private String secondField;
 @MethodInfo(description = "method in AnnotationDemo", name = "firstMethod")
 public void firstMethod(String value) {
  System.out.printf("first method involved");
 }
 @MethodInfo(description = "method in AnnotationDemo", name="secondMethod")
 private void secondMethod() {
  System.out.printf("first method involved");
 }
}

Obtenir des informations d'annotation

Pour obtenir des informations d'annotation, il faut d'abord garantir que l'annotation existe lors de l'exécution du programme, donc généralement, on ajoute la métanaissance @Retention(RetentionPolicy.RUNTIME) à l'annotation personnalisée, de sorte que pendant l'exécution du programme, nous pouvons obtenir certaines informations d'annotation par reflection. Pour des explications sur la reflection, vous pouvez consulter cet article.

public class AnnotationTest {
 public static void main(String[] args) {
  resolveClassAnnotationInfo(AnnotationDemo.class);
  resolveFieldAnnotationInfo(AnnotationDemo.class);
  resolveMethodAnnotationInfo(AnnotationDemo.class);
 }
 private static void resolveClassAnnotationInfo(Class<?> clz) {
  // Vérifier si la classe a l'annotation ClassInfo
  if(clz.isAnnotationPresent(ClassInfo.class)) {
   ClassInfo classInfo = (ClassInfo) clz.getAnnotation(ClassInfo.class);
   System.out.println(classInfo.author()); + " " + classInfo.comments() + " " + classInfo.date());
  }
 }
 private static void resolveFieldAnnotationInfo(Class<?> clz) {
  Field[] fields = clz.getDeclaredFields();
  for (Field field : fields) {
   if(field.isAnnotationPresent(FieldInfo.class)) {
    FieldInfo fieldInfo = (FieldInfo) field.getAnnotation(FieldInfo.class);
    System.out.println(fieldInfo.type()); + " " + fieldInfo.name());
   }
  }
 }
 private static void resolveMethodAnnotationInfo(Class<?> clz) {
  Method[] methods = clz.getDeclaredMethods();
  for (Method method : methods) {}}
   if(method.isAnnotationPresent(MethodInfo.class)) {
    MethodInfo methodInfo = (MethodInfo) method.getAnnotation(MethodInfo.class);
    System.out.println(methodInfo.name() + " " + methodInfo.description());
   }
  }
 }
}

Obtenir les Field du classe via reflection/Method, etc., via getAnnotation() ou getAnnotations() pour obtenir les annotations pertinentes, obtenir l'annotation spécifique peut obtenir des informations spécifiques.

Le résultat de l'exécution est le suivant :

Image-1 Image du résultat d'exécution

Résumé

Pour les débutants en Java ou les développeurs Java expérimentés, le contact avec les annotations Java peut être relativement rare, et dans la pratique, elles sont rarement utilisées, mais elles peuvent souvent être vues dans le code. Cet article est une introduction élémentaire aux annotations, au moins elle est lisible sans pression au niveau du code.

Voici la totalité du contenu de cet article, j'espère qu'il vous sera utile dans vos études, et que vous continuerez à soutenir le tutoriel d'encouragement.

Déclaration : le contenu de cet article est issu du réseau, propriété de ses auteurs respectifs, apporté par les utilisateurs d'Internet et téléchargé spontanément. Ce site ne détient pas de propriété intellectuelle, n'a pas été édité par des humains et n'assume aucune responsabilité juridique. Si vous trouvez du contenu susceptible de violer les droits d'auteur, veuillez envoyer un e-mail à : notice#oldtoolbag.com (veuillez remplacer # par @ lors de l'envoi d'un e-mail pour signaler une violation, et fournir des preuves pertinentes. Une fois vérifié, ce site supprimera immédiatement le contenu suspect de violation de droits d'auteur.)