Desde a introdução das anotações na versão Java 5.0, tornou -se uma parte muito importante da plataforma Java. Durante o processo de desenvolvimento, geralmente vemos anotações como @Override e @Deprecated no código do aplicativo. Neste artigo, direi a você o que são as anotações, por que elas devem ser introduzidas, como as anotações funcionam, como escrever anotações personalizadas (através de exemplos) e em que circunstâncias você pode usar anotações, bem como as mais recentes anotações e ADF (estrutura de desenvolvimento de aplicativos). Levará um pouco de tempo, então prepare -se uma xícara de café e deixe -nos entrar no mundo da anotação.
O que é anotação?
Uma palavra pode descrever as anotações, ou seja, metadados, ou seja, dados que descrevem dados. Portanto, pode -se dizer que a anotação é os metadados do código -fonte. Por exemplo, o seguinte código:
@OverridePublic String tostring () {return "Esta é a representação da string do objeto atual.";}No código acima, reescrevo o método ToString () e uso a anotação @Override. No entanto, mesmo que eu não use a anotação @Override para marcar o código, o programa pode executar normalmente. Então, o que significa a anotação? Existe algum benefício em escrever dessa maneira? De fato, @Override diz ao compilador que esse método é um método de reescrita (metadados que descrevem o método). Se o método não existir na classe pai, o compilador relatará um erro, solicitando que o método não reescreva o método na classe pai. Se eu acidentalmente soletrar o erro de digitação errado, por exemplo, escreva o tostring () como tostring () {duplo r} e não uso a anotação @Override, o programa ainda pode ser compilado e executado. Mas os resultados da operação serão muito diferentes do que eu esperava. Agora entendemos o que são anotações e o uso de anotações ajuda a ler o programa.
A anotação é um modificador especial aplicado a classes, métodos, parâmetros, variáveis, construtores e declarações de pacotes. É uma ferramenta selecionada pelo padrão JSR-175 para descrever os metadados.
Por que apresentar anotações?
Antes (ou mesmo após o uso), o XML é amplamente usado para descrever metadados. Alguns desenvolvedores e arquitetos de aplicativos começaram a descobrir que a manutenção do XML está ficando cada vez pior. Eles querem usar algo firmemente acoplado ao código, em vez de uma descrição de código que é vagamente acoplada ao código (e em alguns casos até completamente separado) como o XML. Se você procurar "XML vs. anotações" no Google, verá muitos debates sobre esse problema. O mais interessante é que a configuração XML é realmente introduzida para separar o código e a configuração. As duas visualizações acima podem confundi -lo. Ambas as visões parecem formar um ciclo, mas cada uma tem seus prós e contras. Vamos usar um exemplo para entender a diferença entre os dois.
Se você deseja definir muitas constantes ou parâmetros para o seu aplicativo, o XML é uma boa opção neste caso, pois não será conectada ao código específico. Se você deseja declarar um método como um serviço, seria melhor usar a anotação porque, neste caso, a anotação e o método precisam ser bem acoplados, e os desenvolvedores devem reconhecer isso.
Outro fator importante é que a anotação define uma maneira padrão de descrever metadados. Antes disso, os desenvolvedores geralmente definem metadados à sua maneira. Por exemplo, use interfaces, anotações, palavras -chave transitórias e assim por diante. Cada programador define metadados à sua maneira, diferentemente da maneira padrão da Anotation.
Atualmente, muitas estruturas usam XML e anotações em combinação para equilibrar os prós e os contras entre os dois.
Como funciona a anotação? Como escrever uma anotação personalizada?
Antes de contar esta parte, recomendamos que você faça o download primeiro da anotações de código de exemplo anotaçõesSsample.zip. Após o download, coloque -o no IDE que você está acostumado a usar. Esses códigos o ajudarão a entender melhor o mecanismo de anotação.
A anotação de gravação é muito simples, você pode comparar a definição de anotação com a definição de interface. Vejamos dois exemplos: um é a anotação padrão @Override, e o outro é a anotação definida pelo usuário @todo.
@Target (elementType.method) @retention (retentionpolicy.source) public @interface substituir {}Você pode ter algumas perguntas sobre a anotação @Override, não faz nada, então como ele verifica se há uma função com o mesmo nome na classe pai? Claro, não se surpreenda, estou apenas provocando você. A definição de anotação @Override não é apenas esse pequeno código. Essa parte do conteúdo é muito importante, tenho que repeti -lo novamente: anotações são apenas metadados e não têm nada a ver com a lógica de negócios. É um pouco difícil de entender, mas é isso. Se as anotações não contiver lógica de negócios, alguém deve implementá -las. Os usuários de metadados fazem isso. As anotações fornecem apenas informações sobre as propriedades que ela define (classe/método/pacote/domínio). Os usuários das anotações (novamente, algum código) leem essas informações e implementam a lógica necessária.
Quando usamos as anotações de Java (como @Override), a JVM é um usuário, que funciona no nível do bytecode. Neste ponto, os desenvolvedores de aplicativos não podem controlar ou usar anotações personalizadas. Então, vamos explicar como escrever anotações personalizadas.
Vamos falar sobre os principais pontos de gravação de anotações personalizadas, uma a uma. No exemplo acima, você vê algumas anotações aplicadas às anotações.
A versão J2SE5.0 fornece quatro tipos de meta -anotações em java.lang.annotation, que anota especificamente outras anotações:
@Documentou uma anotação de anotações simples, indicando se as informações de anotação são adicionadas ao documento Java.
@Retention define o ciclo de vida desta anotação.
RetentionPolicy.Source é descartado durante a fase de compilação. Essas anotações não têm mais nenhum significado após a compilação, portanto não escrevem bytecode. @Override, @suppresswarnings pertencem a esse tipo de anotação.
RetentionPolicy.class é descartado quando a classe é carregada. Útil no processamento de arquivos bytecode. Este é o método padrão para anotações.
RetentionPolicy.Runtime nunca é descartado e a anotação é mantida durante o tempo de execução, para que as informações da anotação possam ser lidas usando o mecanismo de reflexão. Nossas anotações personalizadas geralmente são usadas dessa maneira.
@Target indica onde essa anotação é usada. Se não for especificado, a anotação pode ser colocada em qualquer lugar. Aqui estão alguns dos parâmetros disponíveis. Deve -se notar que a anotação de atributos é compatível. Se você deseja adicionar anotação a todos os 7 atributos e excluir apenas um atributo, precisará definir o destino para incluir todos os atributos.
@InHerited define o relacionamento entre esta anotação e subclasses
Então, como é a definição interna de anotações? As anotações suportam apenas tipos básicos, string e tipos de enum. Todos os atributos do comentário são definidos como métodos e permitem fornecidos valores padrão.
@Target (elementType.method) @retention (retentionPolicy.Runtime) @Interface TODO {public Enum Priority {baixo, médio, alto} status de engaço público {iniciado, não_started} string Author () default default "n; priority priority () default priority; status; status) O exemplo a seguir demonstra como usar as anotações acima.
@Todo (Priority = TODO.priority.medium, autor = "yashwant", status = TODO.STATUS.STARTED) public void incompleteTemethod1 () {// Alguma lógica de negócios está escrita //, mas ainda não está completa} Se houver apenas um atributo na anotação, ele poderá ser nomeado diretamente "valor" e não há necessidade de indicar o nome do atributo ao usá -lo.
@Interface Author {String value ();}@autor ("yashwant") public void somemethod () {} Mas até agora tudo parece muito bom. Definimos nossas próprias anotações e aplicá -las aos métodos lógicos de negócios. Agora precisamos escrever um programa de usuário para chamar nossa anotação. Aqui precisamos usar o mecanismo de reflexão. Se você estiver familiarizado com o código de reflexão, saberá que a reflexão pode fornecer nomes de classe, métodos e objetos variáveis de instância. Todos esses objetos possuem o método getAnnotation () para retornar informações de anotação. Precisamos converter esse objeto em nosso comentário personalizado (depois de verificar com a instanceof ()) e também podemos chamar os métodos no comentário personalizado. Dê uma olhada no código de exemplo a seguir, usando a anotação acima:
Classe BusinessLogicClass = BusinessLogic.class; para (método do método: BusinessLogicClass.getMethods ()) {TODONOnTation = (TODO) Method.getAnnotation (TODO.class); if (TODOANNOTATION! = NULL) {System.out.println ("Método:" tdoannotation.author ()); system.out.println ("prioridade:" + tdoannotation.priority ()); system.out.println ("status:" + tdoannotation.status ());}}Casos de uso da anotação
As funções das anotações são muito poderosas, e estruturas como Spring e Hebernate usam anotações na extração de madeira e validade. As anotações podem ser aplicadas onde as interfaces marcadores são usadas. A diferença é que a interface de tag é usada para definir uma classe completa, mas você pode definir comentários para um único método, como expor um método como um serviço.
Muitas novas anotações foram introduzidas no mais recente Servlet 3.0, especialmente aquelas relacionadas à segurança do servlet.
Handlestyes Esta anotação é usada para representar um conjunto de classes de aplicativos passadas para o ServletContainerInitializer.
HttpConstraint Esta anotação representa as restrições de segurança para solicitações de aplicação de todos os métodos HTTP e é diferente das restrições de segurança HttpMethodConstraint definidas na anotação ServletSecurity.
HttpMethodConstraint Especifica restrições de segurança para diferentes tipos de solicitações, que são diferentes da anotação que descreve o tipo de método do protocolo HTTP na anotação do servletSecurity.
MultipartConfig Esta anotação está marcada no servlet, indicando que o tipo MIME da solicitação que o servlet deseja processar é multipart/formulário-dados.
SERVETletSecurity A anotação está marcada na classe de herança do servlet e a solicitação de protocolo HTTP é forçada a cumprir as restrições de segurança.
O Webfilter é usado para declarar um filtro de servidor;
WebinitParam Esta anotação é usada para declarar os parâmetros de inicialização no servlet ou filtro e geralmente é usado com @webServlet ou @webfilter.
WebListener Esta anotação é um tipo diferente de ouvinte de declaração de eventos no contexto do aplicativo da web.
Serviço da web Esta anotação é usada para declarar a configuração de um servlet.
ADF (Application Framework) e anotações
Agora começamos a discutir a última parte do artigo. A estrutura de aplicativos, conhecida como ADF, é desenvolvida pela Oracle para criar aplicativos convergentes do Oracle. Entendemos as vantagens e desvantagens das anotações e sabemos como escrever anotações personalizadas, mas para onde devemos aplicar as anotações? O ADF fornece algumas anotações simples? Uma boa pergunta, de fato, existem algumas limitações no uso de anotações no ADF. As estruturas de aplicativos mencionadas anteriormente, como Spring e Hibernate, usam AOP (programação orientada para o lado). Na AOP, a estrutura fornece um mecanismo para injetar código no pré-processamento e subsequente processamento de eventos. Por exemplo: você tem um gancho para adicionar código antes e depois da execução do método, para que você possa escrever seu código de usuário nesses locais. O ADF não usa AOP. Se tivermos algum caso de uso para anotação disponível, talvez seja necessário implementá -lo por meio de herança.
Espero que goste deste artigo para ajudá -lo a entender melhor o significado da anotação!