In questo articolo andremo a discutere sulle annotazioni e come può essere utilizzato in programmazione pratico. First, discuteremo alcune idee concettuali e poi saltare in codifica di scrivere un programma di esempio utilizzando le annotazioni.
Motivazione:
In programmazione Java, ci sono diversi metodi per dichiarare il comportamento di elementi diversi (come i metodi, classes, membri ecc). Nella maggior parte dei casi queste dichiarazioni sono definiti in alcuni file esterni (XML, proprietà file etc). E poi quei file sono indicati nel programma di farlo eseguito.
In caso di annotazione, l'approccio è totalmente diverso. Le annotazioni sono meta-dati e quelli sono scritti in un formato specifico. Questi elementi di annotazione sono scritti all'interno del programma Java stesso. So, non c'è bisogno di fare riferimento qualsiasi file esterni, che è un grande vantaggio. Queste annotazioni sono facili da usare e sufficientemente flessibile per attuare.
Nella prossima sezione vedremo come questi possono essere implementati.
Qual è l'annotazione Java?
Una annotazione Java è un metadati di un programma Java. O, semplicemente parlando, un'annotazione Java fornisce informazioni su un programma Java. Nella maggior parte dei casi, non influenza direttamente il programma o il codice.
Perché si usano le annotazioni Java?
Una annotazione Java può essere utilizzato per i seguenti scopi:
- Fornire istruzioni per il compilatore
Quando il compilatore converte il codice in istruzioni leggibili, annotazioni in grado di fornire il compilatore tali istruzioni. Usually, dopo la compilazione, le annotazioni non sono presenti nel codice.
- Fornire istruzioni al costruttore
Questi giorni, si dovrebbe lasciare che strumenti come Apache Maven o Apache Ant per costruire il codice. Le annotazioni possono essere utili per strumenti di compilazione. Quando gli strumenti di costruzione vanno sui loro compiti che includere il codice sorgente di generazione, la generazione di file XML (e.g. descrittori di deployment), imballaggio codici e file in un file JAR, sembra per le annotazioni per gli ingressi sulla generazione di codice sorgente o file.
- Fornire istruzioni per l'esecuzione del software
E 'possibile definire le annotazioni per fornire input al runtime software anche se tali annotazioni possono essere raggiunti con Java Riflessioni, uno strumento diverso.
Le annotazioni possono essere sia predefiniti e personalizzati. Mentre le annotazioni personalizzate possono essere di molti tipi, annotazioni predefiniti sono di tre tipi seguenti.
@deprecated annotazione indica che una classe, metodo o campo che non è più in uso.
@ Override annotazione indica che una classe in un metodo non corrisponde a nessun metodo in una superclasse. In caso di una mancata corrispondenza, il compilatore genera un errore.
@SuppressWarnings annotazione sopprime gli avvertimenti lanciati dal compilatore. For example, se un metodo chiama un metodo deprecato, il compilatore genera un avvertimento. L'annotazione sopprime tali avvertimenti e più.
Creare il nostro primo progetto:
In questa sezione creeremo un progetto utilizzando Eclipse IDE. Il codice di esempio mostra come funziona l'annotazione in un ambiente reale. Prima di trasferirsi in hands-on di codifica abbiamo bisogno di completare la procedura di installazione per rendere l'ambiente pronto.
Di seguito sono riportati i dettagli di installazione.
Step 1: Impostazione di Java Development Kit
Scaricare JDK dal sito Oracle, installarlo e configurarlo. Quindi impostare le variabili d'ambiente PATH e JAVA_HOME.
Step 2: Configurazione IDE Eclipse
Download Eclipse from the official website. Install it and set the PATH variable.
Step 3: Download annotation packages from spring libraries.
In our example we will be using Spring annotation packages. Scaricare org.springframework.context.jar from the above link and put it in the lib folder in Eclipse IDE as shown below.
Spring packages
Figure1: Annotation Jars in lib folder
Now our environment is ready to write Java programs with annotations.
Let us create out first project by using Eclipse IDE.
Create a project in Eclipse and set the package name as com.techalpine.annotation. Under this package create three Java classes as shown below.
Project Structure
Figure2: Project structure
Three classes are BeanAnnotation.java, BeanAnnotationConfig.java and BeanAnnotationMain.java
Listing1: This is the bean class with getter and setter methods
[codice]
package com.techalpine.annotation;
public class BeanAnnotation {
String messageTxt privato;
setMessagetxt public void(String messageTxt){
this.messagetxt = messageTxt;
}
getMessagetxt public void(){
System.out.println(“Questo è il messaggio : ” + messageTxt);
}
}
[/codice]
La prossima è la classe di configurazione con @Configuration e @Fagiolo annotazioni. Queste annotazioni identificheranno il fagiolo e informare il contenitore per la rilegatura.
Listing2: Questa è la classe di configurazione
[codice]
package com.techalpine.annotation;
importare org.springframework.context.annotation. *;
@Configurazione
public class BeanAnnotationConfig {
@Fagiolo
BeanAnnotation pubblico beanannotate(){
return new BeanAnnotation();
}
}
[/codice]
La prossima è la classe principale di testare le annotazioni e come funziona.
Listing3: Questa è la classe principale
[codice]
package com.techalpine.annotation;
importazione org.springframework.context.ApplicationContext;
importare org.springframework.context.annotation. *;
public class BeanAnnotationMain {
public static void main(Stringa[] args) {
ApplicationContext CTX =
nuova AnnotationConfigApplicationContext(BeanAnnotationConfig.class);
BeanAnnotation beanannotate = ctx.getBean(BeanAnnotation.class);
beanannotate.setMessagetxt(“Ciao, Annotazione sta lavorando bene!”);
beanannotate.getMessagetxt();
}
}
[/codice]
L'esecuzione del progetto:
La struttura del progetto è completo ed è pronto per l'esecuzione. Ora eseguire l'applicazione come illustrato di seguito. Sarà un programma Java stand-alone, quindi deve essere eseguito come applicazione Java come illustrato di seguito.
applicazione Run
Figura 3: Eseguire l'applicazione
Una volta che il programma principale viene eseguito, mostrerà il seguente risultato.
Output
Figura 4: Mostrando uscita sulla console
Conclusione:
In questo articolo abbiamo discusso i concetti di annotazione e come esso può essere implementato. Spero che aiuterà gli utenti a scrivere programmi Java con annotazioni.
