Les annotations Java fournissent des informations sur le code, mais n'affectent pas directement le contenu du code qu'il annette. Dans ce didacticiel, nous découvrirons les annotations Java, comment personnaliser les annotations, l'utilisation des annotations et comment analyser les annotations par la réflexion.
Java 1.5 présente des annotations, et de nombreux frameworks Java utilisent actuellement des annotations, comme 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 les outils de compilation. Nous pouvons également déclarer que les annotations ont un effet pendant la compilation ou l'exécution.
Avant d'utiliser des annotations, les données de source de programme ne font que les annotations Java et Javadoc, mais les annotations fournissent bien plus que celles-ci. Les annotations contiennent non seulement des métadonnées, mais peuvent également agir sur la séquence d'exécution du programme. L'interprète d'annotation peut résoudre l'ordre d'exécution du programme par annotation. Par exemple, dans Jersey WebService, nous ajoutons une annotation ** chemin ** sous la forme d'une chaîne URI à la méthode, puis pendant le programme exécutif, l'interprète de maillot déterminera que la méthode appellera 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é interface annoté doit commencer par le symbole @. Nous pouvons déclarer des méthodes d'annotation. Examinons d'abord l'exemple d'annotation, puis nous discuterons de certaines de ses caractéristiques.
Package com.journalv.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; @ Documenté @ cible (elementType.Method) @ hérité @ rétention (retentionPolicy.runtime) public @Interface Methodinfo {String Author () Default 'Pankaj'; String Date (); int révision () par défaut 1; Commentaires de chaîne ();} La méthode d'annotation ne peut pas transporter de paramètres;
Les types de valeur de retour de la méthode d'annotation sont limités aux: types de base, chaîne, enums, annotation ou tableaux 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.
Voici quatre types d'annotations de méta :
1. @Documented - indique que les éléments qui ont cette annotation peuvent être documentés par des outils comme Javadoc. Ce type doit être utilisé pour annoter ces types qui affectent la déclaration d'utilisation des éléments annotés du client. Si une déclaration est annotée à l'aide de documents, ce type d'annotation annotée est utilisé comme API publique pour le membre du programme annoté.
2. @Target - Indique l'étendue des éléments de programme que les annotations de ce type peuvent annoter. Les valeurs de cette annotation de méta peuvent être de type, de méthode, de constructeur, de champ, etc. Si l'annotation de méta cible n'apparaît pas, 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 d'annotation de méta dans la classe actuelle et que la déclaration de la classe actuelle ne contient pas ce type d'annotation de méta, il interroge également automatiquement si la classe parent de la classe actuelle a une annotation de méta héréditaire. Cette action sera répétée pour savoir que le type d'annotation a été trouvé, ou que la classe parent au niveau supérieur est interrogé.
4. @ Rétention - Spécifie la durée de la conservation de l'annotation. Les valeurs de rétentionPolicy sont source, classe, runtime.
Annotations intégrées Java
Java fournit trois annotations intégrées.
1. @Override - Lorsque nous voulons réécrire la méthode dans la classe parent, nous devons utiliser cette annotation pour informer le compilateur que nous voulons réécrire cette méthode. De cette façon, le compilateur invitera un message d'erreur lorsque la méthode de la classe parent est supprimée ou que des modifications se produisent.
2. @Deprecated - Lorsque nous voulons que le compilateur sache qu'une méthode n'est pas recommandée, nous devons utiliser cette annotation. Java recommande cette annotation dans Javadoc, nous devons expliquer pourquoi cette méthode n'est pas recommandée et des méthodes alternatives.
3. @SuppressWarnings - Il s'agit simplement de dire 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: valide dans le fichier source) et est rejetée par le compilateur.
Jetons un coup d'œil à un exemple d'annotations intégrées en Java, reportez-vous aux annotations personnalisées mentionnées ci-dessus.
Package com.journalv.annotations; import java.io.filenotfoundException; import java.util.arraylist; import java.util.list; classe publique AnnotationExample {public static void main (String [] args) {} @ override @ méthodinfo (auteur = 'Pankaj', commentaires = 'Method Method', date = 'nov 17 2012', révision = 1) public String toString () {return 'OverRenden ToString Method';} @ @ déprécée @ méthodehinfo (commentaires = ' void oldMethod () {System.out.println ('ancienne méthode, ne l'utilisez pas. new ArrayList (); L.Add ('ABC'); OldMethod ();}}Je crois que cet exemple peut être explicite et peut être affiché dans différents scénarios.
Analyse de l'annotation Java
Nous utiliserons la technologie de réflexion pour analyser les annotations des classes Java. Ensuite, la rétention de rétention d'annotation devrait être définie sur l'exécution, sinon les informations d'annotation de la classe Java ne seront pas disponibles pendant l'exécution, nous ne pouvons donc obtenir aucune donnée liée à l'annotation.
Package com.journalv.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 (méthode.isannotationPresent (com.journaldev.annotations.methodinfo.class)) {try {// iterate toutes les annotations disponibles dans la méthode pour (annoation anno: méthode.getdeclarenotations ()) {system.out.println ('annotation in method' '+ méthode +' ':' + anno); } MethodInfo Methodanno = method.getAnnotation (methodinfo.class); if (methodanno.revision () == 1) {System.out.println ('Méthode avec révision n ° 1 =' + méthode); }} catch (Throwable ex) {ex.printStackTrace (); }}}} catch (SecurityException | classNotFoundException e) {e.printStackTrace (); }}} L'exécution du programme ci-dessus sortira:
Annotation dans la méthode 'public java.lang.string com.journaldev.annotations.annotationxample.tostring ()': @ com.journaldev.annotations.methodinfo (auteur = Pankaj, révision = 1, commentaires = méthode principale, date = nov 17 2012) Méthode avec révision n ° 1 = public Java.Lang.string com.journaldev.annotations.annotationxample.toString () Annotation in Method 'public static void com.journaldev.annotations.annotationxample.oldMethod ()': @ java.lang.deprecated () Annotation in Method 'public static com.Journalv.annotations.annotationxample.oldMethod ()' :journalv.annotations.annotationxample.oldMethod () ':)' @ com.journaldev.annotations.methodinfo (auteur = Pankaj, révision = 1, commentaires = méthode dépréciée, date = nov 17 2012) Méthode avec révision n ° 1 = public static void com.journaldev.annotations. java.io.filenotfoundException ': @ com.journalv.annotations.methodinfo (auteur = Pankaj, révision = 10, commentaires = méthode principale, date = nov 17 2012)
Il s'agit de ce tutoriel, et j'espère que vous pourrez en apprendre quelque chose.