Técnicas de programação declarativa

Técnicas de programação declarativa

Introdução
Programação declarativa é um paradigma da programação baseado em programação lógica. O termo discemina as linguagens de programação imperativa. Descreve o que e não como os procedimentos de um programa funcionam.
Uma anotation, na linguagem Java, é uma forma sintática de metadados que podem ser adicionados ao código-fonte. Classes, metodos, variaveis, parametros e pacotes podem ser uma anotation. Podem ser arquivos de classe gerada pelo compilador e pode ser mantido pelo JVM (maquina virtual Java) para ser recuperadas em tempo de execução.
Uma anotation fornece dados sobre um programa que não faz parte do proprio programa. Não tem efeito direto sobre o funcionamento do código. A definição do tipo de anotação parece um pouco com a definição de interface, onde a palavra chave ?interface? é precedido pelo caracter @. As anotations aparecem em primeiro lugar, muitas vezes por converção na sua propria linha.
O esquema de criação de annotations foi implementado na versão 5 do Java, mas este conceito já era presente em versões anteriores de uma forma um pouco diferente. Annotations não interferem diretamente na semântica da linguagem, mas sim na maneira que ferramentas e bibliotecas tratam o código. Podem ser lidas de arquivos fonte .java, .class, ou em run time por reflection/reflexão.

Processando uma annotation
Podemos usar mais de uma annotation. Um processador de annotation pode ler um programa em Java e tomar ações com base em suas anotações. Pode, por exemplo, gerar o código fonte auxiliar, aliviando o programador de ter que criar um código clichê que sempre segue padrões previsíveis. Para facilitar esta tarefa, a versão 5.0 do JDK inclui uma ferramenta de processamento de anotação, chamado apt . Na versão 6 do JDK, a funcionalidade do apt é uma parte padrão do compilador Java.

Documentação
Podemos criar uma anotation para substituir os comentários feitos no código.
Suponha que um grupo de software tem sido tradicionalmente começado o corpo de cada classe com comentários que fornecem informações importantes:

Generation3List classe pública estende Generation2List (
/ / Autor: John Doe
/ / Data: 2002/03/17
/ / Revisão atual: 6
/ / Última modificação: 2004/04/12
/ / Por: Jane Doe
/ / Revisores: Alice, Bill, Cindy

/ / Código da classe vai aqui
)
Para adicionar este metadados mesmo como uma anotação, você deve primeiro definir o tipo de anotação. A sintaxe para fazer isso é:

@ (Interface ClassPreamble
String (autor);
...
O corpo da definição de anotação acima contém declarações de tipo de elemento de anotação, que parecem muito com os métodos. Note-se que eles podem definir os valores padrão opcional.
Uma vez que o tipo de anotação tenha sido definida, você pode usar anotações desse tipo, com os valores preenchidos, como este:

ClassPreamble @ (
author = "John Doe",
data = "2002/03/17",
currentRevision = 6,
lastModified = "2004/04/12",
Lastmodifiedby = "Jane Doe",
Comentadores = ("Alice", "Bob", "Cindy") / / Note a notação de array
)

Anotations usadas pelo compilador
Existem três tipos mais usados de annotation que são previamente definidas pela especificação da linguagem em si: @Deprecated , @Override e @SuppressWarnings. Dentre outras que podemos verificar suas funcionalidades descritas logo abaixo.

1.1 @Deprecated
A annotation indica que o elemento marcante é obsoleto e não deve mais ser utilizado. O compilador gera um aviso sempre que um programa usa um método, classe ou campo com o @Deprecated. Quando um elemento é substituído, ele também deve ser documentado usando o Javadoc @deprecated tag. A utilização do "símbolo @" em ambos os comentários Javadoc e anotações não é uma coincidência, eles estão relacionados conceitualmente. Além disso, o tag Javadoc começa com uma minúsculas "d" e a anotação se inicia com uma letra maiúscula "D".

/ / Comentário Javadoc seguinte
/** / **
* @deprecated * @ Deprecated
* Explicação de por que foi substituído
*/ * /
@Deprecated
static void deprecatedMethod() { } static void deprecatedMethod () ()
} )

1.2 @Override
A annotation informa ao compilador que o elemento é utilizado para substituir um elemento declarado em uma superclasse.
// Método de marca / como um método da superclasse
// Que tem sido substituído
@Override @ Override
int overriddenMethod() { } overriddenMethod int () ()
Embora não seja obrigado a usar esta anotação ao substituir um método que ajuda a evitar erros, se um método marcado com @Override não corretamente substituir um método em uma de suas superclasses, o compilador gera um erro.

