Anotações personalizadas de Java
As anotações Java são algumas meta -informações anexadas ao código, que é usado para analisar e usar algumas ferramentas durante a compilação e o tempo de execução, e servem como funções de explicação e configuração.
As anotações não serão e não podem afetar a lógica real do código e desempenharão apenas um papel auxiliar. Incluído no pacote java.lang.annotation.
1. Meta Nota
Meta-anulação refere-se à anotação da anotação. Incluindo quatro tipos: @retention @target @document @InHerited.
1.1. @Retention: Defina a estratégia de retenção de anotações
@Retention (retentionPolicy.source) // A anotação existe apenas no código -fonte e não contém @retention (retentionpolicy.class) // a política de retenção padrão é usada. A anotação existirá no arquivo ByteCode de classe, mas não pode ser obtido em tempo de execução. @Retention (retentionpolicy.runtime) // A anotação existirá no arquivo ByteCode Class e pode ser obtida através da reflexão no tempo de execução.
Classe de anotação:
@Retention (retentionpolicy.runtime) // A anotação existirá no arquivo ByteCode de classe. @Target ({elementType.field, elementType.method} pode ser obtido através da reflexão no tempo de execução // Definir o alvo da anotação ** o intervalo do campo e a constante de enumeração/método @EsterMeta // indicará que a anotação é incluída no javadoc publicm @InterfaceMetMeta // indicar false;/*** Nome do campo* @return*/string name () padrão "";/*** é editável* @return*/boolean editable () padrão true;/*** se você deve ser exibido na lista* @return*/boolean summary () default true; ** ** ** descrição do campo* @return*/string descrição () default "; 0;} Classe de entidade:
public class Anno {@fieldMeta (id = true, nome = "Número de série", ordem = 1) private int id; @fieldMeta (name = "nome", ordem = 3) Nome da sequência privada; @fieldMeta (name = "idade", order = 2) private int idade; @fieldMeta (descrição = jeunha ", 4). getId () {return id;} public void SetId (int id) {this.id = id;} public string getName () {retorna nome;} public void setName (nome da string) {this.name = name;} public int getage () {Return Age;} public void setage (idade) {this.age =} Age; Obtenha a aula de ajuda para anotação:
classe pública classabablefield {public sTorLablefield () {} public STORNableField (fieldMeta meta, campo de campo) {super (); this.meta = meta; this.field = field; this.name = field.getName (); this.type = field.gettype ();} timblefield (fieldmeta metera, TIPO;} META PRIVADO FIELDMETA META; CAMPO DE CAMPO DE PRIVADO; Nome da String Private; classe privada <?> type; public fieldmeta getMeta () {return meta;} public void setMeta (fieldmeta (this.metA}; campo;} public string getName () {retorna nome;} public void setName (nome da string) {this.name = name;} public class <? Para obter anotações em tempo de execução, primeiro crie uma classe base:
public classe pai <t> {classe privada <t> entidade; public parent () {init ();}@suplefresswarnings ("desmarcada") list <sortablefield> init () {list <sortablefield> list = new ArrayList <rortablefield> ();/** getClass (). (classe, interface, tipo primitivo ou vazio) *, e depois a converte em parametrizado. . * getActualTyPearguments () retorna uma matriz de objetos de tipo que representam os parâmetros de tipo real desse tipo. * [0] é o primeiro nesta matriz. . * Em suma, é para obter o tipo real de parâmetros genéricos da superclasse. . */entity = (classe <T>) ((ParameterizedType) this.getClass (). getGenericsuperclass ()). getActualTyPearguments () [0]; // fieldmeta arquivado = entity.getannotation (fieldmeta.class); if (this.entity! = null) { Campos privados, mas não incluem campos herdados* entity.getfields (); Retorna apenas todos os campos públicos acessíveis da classe ou interface representados pelo objeto*na classe GetDecarared ** () Método retorna campos, métodos etc. com todas as permissões de acesso; * Consulte API * */field [] campos = entity.getDecLaredFields (); // for (campo F: campos) {// Obtenha a anotação que contém o campo FieldMeta META = F.Getannotation (FieldMeta.class); se (meta! f); list.add (sf);}} // retorna todos os métodos públicos acessíveis da classe ou interface representados pelo método do objeto [] métodos = entity.getMethods (); para (método m: métodos) {fieldmeta meta = m.getannotation (fieldmeta.class); if (meta! = null) {sTorLablefield sf = new Sortablefield (meta, m.getName (), o método M.GetRetType ()); list.add (sf);}} // esse método é para criar um me método para criar um soma (); implementar classificação // collections.sort (list, new fieldsortcom ()); coleções.sort (list, novo comparador <rortablefield> () {@overridepublic int compare (sortablefield s1, sortablefield s2) {return s1.getMeta (). order ()-s2.getMeta (). s1.getName (). Compareto (s2.getName ()); // Você também pode usar o compare para comparação}});} Lista de retorno;}} Crie uma subclasse para herdar a classe base:
classe pública Child estende o pai <NONO> {} Classe de teste:
public classe testannotation {@suppresswarnings ({"desmarcada", "RawTypes"}) public static void main (string [] args) {pai c = new Child (); list <sortablefield> list = c.init (); // obtendo a anotação na classe no sistema genérico // outl -list para (sortfield para (sortfield (); "+l.getName ()+"/t Tipo de campo: "+l.gettype ()+"/t nome da anotação: "+l.getMeta (). name ()+"/t Anotação Descrição: "+l.getMeta (). Descrição ();}}}}}}}}}}}}}}/////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
1. O princípio de trabalho da anotação:
O JDK5.0 fornece funcionalidade de anotação, permitindo que os desenvolvedores definam e usem seus próprios tipos de anotação. Esta função consiste em uma sintaxe que define o tipo de anotação e uma sintaxe que descreve a declaração de anotação, uma API que lê a anotação, um arquivo de classe que usa anotação para modificar e ferramenta de processamento de anotação.
A anotação não afeta diretamente a semântica do código, mas pode ser considerada como uma ferramenta ou biblioteca de classes de um programa. Por sua vez, terá algum efeito na semântica do programa em execução.
A anotação pode ser lida de várias maneiras através de um mecanismo de reflexão durante o tempo de execução.
2. @Override Anotation:
java.lang
Substituição do tipo de comentário
@Target (value = método)
@Retention (valor = fonte)
Public @Interface Substitua significa que uma declaração de método pretende substituir outra declaração de método na superclasse. Se o método anotar com esse tipo de anotação, mas não substituir o método da superclasse, o compilador gera uma mensagem de erro.
A anotação @Override significa que a subclasse precisa substituir o método correspondente da classe pai.
A substituição é uma anotação marcadora usada para identificar a anotação. O próprio nome da anotação representa as informações a serem fornecidas ao programa de ferramentas.
Aqui está um exemplo usando a anotação @Override:
classe A {private string ID; A (string id) {this.id = id; } @Override public string tostring () {return id; }}3. Anotação @Deprecated:
java.lang
Tipo de comentário depreciado
@Documented
@Retention (valor = tempo de execução)
Os elementos do programa depreciado em interface do @Interface anotados com @Deprecated, os programadores são desencorajados a usar esses elementos, geralmente porque é perigoso ou há melhores opções. O compilador alerta ao usar elementos de programa não aprovados ou executar reescritas no código não aprovado.
@Deprecated Anotation Representation Method não é recomendado.
Depreciado é uma anotação marcadora.
Aqui está um exemplo usando a anotação @Deprecated:
classe A {private string ID; A (string id) {this.id = id; } @Deprecated public void Execute () {System.out.println (id); } public static void main (string [] args) {a a = novo a ("a123"); A.Execute (); }}4. Anotação de @suppresswarnings:
java.lang
Comentário TypePuppresswarnings
@Target (value = {type, campo, método, parâmetro, construtor, local_variable})
@Retention (valor = fonte)
O Public @Interface Suppresswarnings indica que o aviso do compilador especificado deve não ser exibido no elemento de comentário (e todos os elementos do programa contidos nesse elemento de comentário). Observe que o conjunto de avisos que não são exibidos em um determinado elemento é um superconjunto de todos os avisos que não são exibidos no elemento. Por exemplo, se você comentar uma aula para desembarcar um aviso e anotar um método para desembarcar outro aviso, ambos os avisos serão libertados nesse método.
Dependendo do estilo, os programadores sempre devem usar essa anotação nos elementos mais internos aninhados, e só funcionará se usado lá. Se você deseja desmontar um aviso em um método específico, deve comentar o método em vez de sua classe.
A anotação @suppresswarnings indica aviso de supressão.
Aqui está um exemplo usando a anotação @suppresswarnings:
@Suppresswarnings ("desmarcado") public static void main (string [] args) {list list = new ArrayList (); list.add ("abc");}5. Anotações personalizadas:
Ao usar @interface para anotações personalizadas, a interface java.lang.annotation.annotation é herdada automaticamente e outros detalhes são concluídos automaticamente pelo compilador. Ao definir anotações, outras anotações ou interfaces não podem ser herdadas.
Personalize o comentário mais fácil:
public @interface myannotation {} use anotação personalizada: public class AnotationTest2 {@myannotation public void Execute () {System.out.println ("Método"); }} 5.1. Adicionar variáveis:
public @interface myannotation {string value1 ();} use anotações personalizadas: public class AnotationTest2 {@myannotation (value1 = "abc") public void Execute () {System.out.println ("método"); }}Quando o nome do atributo usado na anotação é o valor, a interface do valor do atributo pode ser gravada diretamente sem especificar o nome do atributo ao atribuí -lo; Exceto pelos nomes de valor variáveis inesperados, todos os nomes de variáveis precisam ser atribuídos usando o nome = value.
5.2. Adicione valores padrão:
public @interface myannotation {string value1 () padrão "abc";}5.3. Enumeração de uso multivariado:
public @interface myannotation {string value1 () padrão "abc"; Myenum value2 () padrão myenum.sunny;} enum myenum {ensolarado, chuvoso} Use anotações personalizadas:
classe pública AnoTationTest2 {@myannotation (value1 = "a", value2 = myenum.sunny) public void Execute () {System.out.println ("Método"); }} 5.4. Variáveis de matriz:
public @interface myannotation {string [] value1 () padrão "abc";} Use anotações personalizadas:
classe pública AnoTationTest2 {@myannotation (value1 = {"A", "B"}) public void Execute () {System.out.println ("Method"); }}6. Defina o escopo da anotação:
@Documented
@Retention (valor = tempo de execução)
@Target (value = anotation_type)
A retenção pública @Interface indica quanto tempo a anotação do tipo de anotação deve ser mantida. Se uma anotação de retenção não existir na declaração do tipo de comentário, a política de retenção padrão retençãopolicy.class.
Os comentários da meta -alvo são válidos apenas quando o tipo de meta comentário é usado diretamente para comentários. Se o tipo de meta comentário for usado como membro de outro tipo de comentário, ele será inválido.
retenção de enum pública Policy
estende enum <retentionpolicy> Política de retenção de comentários. As constantes para esse tipo de enumeração descrevem estratégias diferentes para manter os comentários. Eles são usados com os tipos de meta de comentários de retenção para especificar quanto tempo as anotações são retidas.
AULA
O compilador registrará comentários no arquivo de classe, mas a VM não precisa manter os comentários em tempo de execução.
Tempo de execução
O compilador gravará os comentários no arquivo de classe e a VM manterá os comentários em tempo de execução, para que possa ser lido com reflexivamente.
FONTE
Comentários para descartar o compilador. A anotação @retention pode fornecer política de retenção de anotação para compiladores ao definir anotações.
A anotação pertencente à Política de Retenção de Classe é @suppresswarnings, que não serão armazenados no arquivo .class.
6.1. Exemplos de uso em anotações personalizadas:
@Retention (retentionpolicy.class) public @interface myannotation {string [] value1 () padrão "abc";}7. Exemplo de uso de reflexão para ler informações de anotação da política de retenção de tempo de execução:
java.lang.reflect
Interface anotatedElement
Todas as classes de implementação conhecidas:
AccessibleObject, classe, construtor, campo, método, pacote representa um elemento comentado do programa atualmente em execução nesta VM. Esta interface permite a leitura reflexiva dos comentários. Todos os comentários retornados pelos métodos nesta interface são imutáveis e serializáveis. O chamador pode modificar a matriz retornada pelo acessador do membro enumerado da matriz atribuído; Isso não terá nenhum efeito na matriz devolvida por outros chamadores.
Se um método nesta interface retornar um comentário (direta ou indiretamente) contendo um membro da classe designado que referencia uma classe que não é acessível nesta VM, tentando ler a classe chamando o método retornado pela classe relevante sobre o comentário devolvido resultará em uma TypeNotPresentException.
isannotationPresent
O isannoTationPresent boolean (classe <? Extende a anotação> annotationclass) retorna true se o comentário do tipo especificado existir nesse elemento, caso contrário, retornará false. Este método foi projetado principalmente para facilitar o acesso para marcar comentários.
parâmetro:
AnotationClass - Objeto de classe correspondente ao tipo de anotação
retornar:
Retorne true se o comentário do tipo de comentário especificado existir nesse objeto, caso contrário, false
Lançar:
NullPointerException - Se a classe de anotação fornecida for nula
Comece com a seguinte versão:
1.5
getAnnotation
<T estende a anotação> t getAnnotation (classe <t> anotationClass) retorna esses comentários se houver comentários do tipo especificado desse elemento, caso contrário, o nulo será retornado.
parâmetro:
AnotationClass - Objeto de classe correspondente ao tipo de anotação
retornar:
Se os comentários do tipo de comentário especificado do elemento existirem nesse objeto, esses comentários serão retornados, caso contrário, nulo
Lançar:
NullPointerException - Se a classe de anotação fornecida for nula
Comece com a seguinte versão:
1.5
getannotações
Anotação [] getAnnotações () retorna todos os comentários que existem neste elemento. (Se esse elemento não for comentado, uma variedade de comprimento zero será retornada.) O chamador do método pode modificar a matriz retornada à vontade; Isso não terá nenhum efeito na matriz devolvida por outros chamadores.
retornar:
Todos os comentários que existem neste elemento
Comece com a seguinte versão:
1.5
getDecLaredannotações
Anotação [] getDecLaredAnnoTations () retorna todos os comentários que existem diretamente nesse elemento. Ao contrário de outros métodos nessa interface, esse método ignora as anotações herdadas. (Se não houver comentários diretamente nesse elemento, uma matriz de comprimento zero será retornada.) O chamador do método pode modificar a matriz retornada à vontade; Isso não terá nenhum efeito na matriz devolvida por outros chamadores.
retornar:
Todos os comentários que existem diretamente neste elemento
Comece com a seguinte versão:
1.5
Aqui está um exemplo de uso da reflexão para ler as informações de anotação da política de retenção de tempo de execução:
Anotações personalizadas:
@Retention (retentionpolicy.runtime) public @interface myannotation {string [] value1 () padrão "abc";} Use anotações personalizadas:
classe pública AnoTationTest2 {@myannotation (value1 = {"A", "B"}) @Deprecated public void Execute () {System.out.println ("Método"); }} Leia as informações na anotação:
public static void main (string [] args) lança Segurança de Segurança, NoschmethodException, ilegalArgumentException, ilegalAccessException, InvocationTargeTexception {ANNOTATIONTEST2 ANNOTATIONTEST2 = novo AnnoTationTest2 (); // Instância getClass do anoTationTest2Class <NoNotationTest2> C = AnoTationTest2.Class; // getMethodInstance Método Método = c.getMethod ("Execute", nova classe [] {}); // Determine se o método contém a anotação da MyAnnotation if (method.isannotationPresent (myannotation.class)) {// Obtenha a instância de anotação de Myannotation deste método myannotation myannotation = métod.getAnnotation (myannotation.class); // execute o método método.invoke (anoTationTest2, new Object [] {}); // obtenha myannotation string [] value1 = myannotation.value1 (); System.out.println (value1 [0]); } // Obtenha todas as anotações na anotação do método [] anotações = method.getAnnoTations (); para (anotação anotação: anotações) {System.out.println (anotação); }}8. Uso de anotações limitadas:
Anotações limitadas Use @target.
@Documented
@Retention (valor = tempo de execução)
@Target (value = anotation_type)
O destino público @Interface indica o tipo de elementos do programa aos quais o tipo de anotação se aplica. Se um meta -comentário de destino não existir na declaração do tipo de comentário, o tipo declarado poderá ser usado em qualquer elemento do programa. Se esse meta comentário existir, o compilador aplica o limite de uso especificado. Por exemplo, este meta comentário indica que o tipo de declaração é ele mesmo, ou seja, o tipo de meta comentário. Ele só pode ser usado nas declarações do tipo de comentário:
@Target (elementType.annotation_type) public @interface metaannotationType {...} Este meta comentário indica que o tipo de declaração só pode ser usado como tipos de membros em declarações complexas do tipo de anotação. Não pode ser usado diretamente para comentários:
@Target ({}) public @Interface membroType {...} Este é um erro de tempo de compilação que indica que uma constante elementType aparece mais de uma vez no comentário de destino. Por exemplo, os seguintes meta comentários são ilegais:
@Target ({elementType.field, elementType.method, elementType.field}) public @interface bom {...} public enum elementTypeestende o enum <lementType> tipo de elemento do programa. As constantes desse tipo de enumera fornecem uma classificação simples de elementos declarados em um programa Java.
Essas constantes são usadas com o tipo de meta comentário de destino para especificar em que circunstâncias é legal usar o tipo de comentário.
Anotação_type
Declaração do tipo de comentário
CONSTRUTOR
Declaração do método construtor
CAMPO
Declaração de campo (incluindo constantes de enumeração)
LOCAL_VARIABLE
Declaração de variável local
MÉTODO
Declaração do método
PACOTE
Declaração do pacote
PARÂMETRO
Declaração de parâmetro
TIPO
Classe, interface (incluindo tipos de comentários) ou declaração de enumeração
Exemplos de limitações no uso de anotações:
@Target (elementType.method) public @Interface myannotation {string [] value1 () padrão "abc";}9. Adicione notas ao documento de ajuda:
Para adicionar informações de anotação ao arquivo da API ao criar um arquivo javadoc, você pode usar java.lang.annotation.Documented.
Declare o documento de anotação Build em uma anotação personalizada:
@Documentedpublic @interface myannotation {string [] value1 () padrão "abc";} Use anotações personalizadas:
classe pública AnoTationTest2 {@myannotation (value1 = {"A", "B"}) public void Execute () {System.out.println ("Method"); }}10. Use herança nas anotações:
Por padrão, as anotações não são herdadas em subclasses. Você pode adicionar java.lang.annotation.inherited Declaração de anotação quando as anotações personalizadas forem usadas.
@Documented
@Retention (valor = tempo de execução)
@Target (value = anotation_type)
Public @Interface Herited indica que o tipo de anotação é herdado automaticamente. Se houver uma anotação herdada na declaração do tipo de comentário e o usuário consultar o tipo de comentário em uma declaração de classe, e não há comentário desse tipo na declaração de classe, o tipo de comentário será consultado automaticamente na superclasse da classe. Esse processo é repetido até que esse tipo de comentário seja encontrado ou o nível superior da hierarquia de classes seja atingido. Se nenhuma superclasse tiver uma anotação desse tipo, a consulta indicará que a classe atual não possui essa anotação.
Observe que, se você usar o tipo de anotação para comentar algo diferente da classe, esse tipo de meta comentário será inválido. Observe também que esse meta comentário facilita apenas a herança de comentários de superclasses; É inválido para comentários para interfaces implementadas.
O artigo acima fala brevemente sobre as anotações personalizadas do Java e o uso da reflexão para obter anotações durante o tempo de execução é todo o conteúdo que compartilho com você. Espero que possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.