Tutoriel d'annotation Java et annotations personnalisées

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 découvrirons 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

• Les types de valeurs de retour des méthodes d'annotation sont limités à : les types de base, String, Enums, Annotation. Ou un tableau de ces types ; les méthodes d'annotation

• peuvent avoir des valeurs par défaut. Les annotations

• elles-mêmes peuvent contenir des méta-annotations, qui sont utilisées pour annoter ; d'autres annotations.

Il existe quatre types de méta-annotations :

1 @Documented - Indique que l'élément avec cette annotation peut être documenté par des outils 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 - spécifie 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.

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();
}

}

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

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.

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();
        }
   }

}

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

Annotation in Method 'public java.lang.String com.journaldev.annotations.AnnotationExample.toString()' : 
@com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=Main method, date=Nov 17 2012)

Method with revision no 1 = public java.lang.String com.journaldev.annotations.AnnotationExample.toString()

Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @java.lang.Deprecated()

Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : 
@com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=deprecated method, date=Nov 17 2012)

Method with revision no 1 = public static void com.journaldev.annotations.AnnotationExample.oldMethod()

Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.genericsTest() throws java.io.FileNotFoundException' : 
@com.journaldev.annotations.MethodInfo(author=Pankaj, revision=10, comments=Main method, date=Nov 17 2012)

Voici l'intégralité du contenu de ce tutoriel, j'espère que vous pourrez en apprendre quelque chose.

Ce qui précède est le contenu du didacticiel d'annotation Java et des annotations personnalisées. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !