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

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

class Foo {

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

Celui-ci est en fait intégré dans le JDK Java. Le compilateur signalera une erreur, si une méthode est étiquetée avec elle, ce qui ne pas remplace une méthode héritée d'une classe de base. Cette annotation peut être utile pour éviter l'erreur commune, où vous avez réellement l'intention de remplacez 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 remplacée:

class Foo {

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

Le JDK7 à venir permettra des annotations sur n'importe quel type. Il existe déjà des propositions pour utiliser 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.

Un autre, plus avancé l'application pour les annotations implique un traitement de réflexion et d'annotation 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". C'est le type de traitement d'annotation utilisé, par exemple, par divers frameworks et standards JCP (persistance, injection de dépendance, vous le nommez) afin de fournir les méta-donné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 du monde réel du haut de ma tête:

• JUnit 4-vous ajoutez l'annotation @Test à chaque méthode de test que vous souhaitez que le runner JUnit exécute. Il existe également des annotations supplémentaires pour configurer les tests (comme @Before et @BeforeClass). Tous ces éléments sont traités par le runner JUnit, qui exécute les tests conséquent. Vous pourriez 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 font référence (l'annotation @Test est juste avant la méthode de test, donc le but de cette méthode est clair - sert également de documentation). La configuration XML d'autre part peut être plus complexe et peut inclure beaucoup plus de données que les annotations peuvent.

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

• Google Guice - un exemple serait l'annotation @Inject, qui, lorsqu'elle est appliquée à un constructeur, fait que le runtime Guice recherche des valeurs pour chaque paramètre, en fonction de la valeur définie injecteurs. 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 à rechercher 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 frameworks.

Les annotations en Java fournissent un moyen de décrire les classes, les champs et les méthodes. Essentiellement, ils sont une forme de métadonnées ajoutées à un fichier source Java, ils ne peuvent pas affecter la sémantique d'un programme directement. Cependant, les annotations peuvent être lues au moment de l'exécution en utilisant 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 SDK (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 SDK.Par conséquent, il est juste de dire que les annotations et la réflexion fonctionnent main dans la main en Java.

Nous pouvons également limiter la disponibilité d'une annotation à la compilation ou à l'exécution.Voici un exemple simple sur la création d'une annotation personnalisée

Conducteur.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";
}

Est-ce un remplacement pour XML basé configuration?

Pas complètement, mais la confguration qui correspond étroitement aux structures de code (telles que les mappages JPA ou l'injection de dépendance dans Spring) peut souvent être remplacée par des annotations, et est alors généralement beaucoup moins verbeuse, ennuyeuse et douloureuse. À peu près tous les frameworks notables ont fait ce changement, bien que l'ancienne configuration XML reste généralement en option.

Il y a 2 vues des annotations

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

2. Vue du fournisseur, la vue de l'annotation du processeur est plus une "interface" légère, votre programme FAIT face à QUELQUE CHOSE mais sans "implémenter" explicitement l'interface particulière (ici alias l'annotation)

Par exemple, dans 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é"

Les frameworks comme Hibernate étaient beaucoup de configuration/mappage requis utilise fortement les annotations.

Jetez un oeil à Annotations Hibernate

JPA (de Java EE 5) est un excellent exemple de la (sur)utilisation des annotations. Java EE 6 introduira également des annotations dans de nombreux nouveaux domaines, tels que les services Web RESTful et de nouvelles annotations pour la bonne vieille API Servlet.

Voici plusieurs ressources:

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

, Il n'est pas seulement la les détails de configuration qui sont à / peuvent être repris par des annotations, mais ils peuvent également être utilisés pour contrôler le comportement. Vous voyez ce bon retour dans les exemples JAX-RS de Java EE 6.

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

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

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

  Nouveau @Interné Monobjet();

• Type cast:

  MyString = (@Non null String) str;

• Implémente la clause:

  Classe UnmodifiableList implements Liste de lecture @Readonly { ... }

• Déclaration d'exception levée:

  Void monitorTemperature () jette @TemperatureException critique { ... }

Il est utile pour annoter vos classes, que ce 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 test-use uniquement. Cela pourrait simplement être à des fins de documentation, ou vous pouvez l'appliquer en le filtrant lors de votre compilation d'une version candidate de production.

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

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

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 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 ESSAYEZ LE LIEN CI-DESSOUS: É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ù annotationi ont été utilisés pour remplacer les 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 remplacent pas le fichier de configuration, car elles vous amènent à inclure les détails du système externe dans le code source de votre 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 à l'exécution, de gérer les classes et les structures de classe de manière spéciale. @Override et @Test de JUnit sont de bons exemples d'un tel usage, déjà expliqué 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 favorise l'utilisation des 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 POJOs 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, qu'il s'agisse d'un package, d'une classe (y compris les énumérations), d'une interface (y compris les types d'annotation), d'un champ, d'une méthode, d'un paramètre formel, d'un constructeur ou d'une variable locale.

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

Lire en détail surAnnotations Java .