Explication détaillée des fonctionnalités d'annotation Java

Qu'est-ce que l'annotation ?

L'annotation est traduite en chinois par annotation, ce qui signifie fournir des informations de données supplémentaires en plus de la logique du programme lui-même. L'annotation n'a pas d'impact direct sur le code annoté. Elle ne peut pas interagir directement avec le code annoté, mais d'autres composants peuvent utiliser ces informations.

Les informations d'annotation peuvent être compilées dans des fichiers class, ou elles peuvent être conservées dans la machine virtuelle Java, afin qu'elles puissent être obtenues au moment de l'exécution. L'annotation peut même être ajoutée à l'annotation elle-même.

Ces objets peuvent être ajoutés avec Annotation

classes, méthodes, variables, paramètres et packages peut être ajouté une annotation.

Annotation intégrée

@Override SurchargeL'utilisation de la méthode ou du type @Deprecated dans la classe parent n'est plus recommandée

@SuppressWarnings Prevent messages d'avertissement au moment de la compilation. Il doit recevoir un Array de String comme paramètre. Les paramètres disponibles sont :

• non coché

• chemin

• série

• enfin

• fallthrough

peut être utilisé avec l'annotation

@ Retention

détermine le

cycle de vie de l'annotation en cours d'enregistrement et doit recevoir un objet Enum RetentionPolicy en tant que paramètre.

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
}

@Documenté Documenté

@Target

indique la plage que l'Annotation peut modifier, et reçoit un Enum Tableau d'objets EnumType en paramètre.

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE
}

@Inherited

Cette annotation peut affecter les sous-classes de la classe annotée.

Annotation personnalisée

Nous pouvons personnaliser l'annotation après JSE5.0. Voici un exemple simple.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodAnnotation {

}

L'objet Person suivant utilise une MethodAnnotation personnalisée.

public class Person {

    public void eat() {
        System.out.println("eating");
    }

    @MethodAnnotation
    public void walk() {
        System.out.print("walking");
    }

}

Nous pouvons obtenir des informations d'annotation par la réflexion.

 Class<Person> personClass = Person.class;
        Method[] methods = personClass.getMethods();
        for(Method method : methods){
            if (method.isAnnotationPresent(MethodAnnotation.class)){
                method.invoke(personClass.newInstance());
            }
        }

Sortie :

walking

Nous pouvons également ajouter des méthodes à l'annotation personnalisée.

@Target(ElementType.TYPE)
public @interface personAnnotation {
    int id() default 1;
    String name() default "bowen";
}

Ce qui suit est l'utilisation de personAnnotation.

@personAnnotation(id = 8, name = "john")
public class Person {

    public void eat() {
        System.out.println("eating");
    }

    @MethodAnnotation
    public void walk() {
        System.out.print("walking");
    }

}

Comment les annotations sont traitées

Lorsque le code source Java est compilé, un processeur d'annotations plug-in du compilateur traitera ces annotations. Le processeur peut générer des informations de rapport ou créer des fichiers source ou des ressources Java supplémentaires. Si l'annotation elle-même est ajoutée avec la classe d'exécution RententionPolicy, le compilateur Java stockera les métadonnées de l'annotation dans le fichier de classe. Ensuite, la machine virtuelle Java ou d'autres programmes peuvent rechercher ces métadonnées et les traiter en conséquence.

Bien sûr, en plus du processeur d'annotation qui peut gérer les annotations, nous pouvons également utiliser la réflexion pour gérer nous-mêmes les annotations. Java SE 5 possède une

interface appelée AnnotatedElement. Les classes d'objets réfléchissants de Java, Class, Constructor, Field, Method et Package, implémentent toutes cette interface. Cette interface est utilisée pour représenter les éléments de programme annotés actuellement en cours d'exécution dans la machine virtuelle Java. Grâce à cette interface, vous pouvez utiliser la réflexion pour lire les annotations. L'interface AnnotatedElement peut accéder aux annotations marquées avec RUNTIME. Les méthodes correspondantes sont getAnnotation, getAnnotations et isAnnotationPresent. Étant donné que les types d'annotations sont compilés et stockés dans des binaires tout comme les classes, les annotations renvoyées par ces méthodes peuvent être interrogées tout comme les objets Java ordinaires. Utilisation étendue de l'annotation

