Comment et où les annotations sont-elles utilisées 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?

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 pour 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 la réflexion et la 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 l'IDE ou le compilateur, ou au moment de l' exécution par un framework.

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

• pour décrire les contraintes ou l'utilisation d'un élément: par exemple @Deprecated, @Override, ou@NotNull
• pour décrire la "nature" d'un élément, par exemple @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 sa signification .

Avant JDK5, les informations qui sont 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 appartiendront au code Java lui-même et sont donc beaucoup plus faciles à manipuler que XML.

Utilisation d'annotations:

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

... un coup d' oeil par exemple au projet Lombok , qui utilise des annotations pour définir comment générer equalsou hashCodeméthodes.

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

class Foo {

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

Celui-ci est en fait intégré au Java JDK. Le compilateur signalera une erreur, si une méthode est étiquetée avec elle, qui ne remplace pas 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, 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 ...;
    }
}

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

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

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

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 en tête lorsque vous parlez d'annotations comme «remplacement de la configuration basée sur XML». C'est le type de traitement d'annotation utilisé, par exemple, par différents frameworks et standards JCP (persistance, injection de dépendances, vous l'appelez) afin de fournir les métadonnées et informations de configuration nécessaires.

Les annotations sont une forme de métadonnées (données sur les données) ajoutées à un fichier source Java. Ils sont largement utilisés 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' @Testannotation à chaque méthode de test que vous voulez que le runner JUnit exécute. Il existe également des annotations supplémentaires concernant la configuration des tests (comme @Beforeet @BeforeClass). Tout cela est traité par le runner JUnit, qui exécute les tests en conséquence. On pourrait dire que c'est un remplacement pour 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 se réfèrent (l' @Testannotation est juste avant la méthode de test, donc le but de cette méthode est claire - sert également de documentation). D'autre part, la configuration XML peut être plus complexe et peut inclure beaucoup plus de données que les annotations.

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

• Google Guice - un exemple serait l' @Injectannotation qui, lorsqu'elle est appliquée à un constructeur, fait que le moteur d'exécution de Guice recherche des valeurs pour chaque paramètre, en fonction des injecteurs définis. L' @Injectannotation 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 devoir chercher dans un énorme fichier XML pour trouver toutes les injections de dépendance que vous avez configurées).

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

Les annotations en Java fournissent un moyen de décrire les classes, les champs et les méthodes. Essentiellement, il s'agit d'une forme de métadonnées ajoutées à un fichier source Java, elles ne peuvent pas affecter directement la sémantique d'un programme. Cependant, les annotations peuvent être lues au moment de l'exécution à l'aide de la réflexion et ce processus est connu sous le nom d'Introspection. Ensuite, il pourrait être utilisé pour modifier des classes, des champs ou des méthodes.

Cette fonctionnalité est souvent exploitée par les bibliothèques et les kits de développement logiciel (hibernate, JUnit, Spring Framework) pour simplifier ou réduire la quantité de code qu'un programmeur ferait à moins de faire dans orer pour travailler avec ces bibliothèques ou kits de développement logiciel (SDK). Travail de réflexion main dans la main en Java.

Nous pouvons également limiter la disponibilité d'une annotation à la compilation ou à l'exécution. Ci-dessous est un exemple simple de création d'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";
}

S'agit-il d'un remplacement pour la configuration basée sur XML?

