web-dev-qa-db-fra.com

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

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

javaannotations
199
Biju CD

Les annotations sont des méta-méta-objets qui peuvent être utilisés 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 exemple, anObj.getClass()) est appelé introspection . L’introspection peut aller plus loin et on peut demander à un méta-objet quelles sont ses annotations (par exemple, aClass.getAnnotations). L'introspection et les annotations appartiennent à ce qu'on appelle réflexion et méta-programmation .

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 à au moment du développement par IDE ou le compilateur, ou à run-time par un framework.

Le traitement des annotations est un mécanisme très puissant qui peut être utilisé de différentes manières:

  • décrire les contraintes ou l’utilisation d’un élément: par ex. @Deprecated, @Override, ou @NotNull
  • décrire la "nature" d'un élément, par ex. @Entity, @TestCase, @WebService
  • décrire le comportement d'un élément: @Statefull, @Transaction
  • 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 sa signification .

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

Utilisation des annotations:

  • Documentation, par exemple XDoclet
  • Compilation
  • IDE
  • Cadre de test, par exemple JUnit
  • Conteneur IoC par exemple comme printemps
  • Sérialisation, par exemple XML
  • Programmation orientée aspect (AOP), par exemple Printemps AOP
  • Serveurs d'applications, par exemple Conteneur EJB, service Web
  • Mappage objet-relationnel (ORM), par ex. Hibernate, JPA
  • et beaucoup plus...

... regardez par exemple le projet Lombok , qui utilise des annotations pour définir comment générer les méthodes equals ou hashCode.

293
ewernli

Il existe plusieurs applications pour les annotations Java. Tout d’abord, ils peuvent être utilisés par le compilateur (ou ses extensions). Considérons par exemple l'annotation Remplacer :

class Foo {

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

Celui-ci est en fait construit dans le JDK Java. Le compilateur signalera une erreur, si une méthode est étiquetée avec elle, ce qui not remplace une méthode héritée d'un classe de base. Cette annotation peut être utile afin d’éviter l’erreur courante, où vous avez l’intention de remplacer une méthode, mais que vous échouez, car la signature donnée dans votre méthode ne correspond pas à la signature de la méthode en cours de substitution:

class Foo {

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

Le prochain JDK7 autorisera les annotations sur tous les types. Il existe déjà des propositions d'utilisation de cette fonctionnalité pour les annotations du compilateur telles que NotNull , comme dans:

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

ce qui pourrait permettre au compilateur de vous avertir des utilisations incorrectes/non contrôlées des variables et des valeurs null .

Une autre application plus avancée pour les annotations implique le traitement de la réflexion et des annotations au moment de l'exécution. C’est (je pense) ce que vous aviez à l’esprit lorsque vous parlez des annotations comme "remplacement de la configuration basée sur XML". Il s'agit du type de traitement d'annotation utilisé, par exemple, par divers cadres et normes JCP (persistance, injection de dépendance, vous le nommez) afin de fournir les métadonnées et les informations de configuration nécessaires.

46
Dirk

Les annotations sont une forme de métadonnées (données sur les données) ajoutées au fichier source Java. Elles sont largement utilisées par les frameworks pour simplifier l'intégration du code client. Quelques exemples concrets du haut de ma tête:

  • JUnit 4 - vous ajoutez l'annotation @Test À chaque méthode de test à exécuter par le coureur JUnit. Il existe également des annotations supplémentaires relatives à la configuration des tests (comme @Before Et @BeforeClass). Tous ces éléments sont traités par le coureur JUnit, qui exécute les tests en conséquence. Vous pouvez dire que cela remplace la configuration XML, mais les annotations sont parfois plus puissantes (elles peuvent utiliser la réflexion, par exemple) et elles sont plus proches du code auquel elles font référence (l'annotation @Test Se trouve juste avant la méthode d’essai, l’objectif de cette méthode est donc clair - sert également de documentation). La configuration XML, en revanche, peut être plus complexe et peut inclure beaucoup plus de données que les annotations.

  • Terracotta - utilise à la fois des annotations et des fichiers de configuration XML. Par exemple, l'annotation @Root Indique à l'exécution de Terracotta que le champ annoté est une racine 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 dire quelles classes à instrumenter.

