Come e dove sono annotate le annotazioni in Java?

Quali sono le aree principali che possiamo usare Annotazioni? La funzionalità è una sostituzione per la configurazione basata su XML?

Le annotazioni sono meta-meta-oggetti che possono essere usati per descrivere altri meta-oggetti . I meta-oggetti sono classi, campi e metodi. Chiedere un object per il suo meta-object (es. anObj.getClass() ) è chiamato introspezione . L’introspezione può andare oltre e possiamo chiedere a un meta-object quali sono le sue annotazioni (es. aClass.getAnnotations ). L’introspezione e le annotazioni appartengono a ciò che viene chiamato riflessione e meta-programmazione .

Un’annotazione deve essere interpretata in un modo o nell’altro per essere utile. Le annotazioni possono essere interpretate in fase di sviluppo dall’IDE o dal compilatore o in fase di esecuzione da un framework.

L’elaborazione delle annotazioni è un meccanismo molto potente e può essere utilizzato in molti modi diversi:

  • per descrivere i vincoli o l’uso di un elemento: ad esempio @Deprecated, @Override o @NotNull
  • per descrivere la “natura” di un elemento, ad esempio @Entity, @TestCase, @WebService
  • per descrivere il comportamento di un elemento: @Statefull, @Transaction
  • per descrivere come elaborare l’elemento: @Column, @XmlElement

In tutti i casi, viene utilizzata un’annotazione per descrivere l’elemento e chiarirne il significato .

Prima di JDK5, le informazioni che ora sono espresse con le annotazioni dovevano essere archiviate da qualche altra parte, e i file XML venivano spesso utilizzati. Ma è più conveniente usare le annotazioni perché apparterranno al codice Java stesso e quindi sono molto più facili da manipolare rispetto a XML.

Uso delle annotazioni:

  • Documentazione, ad esempio XDoclet
  • Compilazione
  • IDE
  • Quadro di test, ad es. JUnit
  • Contenitore IoC ad esempio come Spring
  • Serializzazione, ad esempio XML
  • Programmazione orientata agli aspetti (AOP), ad es. Spring AOP
  • Server delle applicazioni, ad es. Contenitore EJB, servizio Web
  • Mappatura relazionale oggettuale (ORM), ad esempio Hibernate, JPA
  • e molti altri…

… dare un’occhiata ad esempio al progetto Lombok , che usa annotazioni per definire come generare equals o metodi hashCode .

Ci sono applicazioni mutiple per le annotazioni di Java. Prima di tutto, possono essere usati dal compilatore (o dalle estensioni del compilatore). Prendi ad esempio l’annotazione Override :

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

Questo è in realtà integrato nel JDK di Java. Il compilatore segnalerà un errore, se qualche metodo viene etichettato con esso, che non sovrascrive un metodo ereditato da una class base. Questa annotazione può essere utile per evitare l’errore comune, in cui si intende sovrascrivere un metodo, ma non è ansible farlo, poiché la firma fornita nel metodo non corrisponde alla firma del metodo sottoposto a override:

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

Il prossimo JDK7 consentirà annotazioni su qualsiasi tipo. Esistono già proposte per utilizzare questa funzionalità per le annotazioni del compilatore come NotNull , come in:

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

che potrebbe consentire al compilatore di avvertirti su usi impropri / non controllati di variabili e valori nulli .

Un’altra applicazione più avanzata per le annotazioni prevede il processo di riflessione e annotazione in fase di esecuzione. Questo è (penso) quello che avevi in ​​mente quando parli di annotazioni come “sostituzione per la configurazione basata su XML”. Questo è il tipo di elaborazione delle annotazioni utilizzata, ad esempio, da vari framework e standard JCP (persistenza, dipendenza, iniezione, nome dell’utente) per fornire i necessari metadati e informazioni sulla configurazione.