Pas complètement, mais la configuration qui correspond étroitement aux structures de code (telles que les mappages 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 douloureuse. Presque tous les cadres notables ont effectué ce changement, bien que l'ancienne configuration XML reste généralement une option.

Il y a 2 vues d'annotations

1. la vue utilisateur, la plupart du temps, les annotations fonctionnent comme un raccourci, vous permettent d'économiser des touches ou de rendre votre programme plus lisible

2. vue du vendeur, la vue du processeur sur l'annotation est plutôt une «interface» légère, votre programme est confronté à QUELQUE CHOSE mais sans «implémenter» explicitement l'interface particulière (ici aussi 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 Entité"

Où les annotations peuvent être utilisées

Les 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 sur une déclaration, chaque annotation apparaît souvent, par convention, sur sa propre ligne.

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

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

  new @Interned MyObject ();

• Type de fonte:

  myString = (@NonNull String) str;

• implémente la clause:

  La classe UnmodifiableList implémente @Readonly List <@Readonly T> {...}

• Déclaration d'exception levée:

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

Des cadres comme Hibernate nécessitaient beaucoup de configuration / mappage et utilisent fortement les annotations.

Jetez un œil aux annotations Hibernate

JPA (de 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 de nouvelles annotations pour chacune des bonnes anciennes API Servlet.

Voici plusieurs ressources:

• Sun - L'API Java Persistence
• Tutoriel Java EE 5 - JPA
• Présentation de la plate-forme Java EE 6 (consultez les trois pages).

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

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

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

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

C'est juste un autre outil, il a de nombreux objectifs.

Il attache des informations supplémentaires sur le code par (a) la vérification du compilateur ou (b) l'analyse du code

**

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

**

Type 1) Annotations appliquées au code 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 LE LIEN: ÉLABORER AVEC DES EXEMPLES

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

Les annotations peuvent être utilisées comme alternative aux fichiers de configuration externes, mais ne peuvent pas être considérées comme un remplacement complet. Vous pouvez trouver de nombreux exemples où des annotations ont été utilisées pour remplacer des fichiers de configuration, comme 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. Le but de l'utilisation des fichiers de configuration est généralement de séparer le code des détails de l'environnement dans lequel l'application s'exécute. Dans de telles situations, et surtout lorsque la configuration est utilisée pour mapper l'application à la structure d'un système externe, les annotations ne sont pas un bon remplacement pour le fichier de configuration, car elles vous amènent à 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, sinon 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 beaucoup plus adaptées pour décorer le code source avec des informations supplémentaires qui indiquent aux outils de traitement, à la fois au moment de la compilation et au moment de l'exécution, de gérer les classes et les structures de classe de manière spéciale. @Overrideet JUnit @Testsont de bons exemples d'une telle utilisation, déjà expliqués en détail dans d'autres réponses.

En fin de compte, la règle est toujours la même: garder à l'intérieur de la source les choses qui changent avec la source, et garder à l'extérieur de la source les choses qui changent indépendamment de la source.

Java EE 5 privilégie l'utilisation d'annotations par rapport à la configuration XML. Par exemple, dans EJB3, les attributs de transaction sur une méthode EJB sont spécifiés à l'aide d'annotations. Ils utilisent même des annotations pour marquer les POJO en tant qu'EJB et pour spécifier des méthodes particulières en tant que méthodes de cycle de vie au lieu d'exiger cette implémentation d'une interface.

Le but d'une annotation Java est simplement d'associer des informations à l'élément de programme annoté. Les annotations Java peuvent être utilisées comme modificateurs dans n'importe quelle déclaration, que ce soit le package, la 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. Les annotations Java sont classiquement placées avant tous les autres modificateurs, mais ce n'est pas une exigence; ils peuvent être librement mélangés avec d'autres modificateurs.

Lisez en détail les annotations Java .

Voici quelques endroits où vous pouvez utiliser des annotations.

a. Annotations can be used by compiler to detect errors and suppress warnings
b. Software tools can use annotations to generate code, xml files, documentation etc., For example, Javadoc use annotations while generating java documentation for your class.
c. Runtime processing of the application can be possible via annotations.
d. You can use annotations to describe the constraints (Ex: @Null, @NotNull, @Max, @Min, @Email).
e. Annotations can be used to describe type of an element. Ex: @Entity, @Repository, @Service, @Controller, @RestController, @Resource etc.,
f. Annotation can be used to specify the behaviour. Ex: @Transactional, @Stateful
g. Annotation are used to specify how to process an element. Ex: @Column, @Embeddable, @EmbeddedId
h. Test frameworks like junit and testing use annotations to define test cases (@Test), define test suites (@Suite) etc.,
i. AOP (Aspect Oriented programming) use annotations (@Before, @After, @Around etc.,)
j. ORM tools like Hibernate, Eclipselink use annotations

Vous pouvez consulter ce lien pour plus de détails sur les annotations.

Vous pouvez faire référence à ce lien pour voir comment les annotations sont utilisées pour créer une suite de tests simple.