Consultez les annotations Java maintenant
Aperçu
J'ai décidé d'utiliser Spring Boot pour mon travail, et j'ai dû saisir le concept d'annotation dans mon esprit, qui n'avait que le contenu de la formation Java pour les nouveaux diplômés il y a longtemps.
Site référencé
C'était vraiment facile à comprendre http://www.atmarkit.co.jp/ait/articles/1105/19/news127.html
Surtout dans cet exemple
Annotation signifie "commentaire". J'ai utilisé les commentaires Javadoc pour expliquer aux développeurs à quoi ressemble un programme, mais comme ça, je veux dire au compilateur et à l'environnement d'exécution à quoi ressemble un programme.
Comme vous pouvez le voir dans l'exemple concret décrit plus loin, en Java, en écrivant des annotations dans le programme, vous pouvez supprimer le message d'avertissement émis par le compilateur et modifier le comportement du programme en fonction de l'environnement d'exécution.
Pour l'usage au moment de l'exécution, je me suis référé ici. https://www.qoosky.io/techs/390aad36f8
Essayer
java version 1.8.0_181 Java(TM) SE Runtime Environment (build 1.8.0_181-b13) Java HotSpot(TM) 64-Bit Server VM (build 25.181-b13, mixed mode)
src └test └java └annotation ├ Main.java └ MethodInformation.java
Contenu
Créons un type d'annotation comme juste un marqueur et définissons-le.
MethodInformation.java
package test.java.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
//En ajoutant l'annotation Target, vous pouvez spécifier «À quoi l'annotation est-elle attachée?
@Target(ElementType.TYPE)
public @interface MethodInformation {
}
Main.java
package test.java.annotation;
@MethodInformation
public class Main {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
Quel est le type d'ElementType?
Veuillez ici
public enum ElementType { /** Class, interface (including annotation type), or enum declaration */ TYPE, /** Field declaration (includes enum constants) */ FIELD, /** Method declaration */ METHOD, /** Formal parameter declaration */ PARAMETER, /** Constructor declaration */ CONSTRUCTOR, /** Local variable declaration */ LOCAL_VARIABLE, /** Annotation type declaration */ ANNOTATION_TYPE, /** Package declaration */ PACKAGE, /** * Type parameter declaration * * @since 1.8 */ TYPE_PARAMETER, /** * Use of a type * * @since 1.8 */ TYPE_USE }
## Courir
Il est sorti sans aucun problème. Puisqu'il s'agit d'une annotation qui ne fait rien de particulier, il n'y a pas de changement dans le contenu de sortie.
## Essayez de créer une annotation qui ne peut être attachée qu'à une méthode
#### **`MethodInformation.java`**
```java
package test.java.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.METHOD) //Ne peut être attaché qu'aux méthodes
public @interface MethodInformation {
}
C'est un air dérangeant.
Courir
Échouera en toute sécurité
Obtenez des informations d'annotation depuis l'intérieur de la classe
MethodInformation.java
package test.java.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME) //Il est nécessaire de conserver les informations d'annotation même lors de la compilation → exécution
public @interface MethodInformation {
}
Main.java
package test.java.annotation;
@MethodInformation
public class Main {
public static void main(String[] args) {
Main mainInstance = new Main();
Class clazz = mainInstance.getClass();
//Obtenir le type de jeu d'annotations dans la classe Main
System.out.println(clazz.getAnnotation(MethodInformation.class));
System.out.println("Hello World!");
}
}
Quel est le type de politique de rétention?
Veuillez ici
public enum RetentionPolicy { /** * Annotations are to be discarded by the compiler. */ SOURCE, /** * Annotations are to be recorded in the class file by the compiler * but need not be retained by the VM at run time. This is the default * behavior. */ CLASS, /** * Annotations are to be recorded in the class file by the compiler and * retained by the VM at run time, so they may be read reflectively. * * @see java.lang.reflect.AnnotatedElement */ RUNTIME }
Résultat d'exécution
Vous pouvez voir que @ test.java.annotation.MethodInformation () est affiché.
Obtenez la valeur de l'annotation avec l'ensemble de valeurs
Créez quelque chose appelé un élément d'annotation et essayez d'obtenir sa valeur
MethodInformation.java
package test.java.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodInformation {
String testString();
int testInt();
}
Main.java
package test.java.annotation;
@MethodInformation(testString = "this is test", testInt = 12345)
public class Main {
public static void main(String[] args) {
Main mainInstance = new Main();
Class clazz = mainInstance.getClass();
MethodInformation methodInformation = (MethodInformation)clazz.getAnnotation(MethodInformation.class);
//Défini par une méthode dans le type d'annotation
System.out.println(methodInformation.testString());
System.out.println(methodInformation.testInt());
System.out.println("Hello World!");
}
}
Résultat d'exécution
J'ai pu voir la valeur définie en toute sécurité
Vous pouvez vous annoter
MethodInformation.java
package test.java.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@MethodInformation(testString = "this is test double", testInt = 1234512345) //Annotez-vous
public @interface MethodInformation {
String testString() default "test";
int testInt() default 1234;
}
Main.java
package test.java.annotation;
@MethodInformation
public class Main {
public static void main(String[] args) {
Main mainInstance = new Main();
Class clazz = mainInstance.getClass();
MethodInformation methodInformation = (MethodInformation)clazz.getAnnotation(MethodInformation.class);
System.out.println(methodInformation.testString());
System.out.println(methodInformation.testInt());
System.out.println("Hello World!");
}
}
Résultat d'exécution
Vous pouvez voir qu'il n'a pas été écrasé (la valeur par défaut de l'annotation est incluse). Je me sens un peu étrange.
Recommended Posts