Le annotazioni sono una forma di metadati (dati sui dati) aggiunti a un file di origine Java. Sono ampiamente utilizzati dai framework per semplificare l’integrazione del codice client. Un paio di esempi del mondo reale in cima alla mia testa:

  • JUnit 4 – aggiungi l’annotazione @Test ad ogni metodo di prova che vuoi far funzionare con il runner JUnit. Ci sono anche annotazioni aggiuntive da fare con l’impostazione del test (come @Before e @BeforeClass ). Tutti questi vengono elaborati dal corridore JUnit, che esegue i test di conseguenza. Potresti dire che è un sostituto per la configurazione XML, ma le annotazioni a volte sono più potenti (possono usare la riflessione, ad esempio) e sono anche più vicine al codice a cui fanno riferimento (l’annotazione @Test è proprio prima del metodo di test, quindi lo scopo di questo metodo è chiaro – serve anche come documentazione). La configurazione XML, d’altra parte, può essere più complessa e può includere molti più dati di quante possano fare le annotazioni.

  • Terracotta: utilizza entrambe le annotazioni e i file di configurazione XML. Ad esempio, l’annotazione @Root indica al runtime di Terracotta che il campo annotato è una radice e che la sua memoria deve essere condivisa tra le istanze VM. Il file di configurazione XML viene utilizzato per configurare il server e indicare quali classi utilizzare.

  • Google Guice: un esempio potrebbe essere l’annotazione @Inject , che quando applicata a un costruttore fa in modo che il runtime Guice cerchi i valori per ciascun parametro, in base agli iniettori definiti. L’annotazione @Inject sarebbe piuttosto difficile da replicare utilizzando i file di configurazione XML e la sua vicinanza al costruttore a cui fa riferimento è piuttosto utile (immagina di dover cercare in un enorme file XML per trovare tutte le iniezioni di dipendenza che hai impostato).

Spero di averti dato un’idea del modo in cui le annotazioni vengono utilizzate in diversi framework.

Annotazioni in Java, forniscono un mezzo per descrivere classi, campi e metodi. Essenzialmente, sono una forma di metadati aggiunti a un file sorgente Java, non possono influenzare direttamente la semantica di un programma. Tuttavia, le annotazioni possono essere lette in fase di esecuzione utilizzando Reflection e questo processo è noto come Introspection. Quindi potrebbe essere usato per modificare classi, campi o metodi.

Questa funzione è spesso sfruttata dalle librerie e dagli SDK (hibernate, JUnit, Spring Framework) per semplificare o ridurre la quantità di codice che un programmatore farebbe a meno di non lavorare con queste librerie o SDK. Di conseguenza, è corretto dire annotazioni e La riflessione funziona mano nella mano in Java.

Inoltre, limitiamo la disponibilità di un’annotazione sia in fase di compilazione che in fase di esecuzione. Di seguito è riportato un semplice esempio sulla creazione di un’annotazione personalizzata

Driver.java

 package io.hamzeen; import java.lang.annotation.Annotation; public class Driver { public static void main(String[] args) { Class 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"; } 

È una sostituzione per la configurazione basata su XML?

Non completamente, ma la confgurazione che corrisponde strettamente alle strutture di codice (come i mapping JPA o l’iniezione di dipendenza in spring) può essere spesso sostituita con annotazioni, e di solito è molto meno prolissa, fastidiosa e dolorosa. Praticamente tutti i framework degni di nota hanno realizzato questo switch, anche se la vecchia configurazione XML di solito rimane un’opzione.

Ci sono 2 viste di annotazioni

  1. vista utente, la maggior parte delle volte, le annotazioni funzionano come una scorciatoia, ti fanno risparmiare alcuni tratti chiave o rendono il tuo programma più leggibile

  2. vista del venditore, la vista dell’annotazione del processore è più di “interfaccia” leggera, il tuo programma si confronta con QUALCOSA ma senza “implementare” esplicitamente la particolare interfaccia (qui nota anche l’annotazione)

per esempio in jpa definisci qualcosa del genere

 @Entity class Foo {...} 

invece di

 class Foo implements Entity {...} 

entrambi parlano la stessa cosa “Foo è una class Entity”

I framework come Hibernate erano un sacco di configurazione / mapping è richiesto utilizza le annotazioni pesantemente.

Dai un’occhiata alle annotazioni di ibernazione

JPA (da Java EE 5) è un eccellente esempio dell’uso (oltre) delle annotazioni. Java EE 6 introdurrà anche annotazioni in molte nuove aree, come i webservices RESTful e le nuove annotazioni per ciascuna delle buone vecchie API Servlet.

Qui ci sono diverse risorse:

  • Sun: Java Persistence API
  • Esercitazione su Java EE 5 – JPA
  • Presentazione della piattaforma Java EE 6 (controllare tutte e tre le pagine).

Non sono solo le specifiche di configurazione che devono / possono essere rilevate dalle annotazioni, ma possono anche essere usate per controllare il comportamento. Si vede questo bene indietro negli esempi JAX-RS di Java EE 6.

Dove possono essere usate le annotazioni

Le annotazioni possono essere applicate alle dichiarazioni: dichiarazioni di classi, campi, metodi e altri elementi del programma. Se utilizzato in una dichiarazione, ogni annotazione appare spesso, per convenzione, sulla propria riga.

Aggiornamento Java SE 8: le annotazioni possono anche essere applicate all’uso dei tipi. Ecco alcuni esempi:

  • Espressione di creazione di istanze di class:

    nuovo @Interned MyObject ();

  • Inserisci il cast:

    myString = (@NonNull String) str;

  • clausola sugli attrezzi:

    class UnmodifiableList implementa @Readonly List <@Readonly T> {…}

  • Dichiarazione di eccezione generata:

    void monitorTemperature () genera @Critical TemperatureException {…}

È utile per annotare le tue classi, a livello di metodo, di class o di campo, qualcosa su quella class che non è abbastanza correlata alla class.

Potresti avere le tue annotazioni, utilizzate per contrassegnare alcune classi solo come prova-uso. Potrebbe semplicemente essere a scopo di documentazione, oppure si potrebbe applicarlo filtrandolo durante la compilazione di un candidato alla versione di produzione.

È ansible utilizzare annotazioni per memorizzare alcuni metadati, come in un framework di plugin, ad esempio il nome del plug-in.

È solo un altro strumento, ha molti scopi.

Allega ulteriori informazioni sul codice mediante (a) controllo del compilatore o (b) analisi del codice

**

  • Di seguito sono riportate le annotazioni Built-in: 2 tipi

**

Tipo 1) Annotazioni applicate al codice 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"}) 

Tipo 2) Annotazioni applicate ad altre annotazioni:

 @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 subclasss of annotated class (by default annotations are not inherited to subclasss). 