1.3 @SuppressWarnings
A annotation informa ao compilador para suprimir avisos específicos e que de outra forma gerar. No exemplo abaixo, um método deprecated é usado normalmente e o compilador gerar um aviso. Neste caso, porém, a annotation faz com que o alerta deva ser suprimido.
/ / Utilizar um método deprecated e dizer
/ / não ao compilador para gerar um alerta
@SuppressWarnings("deprecation")
void useDeprecatedMethod() { void useDeprecatedMethod () (
objectOne.deprecatedMethod();
}
Cada aviso do compilador pertence a uma categoria. O Java lista duas categorias: "deprecation" e "unchecked".

1.4 @Retention
A annotation informa qual é a retenção, ou seja, em que situação a marcação será usada. Por exemplo: @Retention(RetentionPolicy.RUNTIME), em run time, outras opções seriam, SOURCE e CLASS. O tipo de valores Retention Policy é encontrado no pacote java.lang.annotation.

1.5 @Target
A annotation informa a qual elemento sofrerá anotação. Por exemplo: @Target(ElementType.FIELD), neste caso o elemento é FIELD, podendo ser outros valores, TYPE (class e interface), METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE e PACKAGE.

1.6 @interface
Declara uma annotation, note a keywork @interface, por exemplo:
public @interface Obrigatorio {}
Seguindo o exemplo, podemos declara um JavaBean Pessoa:
public class Pessoa {
@Obrigatorio private String nome;
@Obrigatorio private String sobrenome;
@Obrigatorio private String cpf;
Notamos que nas linhas que iniciam com @, junto da declaração dos campos, definem também as marcações de obrigatoriedade. Após deve existir uma classe de validação do bean onde avalia se um objeto recebido está marcado com a annotation e tornar os atributos acessiveis.

1.7 @Entity
A annotation transforma uma classe Java em uma classe persistente.

1.8 @RequiresTransaction
A annotation informa ao compilador para verificar se métodos ou toda uma classe necessitam de transação. Isso evita muita duplicação de código e tira a responsabilidade do desenvolvedor ter que explicitamente se preocupar com o controle transacional, nem a necessidade de configurar tudo usando arquivos XML.

1.9 @ inherited
A annotation é automaticamente herdada. Se um Inherited meta-annotation está presente em uma declaração de tipo de annotation, e o usuário consulta o tipo de annotation em uma declaração de classe, bem como a declaração de classe não tem nenhuma annotation para este tipo, então a classe superclasse será automaticamente consultada para o tipo de annotation.

1.10 @Name
("componentName")
Define o nome do componente Seam para uma classe. Essa anotação é necessária para todos os componentes Seam.

1.11 @Scope
@Scope(ScopeTypeConversation)
Define o contexto padrão do componente. Os valores possíveis são definidos pela enumeração ScopeType: Event, Page, Conversation, Session, Business_Process, Application, Stateless.
Quando o scope não está especificado explicitamente, o padrão depende do tipo do componente. Para beans de Stateless, o padrão é Stateless. Para beans de entidade e beans stateful, o padrão é Conversation. Para JavaBeans, o padrão é Event.

1.12 @Intercept
@Intercept(InterceptionType.Always)
Determina quando interceptores Seam são ativos. Os valores possíveis são definidos pela enumeração InterceptionType: Always, After_Restore-View, After_Update_Model_Values,
Invoke_Application, Never.
Quando nenhum tipo de interceptação é especificado explicitamente, o padrão depende do tipo de componente. Para beans de entidade, o padrão é Never. Para o beans de sessão, a mensagem dirigida e JavaBeans, o padrão é Always.
1.12 Outras Annotations
@Role, @Roles, @JndiName, @Conversational, @Startup, @Install, @Synchronized, @ReadOnly, são outros exemplos pesquisados que poderiamos citar, porém para não prolongar a teoria, concluimos este trabalho com satisfação.

Conclusão
Annotation são meta-informações que guardam informações de dados dentro do próprio código-fonte. O sinal de arroba (@) é utilizado apenas para instruir o compilador sobre a necessidade de realizar certas operações para transformar a interface em algo que seja reconhecido como uma anotação (annotation).

Referências Bibliográficas
Acessos em 12/06/2010:
http://www.dmat.uevora.pt/ensino/lma/Programacao_Declarativa.pdf
http://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_declarativa
http://en.wikipedia.org/wiki/Java_annotation
http://java.sun.com/docs/books/tutorial/java/javaOO/annotations.html

Acesso em 13/06/2010.
http://javacomfarinha.blogspot.com/2007/05/annotations.html

Acessos em 16/06/2010
http://www.plugmasters.com.br/sys/materias/541/1/Annotations-em-uso
http://www.jspbrasil.com.br/mostrar/76
http://www.guj.com.br/article.show.logic?id=136
http://www.redhat.com/docs/manuals/jboss/jboss-eap-4.2/doc/seam/Seam_Reference_Guide/Seam_annotations-Annotations_for_component_definition.html
Autor: Ingrid Chaves Carneiro Greco

NetSaber - Artigos

Técnicas de programação declarativa

Artigos Relacionados

Buscar Artigos

Destaques Netsaber

Destaques Netsaber

Rede NetSaber

Sobre o Site