  • Google Guice - un exemple serait l'annotation @Inject, Qui, lorsqu'elle est appliquée à un constructeur, permet au moteur d'exécution de Guice de rechercher des valeurs pour chaque paramètre, en fonction des injecteurs définis. L'annotation @Inject Serait assez difficile à répliquer à l'aide de fichiers de configuration XML, et sa proximité avec le constructeur auquel elle fait référence est très utile (imaginez avoir à chercher dans un énorme fichier XML pour trouver toutes les injections de dépendance que vous avez définies. up).

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

17
Flaviu Cipcigan

Les annotations en Java permettent de décrire les classes, les champs et les méthodes. Il s’agit essentiellement d’une forme de métadonnées ajoutées au fichier source Java, elles ne peuvent pas affecter directement la sémantique d’un programme. Toutefois, les annotations peuvent être lues au moment de l’exécution à l’aide de Reflection & this processus est appelé Introspection, il peut ensuite être utilisé pour modifier des classes, des champs ou des méthodes.

Cette fonctionnalité est souvent exploitée par Bibliothèques et SDK (hibernate, JUnit, Spring Framework) pour simplifier ou réduire la quantité de code qu’un programmeur ferait à moins de travailler avec ces bibliothèques ou ces SDK. Par conséquent, il est juste de dire Les réflexions vont de pair en Java.

Nous obtenons également la possibilité de limiter la disponibilité d’une annotation au moment de la compilation ou de l’exécution. Bel exemple est simple pour créer une annotation personnalisée.

Driver.Java

package io.hamzeen;

import Java.lang.annotation.Annotation;

public class Driver {

