Une introduction détaillée aux annotations personnalisées en Java

Cet article présente principalement des informations pertinentes sur l'explication détaillée des annotations personnalisées Java. Les annotations Java fournissent des informations sur le code, mais n'affectent pas directement le contenu du code qu'elles annotent.

Annotations personnalisées Java

Les annotations Java fournissent certaines informations sur le code, mais n'affectent pas directement le contenu du code qu'elles annotent. Dans ce didacticiel, nous apprendrons les annotations Java, comment personnaliser les annotations, leur utilisation et comment analyser les annotations par réflexion.

Java 1.5 a introduit les annotations, qui sont actuellement largement utilisées dans de nombreux frameworks Java, tels que hibernate, Jersey et spring. Les annotations sont intégrées dans le programme en tant que métadonnées du programme. Les annotations peuvent être analysées par certains outils d'analyse ou outils de compilation. Nous pouvons également déclarer que les annotations ont un effet lors de la compilation ou de l'exécution.

Avant d'utiliser les annotations, les données sources du programme passaient uniquement via les annotations Java et Javadoc, mais les fonctions fournies par les annotations les dépassent de loin. Les annotations contiennent non seulement des métadonnées, elles peuvent également être utilisées pendant l'exécution du programme. L'interpréteur d'annotations peut déterminer l'ordre d'exécution du programme grâce aux annotations. Par exemple, dans le webservice Jersey nous ajoutons l'annotation **PATH** sous la forme d'une chaîne URI à la méthode, puis lors de l'exécution du programme, l'interpréteur Jersey déterminera la méthode pour appeler l'URI donné.

Créer des annotations personnalisées Java

La création d'une annotation personnalisée est similaire à la création d'une interface, mais le mot-clé d'interface de l'annotation doit commencer par le symbole @. Nous pouvons déclarer des méthodes pour les annotations. Examinons d'abord un exemple d'annotation, puis nous discuterons de certaines de ses fonctionnalités.

package com.journaldev.annotations;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Documented
@Target(ElementType.METHOD)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
  public @interface MethodInfo{
  String author() default 'Pankaj';
  String date();
  int revision() default 1;
  String comments();
}

• Les méthodes d'annotation ne peuvent pas avoir de paramètres

• Le type de valeur de retour des méthodes d'annotation est ; limité aux : Les types de base, les chaînes, les énumérations, les annotations ou les tableaux de ces types ; les méthodes d'annotation

• peuvent elles-mêmes avoir des valeurs par défaut ; can Contient des méta-annotations, qui sont utilisées pour annoter d'autres annotations.

• 
  Il existe quatre types de méta-annotations :

1 @Documenté

—— Indique que l'élément avec cette annotation peut. be Des outils de documentation tels que javadoc. Ce type doit être utilisé pour annoter les types qui affectent les déclarations client à l'aide d'éléments annotés. Si une déclaration est annotée avec Documenté, ce type d'annotation est utilisé comme API publique du membre du programme annoté.

2. @Target——Indique la gamme d'éléments de programme que ce type d'annotation peut annoter. La valeur de cette méta-annotation peut être TYPE, METHOD, CONSTRUCTOR, FIELD, etc. Si la méta-annotation Target n'est pas présente, l'annotation définie peut être appliquée à n'importe quel élément du programme.

3. @Inherited——Indique que le type d'annotation est automatiquement hérité. Si l'utilisateur interroge ce type de méta-annotation dans la classe actuelle et que la déclaration de la classe actuelle ne contient pas ce type de méta-annotation, alors la classe parent de la classe actuelle sera également automatiquement interrogée pour voir s'il existe une méta-annotation héritée. -annotation. Cette action sera exécutée à plusieurs reprises jusqu'à ce que ce type d'annotation soit trouvé ou que la classe parent de niveau supérieur soit interrogée.

4.@Rétention——Indique la durée pendant laquelle l'annotation est conservée. Les valeurs de RetentionPolicy sont SOURCE, CLASS et RUNTIME.

Annotations intégrées Java

Java fournit trois annotations intégrées.

1. @Override

- Lorsque nous voulons remplacer une méthode dans la classe parent, nous devons utiliser cette annotation pour indiquer au compilateur que nous voulons remplacer cette méthode. De cette façon, le compilateur affichera un message d'erreur lorsque la méthode de la classe parent est supprimée ou modifiée.

2. @Deprecated - Nous devons utiliser cette annotation lorsque nous voulons que le compilateur sache qu'une certaine méthode est obsolète. Java recommande l'utilisation de cette annotation dans le javadoc, et nous devrions expliquer pourquoi cette méthode est obsolète ainsi que des alternatives.

3. @SuppressWarnings - Cela indique simplement au compilateur d'ignorer les messages d'avertissement spécifiques, tels que l'utilisation de types de données natifs dans les génériques. Sa politique de rétention est SOURCE (Note du traducteur : valable dans les fichiers sources) et est ignorée par le compilateur.

Regardons un exemple d'annotations intégrées à Java, en faisant référence aux annotations personnalisées mentionnées ci-dessus.

Je pense que cet exemple est explicite et peut montrer son application dans différents scénarios.

package com.journaldev.annotations;
 
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
 
public class AnnotationExample {
 
public static void main(String[] args) {
}
 
@Override
@MethodInfo(author = 'Pankaj', comments = 'Main method', date = 'Nov 17 2012', revision = 1)
public String toString() {
  return 'Overriden toString method';
}
 
@Deprecated
@MethodInfo(comments = 'deprecated method', date = 'Nov 17 2012')
public static void oldMethod() {
  System.out.println('old method, don't use it.');
}
 
@SuppressWarnings({ 'unchecked', 'deprecation' })
@MethodInfo(author = 'Pankaj', comments = 'Main method', date = 'Nov 17 2012', revision = 10)
public static void genericsTest() throws FileNotFoundException {
  List l = new ArrayList();
  l.add('abc');
  oldMethod();
}
 
}

Analyse des annotations Java

Nous utiliserons la technologie de réflexion pour analyser les annotations des classes Java. Ensuite, la RetentionPolicy de l'annotation doit être définie sur RUNTIME. Sinon, les informations d'annotation de la classe Java ne seront pas disponibles pendant l'exécution et nous ne pourrons en obtenir aucune donnée relative à l'annotation.

L'exécution du programme ci-dessus produira :

package com.journaldev.annotations;
 
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
 
public class AnnotationParsing {
 
public static void main(String[] args) {
  try {
  for (Method method : AnnotationParsing.class
    .getClassLoader()
    .loadClass(('com.journaldev.annotations.AnnotationExample'))
    .getMethods()) {
    // checks if MethodInfo annotation is present for the method
    if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
      try {
    // iterates all the annotations available in the method
        for (Annotation anno : method.getDeclaredAnnotations()) {
          System.out.println('Annotation in Method ''+ method + '' : ' + anno);
          }
        MethodInfo methodAnno = method.getAnnotation(MethodInfo.class);
        if (methodAnno.revision() == 1) {
          System.out.println('Method with revision no 1 = '+ method);
          }
 
      } catch (Throwable ex) {
          ex.printStackTrace();
          }
    }
  }
  } catch (SecurityException | ClassNotFoundException e) {
      e.printStackTrace();
     }
  }
 
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!