**

  • Annotazioni personalizzate ::

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


PER UNA MIGLIORE COMPRENSIONE PROVA QUI SOTTO LINK: ELABORARE CON ESEMPI


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

Le annotazioni possono essere utilizzate come alternativa ai file di configurazione esterni, ma non possono essere considerate una sostituzione completa. Puoi trovare molti esempi in cui le annotationi sono state utilizzate per sostituire i file di configurazione, come Hibernate, JPA, EJB 3 e quasi tutte le tecnologie incluse in Java EE.

Comunque non è sempre una buona scelta. Lo scopo dell’utilizzo dei file di configurazione è solitamente quello di separare il codice dai dettagli dell’ambiente in cui è in esecuzione l’applicazione. In tali situazioni, e soprattutto quando la configurazione viene utilizzata per mappare l’applicazione alla struttura di un sistema esterno, le annotazioni non sono un buon sostituto per il file di configurazione, in quanto portano a includere i dettagli del sistema esterno all’interno del codice sorgente di la tua applicazione. Qui i file esterni devono essere considerati la scelta migliore, altrimenti sarà necessario modificare il codice sorgente e ricompilare ogni volta che si modifica un dettaglio rilevante nell’ambiente di esecuzione.

Le annotazioni sono molto più adatte a decorare il codice sorgente con informazioni aggiuntive che istruiscono gli strumenti di elaborazione, sia in fase di compilazione che in fase di esecuzione, per gestire classi e strutture di class in modo speciale. @Override e @Override JUnit sono buoni esempi di tale utilizzo, già spiegati in dettaglio in altre risposte.

Alla fine la regola è sempre la stessa: mantieni all’interno della sorgente le cose che cambiano con la fonte, e mantieniti al di fuori della fonte le cose che cambiano indipendentemente dalla sorgente.

Java EE 5 favorisce l’uso di annotazioni sulla configurazione XML. Ad esempio, in EJB3 gli attributi di transazione su un metodo EJB vengono specificati utilizzando le annotazioni. Usano persino annotazioni per contrassegnare i POJO come bean EJB e per specificare metodi particolari come metodi del ciclo di vita invece di richiedere l’implementazione di un’interfaccia.

Lo scopo di un’annotazione Java è semplicemente di associare le informazioni con l’elemento del programma annotato. Le annotazioni Java possono essere utilizzate come modificatori in qualsiasi dichiarazione, indipendentemente dal pacchetto, dalla class (incluse le enumerazioni), dall’interfaccia (inclusi i tipi di annotazione), dal campo, dal metodo, dal parametro formale, dal costruttore o dalla variabile locale.

Le annotazioni Java possono anche essere usate su costanti enum. Tali annotazioni sono posizionate immediatamente prima della costante enum che annotano. Le annotazioni Java sono convenzionalmente posizionate prima di tutti gli altri modificatori, ma questo non è un requisito; possono essere mescolati liberamente con altri modificatori.

Leggi in dettaglio su Java Annotations .