Quali sono le principali aree in cui possiamo usare le annotazioni? La funzione sostituisce la configurazione basata su XML?
Quali sono le principali aree in cui possiamo usare le annotazioni? La funzione sostituisce la configurazione basata su XML?
Risposte:
Le annotazioni sono meta-meta-oggetti che possono essere usati per descrivere altri meta-oggetti . I meta-oggetti sono classi, campi e metodi. Chiedere a un oggetto il suo metaoggetto (ad es. anObj.getClass()
) Si chiama introspezione . L'introspezione può andare oltre e possiamo chiedere a un metaoggetto quali sono le sue annotazioni (ad es aClass.getAnnotations
.). Introspezione e annotazioni appartengono a ciò che si chiama 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 utilizzata in molti modi diversi:
@Deprecated, @Override
, oppure@NotNull
@Entity, @TestCase, @WebService
@Statefull, @Transaction
@Column, @XmlElement
In tutti i casi, un'annotazione viene utilizzata per descrivere l'elemento e chiarirne il significato .
Prima di JDK5, le informazioni ora espresse con le annotazioni dovevano essere archiviate altrove e venivano spesso utilizzati file XML. Ma è più conveniente usare le annotazioni perché apparterranno al codice Java stesso e sono quindi molto più facili da manipolare rispetto all'XML.
Utilizzo delle annotazioni:
... dai uno sguardo ad esempio al progetto Lombok , che usa le annotazioni per definire come generare equals
o hashCode
metodi.
Esistono applicazioni multiple per le annotazioni di Java. Prima di tutto, possono essere utilizzati dal compilatore (o dalle estensioni del compilatore). Considera ad esempio l' annotazione Sostituzione :
class Foo {
@Override public boolean equals(Object other) {
return ...;
}
}
Questo è in realtà integrato in Java JDK. Il compilatore segnalerà un errore, se qualche metodo è taggato con esso, il che lo fa non sovrascrive un metodo ereditato da una classe base. Questa annotazione può essere utile al fine di evitare l'errore comune, in cui si intende effettivamente ignorare un metodo, ma non si riesce a farlo, poiché la firma fornita nel proprio metodo non corrisponde alla firma del metodo da sovrascrivere:
class Foo {
@Override public boolean equals(Foo other) { // Compiler signals an error for this one
return ...;
}
}
A partire da JDK7, le annotazioni sono consentite su qualsiasi tipo. Questa funzione può ora essere utilizzata per le annotazioni del compilatore come NotNull , come in:
public void processSomething(@NotNull String text) {
...
}
che consente al compilatore di avvisarti di usi impropri / non controllati delle variabili e valori null .
Un'altra applicazione più avanzata per le annotazioni prevede l'elaborazione della riflessione e delle annotazioni in fase di esecuzione. Questo è (penso) quello che avevi in mente quando parli delle annotazioni come "sostituzione della configurazione basata su XML". Questo è il tipo di elaborazione delle annotazioni utilizzata, ad esempio, da vari framework e standard JCP (persistenza, iniezione di dipendenza, tu lo chiami) per fornire i metadati e le informazioni di configurazione necessari.
Le annotazioni sono una forma di metadati (dati sui dati) aggiunti a un file sorgente Java. Sono ampiamente utilizzati dai framework per semplificare l'integrazione del codice client. Un paio di esempi del mondo reale dalla cima della mia testa:
JUnit 4: aggiungi l' @Test
annotazione a ciascun metodo di test che desideri eseguire il runner JUnit. Ci sono anche ulteriori annotazioni da fare con l'impostazione del test (come@Before
e @BeforeClass
). Tutti questi sono elaborati dal corridore JUnit, che esegue i test di conseguenza. Si potrebbe dire che è un sostituto della configurazione XML, ma a volte le annotazioni sono più potenti (possono usare la riflessione, per esempio) e sono anche più vicine al codice a cui si riferiscono (l' @Test
annotazione è proprio prima del metodo di test, quindi lo scopo di quel metodo è chiaro - serve anche come documentazione). La configurazione XML, d'altra parte, può essere più complessa e può includere molti più dati rispetto alle annotazioni.
Terracotta: utilizza sia le annotazioni che i file di configurazione XML. Ad esempio, il@Root
annotazione indica al runtime di Terracotta che il campo annotato è una radice e che la sua memoria deve essere condivisa tra istanze di macchine virtuali. Il file di configurazione XML viene utilizzato per configurare il server e comunicargli quali classi utilizzare.
Google Guice - un esempio potrebbe essere l' @Inject
annotazione, che quando applicata a un costruttore fa sì che il runtime di Guice cerchi valori per ciascun parametro, in base agli iniettori definiti. Il@Inject
annotazione sarebbe piuttosto difficile da replicare usando i file di configurazione XML e la sua vicinanza al costruttore a cui fa riferimento è abbastanza utile (immagina di dover cercare un enorme file XML per trovare tutte le iniezioni di dipendenza che hai impostato).
Spero di averti dato un'idea di come vengono usate le annotazioni in diversi framework.
Le 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 utilizzato per modificare classi, campi o metodi.
Questa funzione è spesso sfruttata da Librerie e SDK (ibernazione, JUnit, Spring Framework) per semplificare o ridurre la quantità di codice che un programmatore farebbe a meno che non facciano o meno per lavorare con queste Librerie o SDK. Pertanto, è giusto dire Annotazioni e La riflessione funziona congiuntamente in Java.
Possiamo anche limitare la disponibilità di un'annotazione al tempo di compilazione o al runtime. Di seguito è 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<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";
}
È un sostituto per la configurazione basata su XML?
Non del tutto, ma la configurazione che corrisponde strettamente alle strutture di codice (come i mapping JPA o l'iniezione delle dipendenze in primavera) può spesso essere sostituita da annotazioni, e di solito è molto meno dettagliata, fastidiosa e dolorosa. Quasi tutti i framework importanti hanno fatto questo passaggio, sebbene la vecchia configurazione XML di solito rimanga un'opzione.
Ci sono 2 viste di annotazioni
vista utente, la maggior parte delle volte, le annotazioni funzionano come una scorciatoia, ti salvano alcuni tasti o rendono il tuo programma più leggibile
vista del fornitore, 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 anche l'annotazione)
ad esempio in jpa si definisce qualcosa di simile
@Entity class Foo {...}
invece di
class Foo implements Entity {...}
entrambi parlano la stessa cosa "Foo is a Entity class"
Dove si possono usare le annotazioni
Le annotazioni possono essere applicate alle dichiarazioni: dichiarazioni di classi, campi, metodi e altri elementi del programma. Se utilizzato su una dichiarazione, ogni annotazione appare spesso, per convenzione, su una propria riga.
Aggiornamento Java SE 8: le annotazioni possono essere applicate anche all'uso dei tipi. Ecco alcuni esempi:
Espressione di creazione dell'istanza di classe:
new @Interned MyObject ();
Tipo cast:
myString = (@NonNull String) str;
implementa la clausola:
class UnmodifiableList implementa l'elenco @Readonly <@Readonly T> {...}
Dichiarazione di eccezione generata:
void monitorTemperature () genera @Critical TemperatureException {...}
Frame come Hibernate dove sono richieste molte configurazioni / mappature è necessario utilizzare le Annotazioni pesantemente.
Dai un'occhiata alle annotazioni di ibernazione
JPA (da Java EE 5) è un eccellente esempio dell'uso (eccessivo) di annotazioni. Java EE 6 introdurrà anche annotazioni in molte nuove aree, come i servizi Web RESTful e nuove annotazioni per ciascuna delle buone API servlet.
Ecco alcune risorse:
Non sono solo le specifiche di configurazione che devono / possono essere rilevate dalle annotazioni, ma possono anche essere utilizzate per controllare il comportamento. Lo vedi bene negli esempi JAX-RS di Java EE 6.
È utile per annotare le tue classi, a livello di metodo, classe o campo, qualcosa su quella classe che non è del tutto correlato alla classe.
Potresti avere le tue annotazioni, utilizzate per contrassegnare determinate classi solo come test-use. Potrebbe essere semplicemente a scopo di documentazione, oppure è possibile applicarlo filtrandolo durante la compilazione di un candidato alla versione di produzione.
È possibile utilizzare le annotazioni per memorizzare alcuni metadati, ad esempio in un framework di plug-in, 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
**
**
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 subclasses of annotated class (by default annotations are not inherited to subclasses).
**
** http://en.wikipedia.org/wiki/Java_annotation#Custom_annotations
PER UNA MIGLIORE COMPRENSIONE PROVA SOTTO IL LINK: ELABORA CON ESEMPI
Le annotazioni possono essere utilizzate in alternativa ai file di configurazione esterni, ma non possono essere considerate una sostituzione completa. Puoi trovare molti esempi in cui le annotazioni sono state usate per sostituire i file di configurazione, come Hibernate, JPA, EJB 3 e quasi tutte le tecnologie incluse in Java EE.
Comunque questa non è sempre una buona scelta. Lo scopo dell'utilizzo dei file di configurazione è di solito quello di separare il codice dai dettagli dell'ambiente in cui l'applicazione è in esecuzione. 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 rimpiazzo per il file di configurazione, in quanto portano a includere i dettagli del sistema esterno nel codice sorgente di la tua applicazione. Qui i file esterni devono essere considerati la scelta migliore, altrimenti dovrai modificare il codice sorgente e ricompilare ogni volta che cambi un dettaglio rilevante nell'ambiente di esecuzione.
Le annotazioni sono molto più adatte per 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 le classi e le strutture delle classi in modo speciale. @Override
e JUnit @Test
sono buoni esempi di tale utilizzo, già spiegati in dettaglio in altre risposte.
Alla fine la regola è sempre la stessa: tenere dentro la fonte le cose che cambiano con la fonte e tenere fuori dalla fonte le cose che cambiano indipendentemente dalla fonte.
Java EE 5 favorisce l'uso delle annotazioni sulla configurazione XML. Ad esempio, in EJB3 gli attributi di transazione su un metodo EJB sono specificati usando le annotazioni. Usano persino le annotazioni per contrassegnare i POJO come 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 quello di associare informazioni con l'elemento del programma annotato. Le annotazioni Java possono essere utilizzate come modificatori in qualsiasi dichiarazione, sia che si tratti di pacchetti, classi (inclusi enum), interfaccia (compresi i tipi di annotazioni), campo, metodo, parametro formale, costruttore o variabile locale.
Le annotazioni Java possono essere utilizzate anche su costanti enum. Tali annotazioni vengono posizionate immediatamente prima della costante enum che annotano. Le annotazioni Java sono posizionate convenzionalmente davanti a tutti gli altri modificatori, ma questo non è un requisito; possono essere mescolati liberamente con altri modificatori.
Leggi in dettaglio su Annotazioni Java .
Di seguito sono riportati alcuni dei luoghi in cui è possibile utilizzare le annotazioni.
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
Puoi fare riferimento a questo link per maggiori dettagli sulle annotazioni.
Puoi fare riferimento a questo link per vedere come vengono usate le annotazioni per creare una semplice suite di test.