Comment et où sont utilisées les annotations en Java ?

Question

Quels sont les principaux domaines dans lesquels nous pouvons utiliser les annotations ? Cette fonctionnalité remplace-t-elle la configuration basée sur XML ?

Answer 1

Les annotations sont méta-méta-objets qui peut être utilisé pour décrire d'autres méta-objets . Les méta-objets sont des classes, des champs et des méthodes. Demander à un objet son méta-objet (par ex. anObj.getClass() ) est appelé introspection . L'introspection peut aller plus loin et nous pouvons demander à un méta-objet quelles sont ses annotations (par ex. aClass.getAnnotations ). L'introspection et les annotations font partie de ce que l'on appelle la réflexion y métaprogrammation .

Une annotation doit être interprétée d'une manière ou d'une autre pour être utile. Les annotations peuvent être interprétées à temps de développement par l'IDE ou le compilateur, ou à temps d'exécution par un cadre.

Le traitement des annotations est un mécanisme très puissant qui peut être utilisé de nombreuses façons différentes :

• pour décrire les contraintes ou l'usage d'un élément : par exemple @Deprecated, @Override o @NotNull
• pour décrire la "nature" d'un élément, par ex. @Entity, @TestCase, @WebService
• pour décrire le comportement d'un élément : @Statefull, @Transaction
• pour décrire comment traiter l'élément : @Column, @XmlElement

Dans tous les cas, une annotation est utilisée pour décrire l'élément et clarifier son signification .

Avant le JDK5, les informations qui sont maintenant exprimées par des annotations devaient être stockées ailleurs, et les fichiers XML étaient fréquemment utilisés. Mais il est plus pratique d'utiliser les annotations car elles appartiennent au code Java lui-même, et sont donc beaucoup plus faciles à manipuler que le XML.

Utilisation des annotations :

• Documentation, par exemple XDoclet
• Compilation
• IDE
• Cadre de test, par exemple JUnit.
• Conteneur IoC, par exemple comme Spring
• Sérialisation, par exemple XML
• Programmation orientée aspect (AOP), par exemple Spring AOP
• Serveurs d'application, par exemple conteneur EJB, service Web
• Mappage objet-relationnel (ORM), par exemple Hibernate, JPA
• et bien d'autres encore...

...jetez un coup d'oeil par exemple au projet Lombok qui utilise des annotations pour définir la façon de générer les données de l'entreprise. equals o hashCode méthodes.

Answer 2

Les annotations de Java ont de multiples applications. Tout d'abord, elles peuvent être utilisées par le compilateur (ou ses extensions). Considérez par exemple le Remplacer annotation :

class Foo {

    @Override public boolean equals(Object other) {
        return ...;
    }
}

Celui-ci est en fait intégré au JDK Java. Le compilateur signalera une erreur, si une méthode est étiquetée avec elle, ce qui fait pas surcharger une méthode héritée d'une classe de base. Cette annotation peut être utile afin d'éviter l'erreur courante, où vous avez réellement l'intention de remplacer une méthode, mais ne le faites pas, parce que la signature donnée dans votre méthode ne correspond pas à la signature de la méthode à remplacer :

class Foo {

    @Override public boolean equals(Foo other) {  // Compiler signals an error for this one
        return ...;
    }
}

Depuis le JDK7, les annotations sont autorisées sur tous les types. Cette fonctionnalité peut désormais être utilisée pour les annotations du compilateur telles que NotNull comme dans :

public void processSomething(@NotNull String text) {
    ...
}

qui permet au compilateur de vous avertir en cas d'utilisation inappropriée/non vérifiée de variables et d'éléments d'information. null valeurs.

Une autre application plus avancée des annotations concerne la réflexion et le traitement des annotations au moment de l'exécution. C'est (je pense) ce que vous aviez à l'esprit lorsque vous avez parlé des annotations comme "remplacement de la configuration basée sur XML". C'est le type de traitement des annotations utilisé, par exemple, par divers frameworks et normes JCP (persistance, injection de dépendances, etc.) afin de fournir les métadonnées et les informations de configuration nécessaires.

Answer 3

Les annotations sont une forme de métadonnées (données sur les données) ajoutées à un fichier source Java. Elles sont largement utilisées par les frameworks pour simplifier l'intégration du code client. Voici quelques exemples concrets qui me viennent à l'esprit :

• JUnit 4 - vous ajoutez le @Test à chaque méthode de test que vous souhaitez faire exécuter par le runner JUnit. Il existe également des annotations supplémentaires pour la mise en place des tests (comme l'annotation @Before y @BeforeClass ). Tout cela est traité par le runner JUnit, qui exécute les tests en conséquence. On pourrait dire qu'il s'agit d'un remplacement de la configuration XML, mais les annotations sont parfois plus puissantes (elles peuvent utiliser la réflexion, par exemple) et elles sont également plus proches du code auquel elles font référence (l'élément @Test se trouve juste avant la méthode de test, de sorte que l'objectif de cette méthode est clair - elle sert également de documentation). D'autre part, la configuration XML peut être plus complexe et inclure beaucoup plus de données que les annotations.

• Terracotta - utilise à la fois des annotations et des fichiers de configuration XML. Par exemple, le fichier @Root indique au runtime Terracotta que le champ annoté est un Root et que sa mémoire doit être partagée entre les instances VM. Le fichier de configuration XML est utilisé pour configurer le serveur et lui indiquer les classes à instrumenter.

• Google Guice - un exemple serait le @Inject qui, lorsqu'elle est appliquée à un constructeur, fait en sorte que le runtime Guice recherche des valeurs pour chaque paramètre, sur la base des injecteurs définis. Le site @Inject serait assez difficile à reproduire en utilisant des fichiers de configuration XML, et sa proximité avec le constructeur auquel elle fait référence est très utile (imaginez devoir chercher dans un énorme fichier XML pour trouver toutes les injections de dépendances que vous avez mises en place).

J'espère vous avoir donné un aperçu de la manière dont les annotations sont utilisées dans les différents frameworks.

Answer 4

S'agit-il d'un remplacement de la méthode XML basée sur XML ?

Pas complètement, mais la configuration qui correspond étroitement aux structures de code (comme les mappings JPA ou l'injection de dépendances dans Spring) peut souvent être remplacée par des annotations, et est alors généralement beaucoup moins verbeuse, ennuyeuse et pénible. Presque tous les frameworks notables ont fait ce changement, bien que l'ancienne configuration XML reste généralement une option.

Answer 5

Il existe deux types d'annotations

1. du point de vue de l'utilisateur, la plupart du temps, les annotations fonctionnent comme un raccourci, vous épargnent quelques frappes ou rendent votre programme plus lisible.

2. Du point de vue du vendeur, le processeur considère l'annotation comme une "interface" légère, votre programme se confronte à QUELQUE CHOSE mais sans "implémenter" explicitement l'interface particulière (ici l'annotation).

Par exemple, en jpa, vous définissez quelque chose comme

@Entity class Foo {...}

au lieu de

class Foo implements Entity {...}

les deux disent la même chose "Foo est une classe d'entité"