Neste artigo vamos discutir sobre anotações e como eles podem ser usados em programação prática. First, vamos discutir algumas ideias conceptuais e depois saltar para codificação para escrever um programa de exemplo usando anotações.
Motivação:
Na programação Java, Há vários métodos para declarar o comportamento dos diferentes elementos (como métodos, classes, membros etc). Na maioria dos casos, estas declarações são definidos em alguns ficheiros externos (XML, arquivo de propriedades etc). E, em seguida, esses arquivos são referidos no programa para obtê-lo executado.
No caso de anotação, a abordagem é totalmente diferente. As anotações são meta-dados e aqueles são escritos em um formato específico. Estes elementos de anotação são escritas dentro do programa Java em si. So, não há necessidade de se referir quaisquer arquivos externos, que é uma grande vantagem. Estas anotações são fáceis de usar e suficientemente flexível para implementar.
Na próxima seção, vamos ver como isso pode ser implementado.
O que é anotação Java?
Uma anotação Java é um metadados de um programa Java. Ou, simplesmente falando, uma anotação de Java fornece informações sobre um programa Java. Na maioria dos casos, não influencia diretamente o programa ou código.
Por anotações Java são usados?
Uma anotação de Java pode ser utilizado para as seguintes finalidades:
- Fornecendo instruções para o compilador
Quando o compilador converte o código em instruções legíveis por máquina, anotações podem fornecer o compilador tais instruções. Usually, após a compilação, as anotações não estão presentes no código.
- Fornecendo instruções para o construtor
Nos dias de hoje, você deixaria ferramentas como o Apache Maven ou Apache Ant para construir o código. As anotações podem ser úteis para ferramentas de compilação. Quando as ferramentas de compilação ir sobre suas tarefas, que incluem o código fonte geradora, gerar arquivos XML (e.g. descritores de implementação), embalagens códigos e arquivos em um arquivo JAR, olha para as anotações para as entradas na geração de código-fonte ou arquivos.
- Fornecendo instruções para o tempo de execução de software
É possível definir as anotações para fornecer insumos para runtime software embora essas anotações podem ser acessados com reflexões Java, uma ferramenta diferente.
As anotações podem ser tanto predefinidos e personalizados. Enquanto anotações personalizadas podem ser de vários tipos, anotações predefinidas são um dos três tipos seguintes.
@Descontinuada anotação indica que uma classe, método ou campo que não está mais em uso.
@ Override annotation indicates that a class in a method does not match any method in a superclass. In case of a mismatch, the compiler throws an error.
@SuppressWarnings annotation suppresses warnings thrown by the compiler. For example, if a method calls a deprecated method, the compiler throws a warning. The annotation suppresses such warnings and more.
Creating our first project:
In this section we will create a project by using Eclipse IDE. The code sample will show how annotation works in a real environment. Before moving into hands-on coding we need to complete the installation steps to make the environment ready.
Following are the installation details.
Step 1: Setting up Java development kit
Download JDK from the Oracle site, install and configure it. Then set the PATH and JAVA_HOME environment variables.
Step 2: Setting up Eclipse IDE
Baixar Eclipse do website oficial. Instalá-lo e definir a variável PATH.
Step 3: pacotes de download de anotação de Primavera bibliotecas.
No nosso exemplo, iremos usar pacotes de anotação de Primavera. Download org.springframework.context.jar a partir do link acima e colocá-lo no lib pasta no Eclipse IDE, como mostrado abaixo.
pacotes de primavera
Figura 1: Frascos de anotação na pasta lib
Agora nosso ambiente está pronto para escrever programas Java com anotações.
Vamos criar a primeira projeto usando Eclipse IDE.
Crie um projeto no Eclipse e definir o nome do pacote como com.techalpine.annotation. Ao abrigo deste pacote criar três classes Java, como mostrado abaixo.
Estrutura do projeto
Figura 2: estrutura do projeto
Três classes são BeanAnnotation.java, BeanAnnotationConfig.java e BeanAnnotationMain.java
Listing1: Esta é a classe bean com métodos get e set
[código]
com.techalpine.annotation pacote;
public class BeanAnnotation {
private String messagetxt;
public void setMessagetxt(String messagetxt){
this.messagetxt = messagetxt;
}
public void getMessagetxt(){
System.out.println(“This is the message : ” + messagetxt);
}
}
[/código]
Next is the configuration class with @Configuration and @Bean annotations. These annotations will identify the bean and inform the container for binding.
Listing2: This is the configuration class
[código]
com.techalpine.annotation pacote;
import org.springframework.context.annotation.*;
@Configuration
public class BeanAnnotationConfig {
@Bean
public BeanAnnotation beanannotate(){
return new BeanAnnotation();
}
}
[/código]
Next is the main class to test the annotations and how it works.
Listing3: This is the main class
[código]
com.techalpine.annotation pacote;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;
public class BeanAnnotationMain {
public static void main(Corda[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(BeanAnnotationConfig.class);
BeanAnnotation beanannotate = ctx.getBean(BeanAnnotation.class);
beanannotate.setMessagetxt(“Hello, Annotation is working fine!”);
beanannotate.getMessagetxt();
}
}
[/código]
Executing the project:
The project structure is complete and it is ready to execute. Now run the application as shown below. It will be a stand-alone Java program, so it has to be run as a Java application as shown below.
Run application
Figure3: Run the application
Once the main program is executed, it will show the following output.
Output
Figure4: Showing output on the console
Conclusão:
In this article we have discussed the concepts of annotation and how it can be implemented. Hope it will help the users to write Java programs with annotations.
