1. RetentionPolicy.Source: L'annotation n'est conservée que dans le fichier source. Lorsque le fichier Java est compilé dans un fichier de classe, l'annotation est abandonnée;
2. RetentionPolicy.class: L'annotation est conservée dans le fichier de classe, mais est abandonnée lorsque JVM charge le fichier de classe. Il s'agit du cycle de vie par défaut;
3. RetentionPolicy.runtime: l'annotation n'est pas seulement enregistrée dans le fichier de classe, mais existe toujours après que JVM ait chargé le fichier de classe;
Ces trois cycles de vie correspondent à: le fichier source java (fichier .java) --->. Fichier de classe ----> bytecode en mémoire.
Alors, comment choisissez-vous le bon cycle de vie d'annotation?
Tout d'abord, nous devons clarifier la source de longueur de cycle de vie <classe <runtime, donc là où le premier peut agir, le second peut agir. Généralement, si vous avez besoin d'obtenir dynamiquement des informations d'annotation au moment de l'exécution, vous ne pouvez utiliser que l'annotation d'exécution; Si vous souhaitez effectuer des opérations de prétraitement au moment de la compilation, comme la génération d'un code auxiliaire (comme ButterKnife), vous pouvez utiliser l'annotation de classe; Si vous ne faites que des opérations de vérification, telles que @Override et @SuppressWarnings, vous pouvez utiliser l'annotation source.
Ce qui suit est une application simple d'annotations d'exécution.
Obtenir l'annotation
Vous devez obtenir des annotations d'exécution via la réflexion, qui peut être obtenue à partir du package, de la classe, du champ, de la méthode .... Les méthodes de base sont les mêmes. Plusieurs méthodes courantes sont les suivantes:
/ ** * Obtenez l'annotation du type spécifié * / public <a prolonge Annotation> a getAnnotation (classe <a> annotationType); / ** * Obtenez toutes les annotations, le cas échéant, annotation publique [] getAnnotations (); / ** * Obtenez toutes les annotations, ignorer les annotations héritées * / Public Annotation [] GetDeclatedAnnOnA Existe sur cet élément, revenez vrai s'il y a, sinon Faux * / public booléen iSannotationPresent (classe <? étend Annotation> AnnotationType); / ** * Obtenez toutes les annotations pour les paramètres dans la méthode * / annotation publique [] [] getParameterAnnotations ();
Pour utiliser ces fonctions, vous devez d'abord obtenir les éléments correspondants par réflexion: classe, champ, méthode, etc.
Annotations personnalisées
Jetons un coup d'œil à la façon simple d'utiliser des annotations personnalisées. Ici, nous définissons d'abord 3 annotations d'exécution:
// Classe applicable, interface (y compris le type d'annotation) ou enum @retention (retentionPolicy.runtime) @target (elementType.Type) public @Interface classInfo {String Value (); } // Les attributs de champ applicables, incluent également Enum Constants @retention (retentionPolicy.runtime) @target (elementType.field) public @Interface FieldInfo {int [] value (); } // Méthode applicable @retention (retentionPolicy.runtime) @target (elementType.Method) public @Interface MethodInfo {String Name () Default "Long"; String data (); int age () par défaut 27; }Ces trois annotations sont applicables à différents éléments et ont tous des attributs différents. Lorsque vous utilisez des annotations, vous devez définir ces valeurs d'attribut.
Définissez une autre classe de test pour utiliser ces annotations:
/ ** * Test Runtime Annotation * / @ classInfo ("Test Class") Classe publique TestRuntimeAnNotation {@FieldInfo (valeur = {1, 2}) String public FieldInfo = "FiledInfo"; @ FieldInfo (Value = {10086}) public int i = 100; @MethodInfo (nom = "Bluebird", Data = "Big") String (STATIC getMethodInfo () {return TestRuntimeAnNotation.Class.getSimplename ();}}Il est toujours très simple à utiliser. Enfin, voyons comment obtenir des informations d'annotation dans le code:
/ ** * Test Runtime Annotation * / private void _TestRuntimeAnNotation () {StringBuffer SB = new StringBuffer (); classe <?> CLS = TestRuntimeAnNotation.Class; Constructor <?> [] Constructors = CLS.GetConstructors () ") .append (" / n "); classinfo classInfo = cls.getannotation (classinfo.class); if (classInfo! = null) {sb.append (modificier.toString (cls.getModifiers ())). APPEND (" "). Valeur: ") .APPEND (classInfo.Value ()). append (" / n / n ");} sb.append (" Field Annotation: ") .append (" / n "); champ [] fields = cls.getDeclaredFields (); pour (champ de champ: champs) {fieldInfo fieldInfo = field.getannotation (fieldco.class); (FieldInfo! = null) {sb.append (modificier.toString (field.getModificaires ())). APPEND ("") .APPEND (Field.getType (). GetImpLename ()). APPEND (""). ") .append (arrays.toString (fieldInfo.Value ())). APPEND (" / n / n ");}} sb.append (" Method Annotation: ") .Apnd (" / n "); méthode [] méthodes = cls.getDeclatedMethods (); pour (méthode Méthode) {méthodinfo Methodinfo = Method.getAntoTation (méthodyInfo.class); if (methodInfo! = null) {sb.append (modificier.toString (méthode.getModifiers ())). APPEND ("") .APPEND (Method.GetRetTurnType (). GetSImPlename ()). .APPEND (Method.GetName ()). APPEND ("/ n"); sb.append ("Annotation Value:") .Apnd ("/ n"); sb.append ("name:") .append (MethodInfo.Name ()). ") .Apnd (méthodyInfo.Data ()). APPEND (" / n "); sb.append (" Age: ") .Apnd (méthodinfo.age ()). APPEND (" / n ");}} system.out.print (sb.tostring ());}Les opérations sont effectuées pour obtenir l'élément correspondant par réflexion, puis obtenir l'annotation sur l'élément et enfin obtenir la valeur d'attribut de l'annotation.
Jetons un coup d'œil à la sortie, ici je vais l'afficher directement sur mon téléphone:
Résumer
Ce qui précède est toute l'explication détaillée des concepts de base de l'annotation de la langue java, et j'espère que cela sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!