do Arquivo - Acesso ao Portal Claretiano

Análise das vantagens na busca por novas técnicas
de programação, por meio do estudo da linguagem
Java e seu recurso chamado “annotations”1
Gabriel Augusto Duarte
2
Resumo: Muito se fala sobre novas tecnologias e novos métodos para o desenvolvimento
de sistemas, mas poucos desenvolvedores param para analisar o quanto a tecnologia evoluiu
até chegar ao ponto em que se encontra atualmente. Este estudo faz uma análise geral de
um recurso chamado Anotações, para que uma base comparativa seja criada, podendo-se,
assim, analisar outros recursos e tecnologias semelhantes. Muitas vezes não se nota o quanto
o dia-a-dia pode ser mais organizado, prático e lucrativo, quando se muda uma rotina ou
um paradigma que antes parecia muito bem focado, mas que graças à competitividade de
um mercado sempre mais exigente, torna-se obsoleto em pouco tempo.
Palavras-chave: Sistemas de Informação. Desenvolvimento de Sistemas. JAVA.
Anotações do Java. Evolução das linguagens de programação.
Orientador: Prof. Ms. Klausner Vieira Gonçalves.
Formado em Sistemas de Informação e cursando a especialização em Engenharia
e Administração de Sistemas de Bancos de Dados pela UNICAMP. Atua no
desenvolvimento de sistemas web para as Faculdades Claretianas de Rio Claro desde
2009. E-mail: <[email protected]>.
1
2
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
225
1. INTRODUÇÃO
Estão sempre surgindo novas tecnologias para o desenvolvimento
de sistemas. Mas até que ponto conhecer essas novas ferramentas ou
técnicas pode ser melhor que trabalhar com as que já se conhece e se
tem prazer em trabalhar? Manter o equilíbrio é exatamente o desafio dos
desenvolvedores.
Nota-se isso observando que programadores de COBOL, uma
linguagem de meio século, encontram ainda hoje oportunidades no
mercado. Mas deve se atentar ao fato de que a linguagem em questão
evoluiu, e os programadores necessitaram, em algum momento, evoluir
junto a eles.
Este artigo tem como objetivo não só apresentar uma ferramenta,
as anotações do Java, mas também trazer à tona a necessidade de se
aprofundar na tecnologia da preferência de cada um.
2. MATERIAIS E MÉTODOS
Linguagens de programação e sua evolução
O ser humano tem, em sua essência, a necessidade de desenvolver
ferramentas que facilitem o seu dia a dia. Ao longo de toda essa existência
criativa da humanidade, notou-se que todo problema é mais facilmente
resolvido se dividido em problemas menores. Deu-se, nesse momento,
o início da informática, surgindo como meio de dividir problemas e
posteriormente, fazê-los interpretáveis pelos computadores através de
comandos.
Segundo Sebesta (2000), os primeiros computadores eram utilizados
somente no meio científico e isso graças ao fato de que esses eram
extremamente difíceis de operar. A linguagem humana e a linguagem
computacional estavam distantes e cada comando exigia horas de trabalho
para ser feito, como no caso dos cartões perfurados. A solução foi criar
uma linguagem intermediária entre o computador e o homem.
226
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
Essas linguagens necessitaram evoluir ao longo dos anos para se
adaptar às novas necessidades e aos novos recursos. Podemos citar como
marco nessa evolução a criação do Paradigma Estruturado e posteriormente
Orientado a Objetos, na qual se baseou a linguagem JAVA.
Linguagem JAVA
Em meados da década de 1990, desenvolvedores da Empresa SUN
(Microsystems)trabalhavam no desenvolvimento de uma espécie de TV
interativa, mas a linguagem utilizada na época, o C++, não era suficiente
para satisfazer as necessidades apresentadas pelo projeto, conforme nos
diz Cadenhead (2005). James Gosling, líder do projeto, decidiu então
utilizar os esforços de sua equipe para a produção de uma linguagem que
atendesse esses requisitos.
Segundo JAVA (2010) o esforço do corpo de engenheiros não foi
suficiente para criar a TV, pois era avançada demais para a época, mas a
nova linguagem foi então utilizada em um meio que ainda ganhava força
na época, a internet.
Em 1995 a SUN anunciou o lançamento do Java como um pacote
de ferramentas de desenvolvimento gratuito. E, embora com recursos
primitivos se comparados aos dias atuais, poderiam ser utilizados nas
páginas vistas no Netscape Navigator.
O JAVA possui inúmeras características que o fazem merecedor do
prestígio atingido, entre elas:
• orientação a objetos;
• ser uma linguagem distribuída;
• segurança;
• portabilidade;
• ser uma linguagem interpretada.
Além das características acima informadas, os desenvolvedores devem
conhecer as características internas da linguagem, necessárias durante a
codificação. São elas:
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
227
•
•
•
•
•
ausência de ponteiros;
existência de um tipo booleano;
herança simples;
existência de threads ou processos assíncronos;
coleta automática de lixo de memória (GarbageCollection).
JAVA e a internet
Conforme dito anteriormente, o JAVA foi criado com o objetivo de
ser uma linguagem voltada à comunicação em rede. Entre as ferramentas
que atingiram esse objetivo, podemos citar os applets, o servlets e as
páginas JSP.
Os applets são pequenos programas utilizados em páginas web
que fornecem um grande leque de opções ao desenvolvimento. Esses
já compuseram boa parte da utilização do JAVA, mas hoje em dia são
utilizados apenas em aplicações mais específicas.
Servlet é o nome utilizado como diminutivo de server, ou servidor.
Como remete o seu nome, estes aplicativos são utilizados no servidor e
possuem um grande poder de manipulação de requisições via internet.
Já as páginas JSP foram criadas com o intuito de anexar os códigos
JAVA ao conteúdo HTML, facilitando o desenvolvimento. Podemos
utilizar todas as ferramentas dos servlets nas páginas JSP.
Anotações
Em qualquer linguagem de programação, é necessário organização
e padronização nos códigos, para que seja mais simples sua manutenção.
No JAVA isso pode ser feito de diversas maneiras, como os Javadocs, a
documentação automática do JAVA,uso de interfaces ou através da
generalização de classes.
Além dessas ferramentas, podem ser utilizadas as anotações do JAVA.
Anotação é uma informação adicionada ao código no formato @nome_
da_anotação que não alteram diretamente o fluxo do sistema. Conforme
228
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
Oracle (2010), anotações podem ser utilizadas em três situações: passando
informações ao compilador; para gerar meta-informações na forma
de documentação, arquivos XML, entre outros. Para serem avaliadas
em tempo de execução, causando um desvio indireto na execução do
sistema.
Anotações podem tratar especificamente um elemento do código,
como uma classe, um método, atributo, pacote etc.
Anotações utilizadas pelo compilador: são três as anotações
utilizadas pelo compilador. A anotação @Deprecated informa que o
método que a contém não deve mais ser utilizado, pois foi substituído
por outro melhor. @Override indica que o método foi sobrescrito de
uma classe mãe e @SupressWarning indica que avisos do tipo ”Warning”
podem ser ignorados.
Anotações utilizadas para gerar documentos e outros códigos:
são anotações criadas pelo desenvolvedor com a finalidade de serem lidas
externamente. Vejamos um exemplo, por Oracle (tutorial/java/javaOO/
annotations.html>. Acesso em: 30 set. 2010):
1. @ClassPreamble (
2. author = “John Doe”,
3. date = “3/17/2002”,
4. currentRevision = 6,
5. lastModified = “4/12/2004”,
6. lastModifiedBy = “Jane Doe”,
7. reviewers = {“Alice”, “Bob”, “Cindy”} // Note array notation
8. }
9. public class Generation3List extends Generation2List {
10. // classcodegoeshere
11. }
Anotações – exemplo de anotações – Oracle (disponível em:
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
229
download.oracle.com/javase/tutorial/java/javaOO/annotations.html>.
Acesso em: 30 set. 2010)
Anotações avaliadas em tempo de execução: são anotações utilizadas
pelo próprio sistema com o objetivo de causar alguma alteração em seu
fluxo de execução. Embora possam existir muitas formas de anotações, a
seguir estão exemplos que compreendem a maioria delas.
Anotação sem valor interno: pode se criar uma anotação apenas
para verificar sua existência. Um exemplo seria a anotação @Obrigatorio
que poderia ser utilizada para a validação dos dados de um objeto antes da
inserção de seus dados no banco de dados. Exemplo:
1. @Retention(RetentionPolicy.RUNTIME)//Em tempo de
execução
2. @Target(ElementType.FIELD) //Anotação de atributos
3. public @interface Obrigatorio {}(citação pessoal).
Anotação com apenas um valor: anotações podem receber apenas
um valor. Para isso, utilizamos em sua criação o campo value. Um exemplo
seria criar uma anotação que armazenasse uma nota para ser enviada ao
usuário.
1. @Retention(RetentionPolicy.RUNTIME) //Em tempo de
execução
2. @Target(ElementType.TYPE) //Anotação de classes
3. public @interface Nota{
4. Stringvalue();
5. }(citação pessoal).
Um detalhe importante a ser notado é que os campos das anotações
são criados como métodos estáticos. Isso torna perceptível que anotações
são na verdade interfaces e não classes. A diferença entre uma interface e
uma anotação é a marcação interface e @interface, respectivamente.
230
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
Anotações com mais de um valor: anotações podem receber
quaisquer valores, sejam tipos primitivos ou classes. Pode-se então, por
exemplo, criar uma anotação que armazene valores para um cálculo.
1. @Retention(RetentionPolicy.RUNTIME) //Em tempo de
execução
2. @Target(ElementType.TYPE) //Anotação de classes
3. public @interface ValorCalculo{
4. floatporcentagemImposto();
5. floatporcentagemDesconto();
6. floatporcentagemMulta();
7. }(citação pessoal)
Anotações – anotação com múltiplos valores: observarmos também
que a anotação, desse modo, obriga o uso de todos os seus campos. Para
que isso não ocorra é necessária a utilização da anotação default.
Exemplos do uso das anotações
Supondo que seja criado um sistema para calcular o custo de produtos
dependendo dos do tempo de entrega, e esse sistema deve exibir o tipo
do produto que está sendo calculado, deve considerar cálculos diferentes
para cada tipo de produto e ainda verificar se os campos estão todos
registrados. Embora se possa criar esse sistema das mais variadas maneiras,
uma possibilidade seria, por exemplo, criar as seguintes classes:
Código sem anotações: para que seja ilustrado o uso das anotações,
foi criado um projeto sem a sua utilização onde é realizado um cálculo
com produtos nacionais e importados. O mesmo projeto será reutilizado
posteriormente, para que fiquem claras as diferenças de utilização.
Produto: classe abstrata que possui os atributos comuns a qualquer
uma das classes filho, ProdutoNacional e ProdutoImportado.
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
231
1. public abstract class Produto {
2. privateInteger id;
3. privateString nome;
4. privateStringdescricao;
5. privateFloat valor;
6. public Produto() {
7. }
8. publicStringgetDescricao() {
9. returndescricao;
10. }
11. public void setDescricao(String descricao) {
12. this.descricao = descricao;
13. }
14. publicIntegergetId() {
15. return id;
16. }
17. public void setId(Integer id) {
18. this.id = id;
19. }
20. publicStringgetNome() {
21. return nome;
22. }
23. public void setNome(String nome) {
24. this.nome = nome;
25. }
232
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
26. publicFloatgetValor() {
27. return valor;
28. }
29. publicvoidsetValor(Float valor) {
30. this.valor = valor;
31. }
32. } (citação pessoal).
ProdutoNacional e ProdutoImportado: Classes que herdam os
atributos de Produto, estabelecendo os seus atributos particulares.
1. publicclassProdutoNacionalextends Produto {
2. public static final Float valorImposto = 10.0f;
3. public static final Float valorMulta = 5.0f;
4. publicstatic final FloatvalorDesconto = 1.0f;
5. } (citação pessoal).
1. publicclassProdutoImportadoextends Produto {
2. publicstatic final FloatvalorImposto = 20.0f;
3. public static final Float valorMulta = 8.0f;
4. publicstatic final FloatvalorDesconto = 0.5f;
5. privateFloatvalorImportacao;
6. publicProdutoImportado() {
7. super();
8. }
9. publicFloatgetValorImportacao() {
10. returnvalorImportacao;
11. }
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
233
12. publicvoidsetValorImportacao(FloatvalorImportacao) {
13. this.valorImportacao = valorImportacao;
14. }
15. }(citação pessoal).
Calculadora: classes que contém as regras de negócio para os cálculos
com produtos. Para sua utilização, seria utilizado um servlet, descrito a
seguir.
1. publicclass Calculadora {
2. publicstaticStringcalculaValor(Produto produto, int dias) {
3. Stringmsg = “”;
4. if (produto != null) {
5. Float valor = null;
6. if (produto.getId() != null&&produto.getNome() !=
null&&produto.getValor() != null&&produto.getDescricao() != null) {
7. valor = produto.getValor();
8. FloatvalorImposto = 0.0f;
9. FloatvalorMulta = 0.0f;
10. FloatvalorDesconto = 0.0f;
11. if (produto instanceofProdutoNacional || (produto
instanceofProdutoImportado&&
((ProdutoImportado)produto).
getValorImportacao() != null)) {
12. if (produto instanceofProdutoNacional) {
13. msg += “Calculando valor para produto nacional\n”;
14. valorImposto = ProdutoNacional.valorImposto;
15. valorMulta = ProdutoNacional.valorMulta;
16. valorDesconto = ProdutoNacional.valorDesconto;
17. }
234
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
18. elseif (produto instanceofProdutoImportado) {
19. msg += “Calculando valor para produto importado\n”;
20. valorImposto = ProdutoImportado.valorImposto;
21. valorMulta = ProdutoImportado.valorMulta;
22. valorDesconto = ProdutoNacional.valorDesconto;
23. valor += ((ProdutoImportado)produto).getValorImportacao();
24. }
25. if (dias > 10) {
26. valor = valor + (valor / 100 * valorMulta * (dias - 10));
27. }
28. elseif (dias < -10) {
29. valor = valor - (valor / 100 * valorDesconto * (dias + 10) * -1);
30. }
31. valor = valor + (valor / 100 * valorImposto);
32. msg += “O valor encontrado foi “ + valor + “\n”;
33. }
34. else {
35. msg += “É necessário preencher todos os campos.\n”;
36. }
37. }
38. else {
39. msg += “É necessário preencher todos os campos.\n”;
40. }
41. }
42. returnmsg;
43. }
44. }(citação pessoal).
Pode se perceber que apesar do cálculo ser simples, o código acaba
ficando complexo para respeitar os atributos de cada tipo de produto, isso
se percebe na condição que se inicia na linha 12 da calculadora. O código
necessita de um bloco como esse para cada tipo de produto.
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
235
Outro problema que encontramos nesse código é sua inflexibilidade.
Para cada produto também necessitamos procurar ocorrências como a da
linha 11 que verifica um atributo utilizado somente no produto importado.
A possibilidade de erro em um código como esse é muito grande, mesmo
para um desenvolvedor atento.
A solução para esse problema pode estar, por exemplo, nas anotações.
Neste caso vamos utilizar as mesmas criadas no tópico onde se iniciou a
explicação sobre anotações. (@Obrigatorio, @Nota, @ValorCalculo).
Código com anotações: conforme dito anteriormente, a seguir está
uma possível atualização do projeto anterior, criado sem anotações.
Produto:
1. publicclass Produto {
2. @Obrigatorio
3. privateInteger id;
4. @Obrigatorio
5. privateString nome;
6. @Obrigatorio
7. privateStringdescricao;
8. @Obrigatorio
9. privateFloat valor;
10. public Produto() {
11. }
12. publicStringgetDescricao() {
13. returndescricao;
14. }
15. public void setDescricao(String descricao) {
16. this.descricao = descricao;
236
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
17. }
18. publicIntegergetId() {
19. return id;
20. }
21. public void setId(Integer id) {
22. this.id = id;
23. }
24. publicStringgetNome() {
25. return nome;
26. }
27.
28. public void setNome(String nome) {
29. this.nome = nome;
30. }
31. publicFloatgetValor() {
32. return valor;
33. }
34. publicvoidsetValor(Float valor) {
35.
36. this.valor = valor;
37. }
38. }(citação pessoal).
ProdutoNacional e ProdutoImportado: As classes filho recebem as
anotações @Nota e @ValorCalculo, conforme código abaixo:
1. @Nota(“Produto Nacional”)
2. @ValorCalculo(
3. porcentagemDesconto = 1.0f,
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
237
4. porcentagemImposto = 10.0f,
5. porcentagemMulta = 5.0f
6. )
7. publicclassProdutoNacionalextends Produto {}
1. @Nota(“Produto Importado”)
2. @ValorCalculo(
3. porcentagemDesconto = 0.5f,
4. porcentagemImposto = 20.0f,
5. porcentagemMulta = 8.0f
6.)
7. publicclassProdutoImportadoextends Produto {
8. @Obrigatorio
9. privateFloatvalorImportacao;
10. publicProdutoImportado() {
11. super();
12. }
13. publicFloatgetValorImportacao() {
14. returnvalorImportacao;
15. }
16. publicvoidsetValorImportacao(FloatvalorImportacao) {
17. this.valorImportacao = valorImportacao;
18. }
19. }(citação pessoal).
Calculadora: A maior parte das mudanças fica na classe
Calculadora. Ela é responsável pela leitura de todos os dados contidos
agora nas anotações. A primeira vista nota-se que o código, embora mais
organizado, ficou mais complexo por conta dessa leitura, mas dando-se
conta de que esse código não aumenta, não importa quantos tipos de
238
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
produtos participem do calculo.
1. publicclass Calculadora {
2. publicstaticStringcalculaValor(Produto produto, int dias) {
3. Stringmsg = “”;
4. if (produto != null) {
5. Float valor = null;
6. if (camposPreenchidos(produto)) {
7. valor = produto.getValor();
8.FloatvalorImposto
=
produto.getClass().
getAnnotation(ValorCalculo.class).porcentagemImposto();
9.FloatvalorMulta
=
produto.getClass().
getAnnotation(ValorCalculo.class).porcentagemMulta();
10.FloatvalorDesconto
=
produto.getClass().
getAnnotation(ValorCalculo.class).porcentagemDesconto();
11. msg += produto.getClass().getAnnotation(Nota.class).value()
+ “\n”;
12. if (produto instanceofProdutoImportado) {
13. valor += ((ProdutoImportado)produto).getValorImportacao();
14. }
15. if (dias > 10) {
16. valor = valor + (valor / 100 * valorMulta * (dias - 10));
17. }
18. elseif (dias < -10) {
19. valor = valor - (valor / 100 * valorDesconto * (dias + 10) * -1);
20. }
21. valor = valor + (valor / 100 * valorImposto);
22. msg += “O valor encontrado foi “ + valor + “\n”;
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
239
23. }
24. }
25. }(citação pessoal).
As anotações resolvem os problemas propostos, pois tem o poder de
ler meta-dados das classes identificando-as não importandopara os seus
atributos. Este é um recurso valioso quando se necessita identificar valores
diferentes em diferentes classes.
Como quando lê que os campos são obrigatórios, por exemplo, no
método camposPreenchidos da calculadora com anotações. Embora o
código fique de certo modo mais complicado, se for analisado que não
mais teremos que adicionar campo a campo para ser verificado como
acontecia antes (linha 6 - calculadora sem anotações e linha 11, para casos
de campos exclusivos) e perceptível que há uma redução significativa de
trabalho.
Por sua vez, quando se utiliza a leitura do tipo de produto através
da anotação @Nota, não ocorre uma redução de trabalho, mas uma
limpeza no código, facilitando uma eventual mudança que possa ocorrer
futuramente. É muito mais simples identificar que o tipo do produto está
escrito na anotação do que quando ocorre no meio do código, como por
exemplo, nas linhas 13 e 19 do primeiro modelo de calculadora.
Percebe-se que também esta clareza no caso dos valores da anotação
@ValorCalculo, onde não são mais a leitura dos valores como atributos
da classe e sim como valores separados na anotação. É fácil identificar que
são valores especiais destacados logo no início da classe. Também não há
mais a necessidade de criação de métodos de obtenção dos mesmos e não
há risco de confusão com outros campos de objetos instanciados a partir
desta classe.
240
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
CONCLUSÃO
Portanto, conclui-se que as anotações não tornaram o código mais
simples do que o primeiro modelo onde não é utilizado este recurso, nem
tão pouco tornou menor do que o anterior. Mas as anotações tornaram
o código mais claro aos olhos de quem conheça a técnica e entenda
exatamente o porquê da sua utilização em cada ponto. Torna-se então
fundamental não somente o conhecimento da ferramenta central que foi
abordada neste trabalho, mas de todos os outros recursos e métodos que
estão por trás das boas práticas de programação.
Mostrou-se, através deste estudo, que a importância do profundo
conhecimento das ferramentas com as quais trabalhamos não está
diretamente em utilizar às mesmas e sim na capacidade de se escolher
corretamente onde e quando utilizá-las. Toda ferramenta pode trazer
benefícios a quem as utiliza, mas é necessário sempre optar pelo bom
senso na escolha de quais ferramentas utilizar. Pode se considerar errado
não se atualizar e desconhecer as ferramentas atuais de desenvolvimento,
mas também é um erro utilizar uma ferramenta apenas por utilizar.
REFERÊNCIAS
BARNES, D. J.; KÖLLING, M. Programação orientada a objetos com Java: uma
introdução básica utilizando o BlueJ. Tradução de Edson Furmankiewicz. São Paulo:
Pearson Prentice Hall, 2007.
CADENHEAD, R.; LEMAY, L. Aprenda em 21 dias Java 2. Rio de Janeiro: Elsevier,
2005.
JAVA. Saibamaissobre a tecnologia Java. 2010. Disponível em: <www.java.com/pt_
BR/about>. Acesso em: 30 set. 2010.
ORACLE. Annotations (The Java Tutorials > Learning the Java Language>. 2010.
Classes andObjects). Disponível em: <http://download.oracle.com/javase/tutorial/
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012
241
java/javaOO/annotations.html>. Acesso em: 30 set. 2010.
SEBESTA, R. W. Conceitos de linguagens de programação. Tradução de José Carlos
Barbosa dos Santos. 4. ed. Porto Alegre: Bookman, 2000.
Title: Analysis of the advantages in the search of new programming techniques through
the study of java language and its resource called “annotations”.
Author: Gabriel Augusto Duarte.
ABSTRACT: Much has been said about new technologies and methodologies for
systems development, but few developers do stop to analyse how much technology has
evolved so far. This study presents an overview of a resource called “Annotations”, aiming
at establishing a comparative basis for further analysis of other similar resources and
technologies. Very often it is not perceived how the day-to-day could be more organised,
practical and profitable if a routine or paradigm was changed, one that, so far, seemed
very well focused but, thanks to the competitiveness of a demanding market, quickly
becomes obsolete.
Keywords: Information Systems. Systems Development. JAVA. Java Annotations.
Evolution of programming languages.
242
Linguagem Acadêmica, Batatais, v. 2, n. 1, p. 225-242, jan./jun. 2012