    public static void main(String[] args) {
        Class<TestAlpha> obj = TestAlpha.class;
        if (obj.isAnnotationPresent(IssueInfo.class)) {

            Annotation annotation = obj.getAnnotation(IssueInfo.class);
            IssueInfo testerInfo = (IssueInfo) annotation;

            System.out.printf("%nType: %s", testerInfo.type());
            System.out.printf("%nReporter: %s", testerInfo.reporter());
            System.out.printf("%nCreated On: %s%n%n",
                    testerInfo.created());
        }
    }
}

TestAlpha.Java

package io.hamzeen;

import io.hamzeen.IssueInfo;
import io.hamzeen.IssueInfo.Type;

@IssueInfo(type = Type.IMPROVEMENT, reporter = "Hamzeen. H.")
public class TestAlpha {

}

IssueInfo.Java

package io.hamzeen;

import Java.lang.annotation.ElementType;
import Java.lang.annotation.Retention;
import Java.lang.annotation.RetentionPolicy;
import Java.lang.annotation.Target;

/**
 * @author Hamzeen. H.
 * @created 10/01/2015
 * 
 * IssueInfo annotation definition
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface IssueInfo {

    public enum Type {
        BUG, IMPROVEMENT, FEATURE
    }

    Type type() default Type.BUG;

    String reporter() default "Vimesh";

    String created() default "10/01/2015";
}
11
Hamzeen Hameem

Il y a 2 vues d'annotations

  1. dans la vue utilisateur, les annotations fonctionnent la plupart du temps comme un raccourci, vous épargnent quelques touches ou rendent votre programme plus lisible.

  2. vue du fournisseur, la vue du processeur sur les annotations est plutôt une "interface" pondérée, 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 parlent la même chose "Foo est une classe d'entité"

6
Dapeng

Est-ce un remplacement pour une configuration basée sur XML?

Pas complètement, mais une configuration qui correspond étroitement aux structures de code (telles que les mappages JPA ou l'injection de dépendance au printemps) peut souvent être remplacée par des annotations et est généralement beaucoup moins verbeuse, gênante et douloureuse. Presque tous les frameworks remarquables ont fait ce changement, bien que l'ancienne configuration XML reste généralement une option.

6
Michael Borgwardt

Où les annotations peuvent être utilisées

Des annotations peuvent être appliquées aux déclarations: déclarations de classes, champs, méthodes et autres éléments de programme. Lorsqu'elle est utilisée dans une déclaration, chaque annotation apparaît souvent, par convention, sur sa propre ligne.

Mise à jour de Java SE 8: Des annotations peuvent également être appliquées à l'utilisation de types. Voici quelques exemples:

  • Expression de création d'instance de classe:

    new @Interned MyObject ();

  • Type cast:

    myString = (@NonNull String) str;

  • implémente la clause:

    class UnmodifiableList implémente la liste @Readonly <@Readonly T> {...}

  • Déclaration d'exception levée:

    void monitorTemperature () lève @Critical TemperatureException {...}

3
Premraj

Les frameworks tels que Hibernate où de nombreuses configurations/mappages sont nécessaires utilisent fortement les annotations.

Jetez un oeil à Annotations Hibernate

2
medopal

JPA (from Java EE 5) est un excellent exemple de l’utilisation (excessive) d’annotations. Java EE 6 introduira également des annotations dans de nombreux nouveaux domaines. , tels que les services Web RESTful et les nouvelles annotations sous chacun le bon vieil API Servlet.

Voici plusieurs ressources:

Ce ne sont pas seulement les spécificités de la configuration qui doivent/peuvent être reprises par des annotations, mais elles peuvent également être utilisées pour contrôler le comportement. Vous voyez cela de nouveau dans les exemples JAX-RS de EE 6 Java).

2
BalusC

C'est utile pour annoter vos classes, soit au niveau de la méthode, de la classe ou du champ, quelque chose à propos de cette classe qui n'est pas tout à fait lié à la classe.

Vous pouvez avoir vos propres annotations, utilisées pour marquer certaines classes comme étant uniquement destinées à un usage test. Cela peut être simplement à des fins de documentation ou vous pouvez l'appliquer en le filtrant lors de la compilation d'une version de production candidate.

Vous pouvez utiliser des annotations pour stocker des métadonnées, comme dans un framework de plug-in, par exemple le nom du plug-in.

C'est juste un autre outil, il a plusieurs buts.

1
Chii

Il joint des informations supplémentaires sur le code par (a) vérification du compilateur ou (b) analyse de code

**

  • Voici les annotations intégrées :: 2 types

**

Type 1) Annotations appliquées à Java:

@Override // gives error if signature is wrong while overriding.
Public boolean equals (Object Obj) 

@Deprecated // indicates the deprecated method
Public doSomething()....

@SuppressWarnings() // stops the warnings from printing while compiling.
SuppressWarnings({"unchecked","fallthrough"})

Type 2) Annotations appliquées à d'autres annotations:

@Retention - Specifies how the marked annotation is stored—Whether in code only, compiled into the class, or available at run-time through reflection.

@Documented - Marks another annotation for inclusion in the documentation.

@Target - Marks another annotation to restrict what kind of Java elements the annotation may be applied to

@Inherited - Marks another annotation to be inherited to subclasses of annotated class (by default annotations are not inherited to subclasses).

**

  • Annotations personnalisées ::

** http://en.wikipedia.org/wiki/Java_annotation#Custom_annotations

POUR MIEUX COMPRENDRE ESSAYER CI-DESSOUS LINK: ÉLABORER AVEC DES EXEMPLES

http://www.javabeat.net/2007/08/annotations-in-Java-5-0/

1
krishna_kp

L’objet d’une annotation Java est simplement d’associer des informations à l’élément de programme annoté. Java peuvent être utilisées comme modificateurs dans n’importe quelle déclaration, que ce soit un paquet ou une classe. (y compris les énumérations), l'interface (y compris les types d'annotation), le champ, la méthode, le paramètre formel, le constructeur ou la variable locale.

Les annotations Java peuvent également être utilisées sur les constantes enum. Ces annotations sont placées immédiatement avant la constante d'énumération qu'elles annotent. Java sont classiquement placées avant tous les autres modificateurs, mais ce n'est pas une obligation; elles peuvent être librement mélangées à d'autres modificateurs.

Lisez en détail sur Annotations Java .

0
Krishan

Java EE 5 favorise l'utilisation des annotations sur la configuration XML. Par exemple, dans EJB3, les attributs de transaction d'une méthode EJB sont spécifiés à l'aide d'annotations. Ils utilisent même des annotations pour marquer les POJO en tant que EJB et pour spécifier des méthodes particulières en tant que méthodes de cycle de vie au lieu de nécessiter la mise en œuvre d'une interface.

0
Ken Liu

Les annotations peuvent être utilisées à la place des fichiers de configuration externes, mais ne peuvent pas être considérées comme un remplacement complet. Vous pouvez trouver de nombreux exemples dans lesquels des annotations ont été utilisées pour remplacer des fichiers de configuration, telles que Hibernate, JPA, EJB 3 et presque toutes les technologies incluses dans Java EE.

Quoi qu'il en soit, ce n'est pas toujours un bon choix. L'utilisation de fichiers de configuration a généralement pour but de séparer le code des détails de l'environnement dans lequel l'application est exécutée. Dans de telles situations, et surtout lorsque la configuration est utilisée pour mapper l'application sur la structure d'un système externe, les annotations ne remplacent pas le fichier de configuration, car elles vous invitent à inclure les détails du système externe dans le code source de ton application. Ici, les fichiers externes doivent être considérés comme le meilleur choix. Dans le cas contraire, vous devrez modifier le code source et recompiler chaque fois que vous modifiez un détail pertinent dans l'environnement d'exécution.

Les annotations sont bien plus adaptées pour décorer le code source avec des informations supplémentaires indiquant aux outils de traitement, à la compilation et à l'exécution, de gérer les classes et les structures de classes de manière spéciale. @Override et JUnit's @Test sont de bons exemples d’un tel usage, déjà expliqués en détail dans d’autres réponses.

En fin de compte, la règle est toujours la même: conservez dans la source les éléments qui changent avec la source et maintenez en dehors de la source les éléments qui changent indépendamment de la source.

0
Massimiliano Fliri