Les annotations (également appelées métadonnées) nous fournissent un moyen formel d'ajouter des informations dans notre code, nous permettant d'utiliser ces données très commodément à un moment ultérieur.
1. Syntaxe de base
Java SE5 a trois annotations standard intégrées
@Override: indique que la définition actuelle de la méthode écrasera les méthodes dans la superclasse. Si vous épelez accidentellement la mauvaise orthographe ou si la signature de la méthode ne correspond pas à la méthode écrasée, le compilateur émettra un message d'erreur.
@Deprecated: Si le programmeur utilise un élément annoté, le compilateur émettra un message d'avertissement
@SupperessWarnings: Fermez le message d'alerte du compilateur inapproprié.
Java SE5 a quatre méta-annotations intégrées
@Target: indique où cette annotation peut être utilisée. Les paramètres ElementType possibles incluent:
1) Constructeur: l'énoncé du constructeur
2) Champ: Déclaration de domaine (y compris les instances d'énumération)
3) Local_variable: Déclaration de variable locale
4) Méthode: Instruction Méthode
5) Package: Instruction Package
6) Paramètre: Déclaration des paramètres
7) Type: classe, interface (y compris le type d'annotation) ou Déclaration d'énumération
@Retention: indique à quel niveau pour sauver les informations d'annotation. Les paramètres de rétention de rétention facultatif incluent:
1) Source: L'annotation sera rejetée par le compilateur
2) Classe: les annotations sont disponibles dans les fichiers de classe, mais seront rejetées par la machine virtuelle
3) Exécution: VM conservera également des annotations pendant l'exécution, de sorte que les informations d'annotation peuvent être lues par le mécanisme de réflexion.
@Documented: Incluez cette annotation en Javadoc
@Inherited: permettez aux sous-classes de hériter des annotations dans les classes parentales la plupart du temps, les programmeurs définissent principalement leurs propres annotations et écrivent leurs propres processeurs pour les gérer.
Usecase.java
package com; import java.lang.annotation.elementType; import java.lang.annotation.retention; Importer java.lang.annotation.retentionPolicy; import java.lang.annotation.target; @Target (elementType.Method) // Utiliser pour définir où votre annotation sera appliquée, et celle-ci est appliquée comme méthode // utiliser pour définir à quel niveau l'annotation est disponible, dans le code source (classe) ou l'exécution (runtime) @retention (rétentionpolicy.runtime) public @interface usecase {public int id (); Public String Description () Par défaut "Aucune description"; } PasswordUtils .java package com; classe publique PasswordUtils {@UseCase (id = 47, Description = "Les mots de passe doivent contenir au moins un numérique") public booléan validepassword () {return true; } @UseCase (id = 48) public String EncryptPassword (String Motword) {return mot de passe; } @Usecase (id = 49, description = "jong_cai") public void closedame () {System.out.println ("jong_cai"); }}
2. Écrivez le processeur d'annotation
S'il n'y a pas d'outil pour lire les annotations, les annotations ne seront pas plus utiles que les annotations. Dans le processus d'utilisation des annotations, une partie importante est de créer et d'utiliser des processeurs d'annotation. Java SE5 étend l'API du mécanisme de réflexion pour aider les programmeurs à construire de tels outils. Dans le même temps, il fournit également un outil externe apte pour aider les programmeurs à analyser le code source Java avec des annotations. Vous trouverez ci-dessous un processeur d'annotation très simple, que nous utiliserons pour lire la classe Passwordutils et utiliser le mécanisme de réflexion pour trouver la balise @USECase. Nous lui fournissons un ensemble de valeurs d'identification, puis il répertorie les cas d'utilisation trouvés dans Passwordutils, ainsi que les cas d'utilisation manquants.
Package usecasetracker.java com; import java.lang.reflect.method; import java.util.arraylist; Importer java.util.collections; Importer java.util.list; classe publique UseCasetracker {public static void trackusecases (list <Integer> list, class <?> cl) {for (méthode m: cl.getDeclaredMethods ()) {uscase us = m.getannotation (usecase.class); if (us! = null) {System.out.println ("Found Use Case:" + us.id () + "" + us.deScription ()); list.reMove (New Integer (us.id ())); }} pour (int i: list) {System.out.println ("avertissement: cas d'utilisation manquant-" + i); }} public static void main (String [] args) {list <Integer> list = new ArrayList <Integer> (); Collection.Addall (liste, 47,48,49,50,51); TrackUseCases (liste, mot de passe-mot de passe.classe); }}
Ce programme utilise deux méthodes de réflexion: getDeclaredMethods () et getAnnotation (). Ils appartiennent tous deux à l'interface AnnotateDelement (classe, méthode et champ et d'autres classes implémentent cette interface). La méthode getAnnotation () renvoie un objet d'annotation du type spécifié, qui est UseCase. Si la méthode annotée n'a pas d'annotation du type, elle renvoie une valeur nulle. Ensuite, nous extrayons la valeur de l'élément de l'objet UseCase renvoyé en appelant les méthodes id () et description (). La méthode EncryptPassword () ne spécifie pas la valeur de description lors de l'annotation, donc lorsque le processeur traite son annotation correspondante, la valeur par défaut de la méthode Description () est obtenue par la méthode Description ().
L'annotation se propage dans le monde de Java. Si vous avez le temps, écrivez cet article d'annotations simples. C'est une introduction à l'annotation. J'espère que vous pourrez jeter une brique et apprendre ensemble ...
Si vous arrêtez de parler non-sens, la pratique est la ligne de fond.
3. Exemple
Parlons d'abord du concept d'annotation, puis parlons de la façon de concevoir votre propre annotation.
Tout d'abord, dans le package java.lang.annotation fourni avec JDK, ouvrez les fichiers source suivants:
Fichier source Target.java
@Documented @retention (retenderPolicy.runtime) @target (elementType.annotation_type) public @Interface Target {elementType [] value (); @Documented @retention (retenderPolicy.runtime) @target (elementType.annotation_type) public @Interface Target {elementType [] value (); }
@Interface est un mot-clé. Lors de la conception d'annotations, un type doit être défini comme @Interface, et vous ne pouvez pas utiliser les mots clés de classe ou d'interface (pensez-vous que le soleil est un peu avare, mais il ressemble tellement à l'interface).
Fichier source Retention.java
@Documented @retention (retenderPolicy.runtime) @target (elementType.annotation_type) public @Interface Retention {RetentionPolicy Value (); } @Documented @retention (retenderPolicy.runtime) @target (elementType.annotation_type) public @Interface Retention {RetentionPolicy Value (); }
Après avoir vu cela, vous pouvez être vague et ne savez pas de quoi vous parlez. Ne vous inquiétez pas, jetez un œil. Les fichiers ci-dessus utilisent les deux champs RetentionPolicy et ElementType, et vous pouvez deviner qu'il s'agit de deux fichiers Java. En effet, les codes source de ces deux fichiers sont les suivants:
Fichier source RetentionPolicy.java
Public Enum RetentionPolicy {Source, Class, Runtime} Public Enum RetentionPolicy {Source, Class, Runtime} Il s'agit d'un type d'énumération, avec trois valeurs, à savoir la source, la classe et l'exécution.
La source signifie que les informations de type d'annotation ne seront conservées que dans le code source du programme. Si le code source est compilé, les données d'annotation disparaîtront et ne seront pas conservées dans le fichier .class compilé.
La classe signifie que les informations de type d'annotation sont conservées dans le code source du programme, et elles seront également conservées dans le fichier .classe compilé. Lors de l'exécution, ces informations ne seront pas chargées dans la machine virtuelle (JVM). Notez que lorsque vous ne définissez pas de valeur de rétention du type d'annotation, la valeur par défaut du système est la classe.
Le troisième est l'exécution, ce qui signifie que les informations sont conservées dans le code source et le fichier .class compilé, et ces informations seront chargées dans le JVM pendant l'exécution.
Par exemple, si la rétention dans @Override est définie sur Source, si la compilation est réussie, vous n'avez pas besoin de ces informations vérifiées; Au contraire, la rétention dans @Deprecated est définie sur l'exécution, ce qui signifie qu'en plus de nous avertir quelle méthode est utilisée pendant la compilation, vous pouvez également vérifier si la méthode est obsolète lors de l'exécution.
Fichier source ElementType.java
public ENUMELLETYPE {Type, champ, méthode, paramètre, constructeur, local_variable, annotation_type, package} public ENUMELLETYPE {type, champ, méthode, paramètre, constructeur, local_variable, annotation_type, package} ＠Le élémentype dans la cible est utilisé pour spécifier quel type d'annotation des éléments peut être utilisé. Expliquons: type (type), champ (attribut), méthode (méthode), paramètre (paramètre), constructeur (constructeur), local_variable (variable locale), annotation_type, package (package), où le type (type) fait référence à la classe, à l'interface, à l'énumération et aux types d'annotation.
De plus, il peut être vu à partir du code source de 1 que @Target lui-même s'est également utilisé pour se déclarer et ne pouvait être utilisé que sur annotation_type.
Si un type d'annotation ne spécifie pas quels éléments @target est utilisé, il peut être utilisé sur n'importe quel élément et l'élément se réfère ici aux huit types ci-dessus.
Permettez-moi de vous donner quelques exemples corrects:
@Target (elementType.Method)
@Target (value = elementType.Method)
@Target (elementType.Method, elementType.Constructor)
Veuillez vous référer à la documentation Javadoc pour plus de détails
Les fichiers source utilisent tous @Documented. Le but de @Documented est de permettre l'affichage des informations de type d'annotation sur le document de description de JavaAPI; S'il n'est pas ajouté, les informations générées par ce type ne seront pas trouvées lors de l'utilisation de Javadoc pour générer le document API.
Un autre point est que si vous avez besoin d'hériter des données d'annotation à une sous-classe, vous utiliserez le type d'annotation @Inherited.
Ce qui suit est l'exemple d'annotation le plus simple à concevoir, qui se compose de quatre fichiers;
Description.java
Package Lighter.javaeye.com; import java.lang.annotation.documented; import java.lang.annotation.elementType; import java.lang.annotation.retention; Importer java.lang.annotation.retentionPolicy; import java.lang.annotation.target; @Target (elementType.Type) @retention (retentionPolicy.runtime) @Documented public @Interface Description {String Value (); } package light.javaeye.com; import java.lang.annotation.documented; import java.lang.annotation.elementType; import java.lang.annotation.retention; Importer java.lang.annotation.retentionPolicy; import java.lang.annotation.target; @Target (elementType.Type) @retention (retentionPolicy.runtime) @Documented public @Interface Description {String Value (); }
Remarque: Toutes les annotations hériteront automatiquement de l'interface java.lang.annotation, vous ne pouvez donc pas hériter d'autres classes ou interfaces.
Le point le plus important est de savoir comment définir les paramètres dans le type d'annotation:
Tout d'abord, vous ne pouvez utiliser que des droits d'accès public ou par défaut pour le modifier. Par exemple, String Value (); Ici, définissez la méthode sur le type par défaut par défaut.
Deuxièmement, les membres du paramètre ne peuvent utiliser que huit types de données de base: octets, courts, char, int, long, flottant, double, booléen et types de données tels que la chaîne, l'énumération, la classe, les annotations, ainsi que les tableaux de ces types. Par exemple, String Value (); Le membre du paramètre ici est une chaîne.
Troisièmement, s'il n'y a qu'un seul membre du paramètre, il est préférable de définir le nom du paramètre sur "Valeur" et d'ajouter des supports par la suite. Exemple: l'exemple ci-dessus n'a qu'un seul membre de paramètre.
Name.java
Package Lighter.javaeye.com; import java.lang.annotation.documented; import java.lang.annotation.elementType; import java.lang.annotation.retention; Importer java.lang.annotation.retentionPolicy; import java.lang.annotation.target; // Notez que le @target ici est différent de @Description, et les membres du paramètre sont également différents @target (elementType.Method) @retention (retenderPolicy.runtime) @documented public @interface name {String Original (); String Community (); } package light.javaeye.com; import java.lang.annotation.documented; import java.lang.annotation.elementType; import java.lang.annotation.retention; Importer java.lang.annotation.retentionPolicy; import java.lang.annotation.target; // Notez que le @target ici est différent de @Description, et les membres du paramètre sont également différents @target (elementType.Method) @retention (retenderPolicy.runtime) @documented public @interface name {String Original (); String Community (); }
Javaeyer.java
Package Lighter.javaeye.com; @Description ("Javaeye, être la meilleure communauté d'échange de développement de logiciels") classe publique Javaeyer {@Name (Original = "Founder: Robbin", Community = "javaeye") public String getName () {return null; } @Name (Originated = "Founder: Jiangnan Baiyi", Community = "Springside") public String getName2 () {return "emprunter deux ids d'identification, veuillez me pardonner d'avoir écrit cet exemple!"; }} package light.javaeye.com; @Description ("Javaeye, être la meilleure communauté d'échange de développement de logiciels") classe publique Javaeyer {@Name (Original = "Founder: Robbin", Community = "javaeye") public String getName () {return null; } @Name (Originated = "Founder: Jiangnan Baiyi", Community = "Springside") public String getName2 () {return "emprunter deux ids d'identification, veuillez me pardonner d'avoir écrit cet exemple!"; }}Écrivez une classe de testannotation qui peut exécuter les informations sur l'extrait de Javaeyer
Package Lighter.javaeye.com; import java.lang.reflect.method; import java.util.hashset; import java.util.set; Classe publique Testannotation {/ ** * Auteur Lighter * Remarque: Pour plus de détails, veuillez vous référer à la documentation Javadoc pour l'utilisation de l'API Annotation * / public static void main (String [] args) lève une exception {String class_name = "Lighter.javaeye.com.javaeyer"; Class test = class.forname (class_name); Méthode [] méthode = test.getMethods (); booléen drapeau = test.isannotationPresent (description.class); if (Flag) {Description des = (Description) test.getAnTannotation (Description.Class); System.out.println ("Description:" + des.Value ()); System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- HashSet <méthode> (); System.out.Println ("Création de la communauté:" + nom ANNOTATION API * / PUBLIC STATIC VOID Main (String [] args) lève une exception {String class_name = "Lighter.javaeye.com.javaeyer"; Class test = class.forname (class_name); Méthode [] méthode = test.getMethods (); booléen drapeau = test.isannotationPresent (description.class); if (Flag) {Description des = (Description) test.getAnTannotation (Description.Class); System.out.println ("Description:" + des.Value ()); System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- { Boolean OtherFlag = Méthode [I]. Résultats en cours:
Description: Javaeye, The Best Software Development Exchange Community Fondateur: Robbin Créé Communauté: Javaeye Fondateur: Javaeye Créé Communauté: Springside