L'annotation est largement utilisée dans divers

frameworks

et bibliothèques.

JunitJunit est un framework de

tests unitaires

très connu Lorsque vous utilisez Junit, vous devez être exposé à de nombreuses annotations.

@Exécuter avec la classe de test personnalisée Runner

• @ContextConfiguration Définir le ApplicationContext de Spring

• @DirtiesContext Reload le ApplicationContext avant d'exécuter le test suivant.

• @Avant l'initialisation avant d'appeler la méthode de test

• @Après le traitement après l'appel de la méthode de test

• @Test indique que la méthode est une méthode de test

• @Ignore peut être ajouté à la classe de test ou à la méthode de test pour ignorer l'opération.

• @BeforeClass : appelé avant que toutes les méthodes de test de la classe de test soient exécutées, et appelé une seule fois (la méthode marquée doit être

  statique
)

• @AfterClass : appelé après que toutes les méthodes de test de la classe de test ont été exécutées, et exécutées une seule fois (la méthode marquée doit être statique)

Spring

Spring est connu comme l'enfer de la configuration, et il existe de nombreuses annotations.

• @Service annoter la classe de service

• @Repository annoter la classe DAO

• @Component Annoter la classe de composants

• @Autowired Laisser Spring assembler automatiquement les beans

• @Transactional Configurer les choses

• @Scope configure la plage de survie de l'objet

• @Controller annote la classe du contrôleur

• @RequestMapping mappage du chemin d'URL

• @PathVariable mappe les paramètres de méthode aux chemins

• @RequestParam lie les paramètres de requête aux variables de méthode

• @ModelAttribute est lié au model

• @SessionAttributes est défini sur l'attribut de session

Hibernate

• @Entity modifie le bean entité

• @Table mappe la classe d'entité à la table de la base de données

• @Column mappe la colonne

• @Id mapping id

• @GeneratedValue Ce champ est auto-croissant

• @Contrôle de version ou contrôle de concurrence

• @OrderBy Collation

• @Lob Large Object Annotation

Hibernate et bien plus encore Concernant l'annotation d'union et l'annotation de héritage , cela n'a aucun sens de les énumérer ici.

JSR 303 – Bean Validation

JSR 303 – Bean Validation est une spécification de validation de données, et sa vérification des beans Java est principalement implémentée via l'annotation Java.

• @NullAnnoté par L'élément de doit être nul

• @NotNull annoté Le l'élément ne doit pas être nul

• @AssertTrueL'élément annoté doit être vrai@AssertFalseL'élément annoté doit être faux@Min(value)L'élément annoté doit être un nombre dont la valeur doit être supérieure à ou égal à la valeur minimale spécifiée

• @Max(value) L'élément annoté doit être un nombre et sa valeur doit être inférieure ou égale à la valeur maximale spécifiée

• @DecimalMin(value)L'élément annoté doit être un nombre et sa valeur doit être supérieure ou égale à la valeur minimale spécifiée

• @DecimalMax( value)L'élément annoté doit être Est un nombre dont la valeur doit être inférieure ou égale à la valeur maximale spécifiée

• @Size(max, min) La taille de l'élément annoté doit être dans la plage spécifiée

• @Digits (entier, fraction) L'élément annoté doit être un nombre et sa valeur doit être dans une plage acceptable

• @Past L'élément annoté doit être Est une date dans le passé

• L'élément annoté avec @Future doit être une date dans le futur

• L'élément annoté avec @Pattern(value) Doit être conforme à l'expression régulière spécifiée

En fait, il existe de nombreux frameworks ou bibliothèques qui utilisent l'annotation, donc Je ne les énumérerai pas un par un ici. J'espère que tout le monde pourra tirer des conclusions. En savoir plus sur les annotations en Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!