Annotations Java

Tutoriels
Java

Les annotations Java fournissent des informations sur le code. Les annotations Java n’ont aucun effet direct sur le code qu’elles annotent. Dans ce tutoriel sur les annotations Java, nous examinerons les éléments suivants :

  1. Annotations Java intégrées
  2. Comment écrire une annotation personnalisée
  3. Utilisation des annotations et comment les analyser à l’aide de l’API Reflection.

Annotations Java

Java 1.5 a introduit les annotations et elles sont maintenant largement utilisées dans les frameworks Java EE tels que Hibernate, Jersey et Spring. L’annotation Java est une métadonnée sur le programme incorporée dans le programme lui-même. Elle peut être analysée par un outil d’analyse d’annotations ou par le compilateur. Nous pouvons également spécifier la disponibilité de l’annotation uniquement au moment de la compilation ou jusqu’à l’exécution. Avant les annotations Java, les métadonnées du programme étaient disponibles via des commentaires Java ou par Javadoc, mais les annotations offrent plus que cela. Les métadonnées des annotations peuvent également être disponibles à l’exécution et les analyseurs d’annotations peuvent les utiliser pour déterminer le flux de traitement. Par exemple, dans le service web Jersey, nous ajoutons une annotation PATH avec une chaîne URI à une méthode et, à l’exécution, Jersey l’analyse pour déterminer la méthode à invoquer pour le modèle d’URI donné.

Annotation personnalisée Java

Créer une annotation personnalisée est similaire à écrire une interface, à la différence que le mot-clé interface est préfixé par le symbole _@_. Nous pouvons déclarer des méthodes dans l’annotation. Voyons un exemple d’annotation personnalisée en Java, puis discutons de ses caractéristiques et points importants.

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

Quelques points importants sur les annotations Java sont les suivants :

  1. Les méthodes d’annotation ne peuvent pas avoir de paramètres.
  2. Les types de retour des méthodes d’annotation sont limités aux types primitifs, String, Enums, Annotation ou tableau de ces types.
  3. Les méthodes d’annotation Java peuvent avoir des valeurs par défaut.
  4. Les annotations peuvent avoir des méta-annotations attachées. Les méta-annotations sont utilisées pour fournir des informations sur l’annotation.

Méta-annotations en Java

Il existe cinq types de méta-annotations :

  1. @Documented – indique que les éléments utilisant cette annotation doivent être documentés par Javadoc et des outils similaires. Ce type devrait être utilisé pour annoter les déclarations de types dont les annotations affectent l’utilisation des éléments annotés par leurs clients. Si une déclaration de type est annotée avec Documented, ses annotations font partie de l’API publique des éléments annotés.
  2. @Cible – indique les types d’éléments de programme auxquels un type d’annotation est applicable. Certaines valeurs possibles sont TYPE, METHODE, CONSTRUCTEUR, CHAMP, etc. Si la méta-annotation Target n’est pas présente, alors l’annotation peut être utilisée sur n’importe quel élément de programme.
  3. @Hérité – indique qu’un type d’annotation est automatiquement hérité. Si l’utilisateur interroge le type d’annotation sur une déclaration de classe, et que la déclaration de classe n’a pas d’annotation pour ce type, alors la superclasse de la classe sera automatiquement interrogée pour le type d’annotation. Ce processus sera répété jusqu’à ce qu’une annotation pour ce type soit trouvée, ou que le sommet de la hiérarchie des classes (Object) soit atteint.
  4. @Retention – indique pendant combien de temps les annotations avec le type annoté doivent être conservées. Il prend un argument RetentionPolicy dont les valeurs possibles sont SOURCE, CLASS et RUNTIME
  5. @Répétable – utilisé pour indiquer que le type d’annotation dont il annote la déclaration est répétable.

Annotations intégrées en Java

Java fournit cinq annotations intégrées.

  1. @Override – Lorsque nous voulons remplacer une méthode de la Superclasse, nous devrions utiliser cette annotation pour informer le compilateur que nous remplaçons une méthode. Ainsi, lorsque la méthode de la superclasse est supprimée ou modifiée, le compilateur affichera un message d’erreur. Apprenez pourquoi nous devrions toujours utiliser l’annotation de remplacement de Java lors du remplacement d’une méthode.
  2. @Deprecated – lorsque nous voulons que le compilateur sache qu’une méthode est obsolète, nous devrions utiliser cette annotation. Java recommande que dans javadoc, nous devrions fournir des informations sur la raison pour laquelle cette méthode est obsolète et quelle est l’alternative à utiliser.
  3. @SuppressWarnings – Ceci est juste pour indiquer au compilateur d’ignorer des avertissements spécifiques qu’ils produisent, par exemple en utilisant des types bruts dans les génériques Java. Sa politique de rétention est SOURCE et il est ignoré par le compilateur.
  4. @FunctionalInterface – Cette annotation a été introduite dans Java 8 pour indiquer que l’interface est destinée à être une interface fonctionnelle.
  5. @SafeVarargs – Une assertion du programmeur que le corps de la méthode ou du constructeur annoté ne réalise pas d’opérations potentiellement dangereuses sur son paramètre varargs.

Exemple d’annotations Java

Voyons un exemple en Java montrant l’utilisation des annotations intégrées en Java ainsi que l’utilisation d’une annotation personnalisée créée par nous dans l’exemple 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();
	}

}

I believe above java annotation example is self-explanatory and showing the use of annotations in different cases.

Annotation Java Analyse

Nous utiliserons la réflexion pour analyser les annotations Java d’une classe. Veuillez noter que la politique de rétention de l’annotation doit être RUNTIME sinon ses informations ne seront pas disponibles à l’exécution et nous ne pourrons pas récupérer de données à partir de celle-ci. 

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()) {
				// vérifie si l'annotation MethodInfo est présente pour la méthode
				if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
					try {
						// itère sur toutes les annotations disponibles dans la méthode
						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();
		}
	}

}

La sortie du programme ci-dessus est :

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)

L’API de réflexion est très puissante et largement utilisée en Java, dans les frameworks J2EE tels que Spring, Hibernate, JUnit, consultez Réflexion en Java. C’est tout pour le tutoriel sur les exemples d’annotations Java, j’espère que vous avez appris quelque chose. Mises à jour des annotations Java:

  1. Les spécifications Servlet 3.0 ont introduit l’utilisation d’annotations pour la configuration des servlets et les paramètres d’initialisation. Pour en savoir plus, consultez le tutoriel sur les Servlets Java.
  2. Nous pouvons utiliser des annotations dans Struts 2 pour configurer ses classes d’action et ses pages de résultats. Consultez un exemple de travail sur l’exemple d’annotation Struts 2 Hello World.

Référence : Site web d’Oracle

Source:
https://www.digitalocean.com/community/tutorials/java-annotations