1. RetentionPolicy.Source: A anotação é retida apenas no arquivo de origem. Quando o arquivo Java é compilado em um arquivo de classe, a anotação é abandonada;
2. RetentionPolicy.class: A anotação é retida no arquivo de classe, mas é abandonada quando a JVM carrega o arquivo de classe. Este é o ciclo de vida padrão;
3. RetentionPolicy.Runtime: A anotação não é apenas salva no arquivo de classe, mas ainda existe após a JVM carregar o arquivo de classe;
Esses três ciclos de vida correspondem a: arquivo de origem java (arquivo .java) --->. Classe arquivo ----> bytecode na memória.
Então, como você escolhe o ciclo de vida da anotação certa?
Primeiro de tudo, devemos esclarecer a fonte do comprimento do ciclo de vida <Classe <tempo de execução; portanto, onde o primeiro pode agir, o último pode agir. Geralmente, se você precisar obter informações de anotação dinamicamente em tempo de execução, só poderá usar a anotação de tempo de execução; Se você deseja executar algumas operações de pré -processamento no momento da compilação, como a geração de algum código auxiliar (como o Butterknife), você pode usar a anotação de classe; Se você executar apenas algumas operações de verificação, como @Override e @SuppressWarnings, poderá usar a anotação de origem.
A seguir, é apresentada uma aplicação simples de anotações de tempo de execução.
Obtenha anotação
Você precisa obter anotações de tempo de execução através da reflexão, que podem ser obtidas de pacote, classe, campo, método ... os métodos básicos são os mesmos. Vários métodos comuns são os seguintes:
/*** Obtenha anotação do tipo especificado*/public <a estende anotações> uma getAnnotation (classe <a> annotationType);/*** Obtenha todas as anotações, se houver*/public anotações (] getAnnoTations (); Existe nesse elemento, retorne verdadeiro, se houver, caso contrário,*/public boolean isannotationPresent (Classe <? Extende a anotação> annotationType);/***Obtenha todas as anotações para parâmetros no método*/anotação pública [] [] getParameterAnnotations ();
Para usar essas funções, você deve primeiro obter os elementos correspondentes através da reflexão: classe, campo, método, etc.
Anotações personalizadas
Vamos dar uma olhada na maneira simples de usar anotações personalizadas. Aqui, primeiro definimos 3 anotações de tempo de execução:
// classe aplicável, interface (incluindo tipo de anotação) ou enum @retention (retentionpolicy.runtime) @target (elementType.type) public @Interface Classinfo {String value (); } // Os atributos de campo aplicáveis também incluem constantes enum @retention (retentionpolicy.runtime) @target (elementType.field) public @interface fieldInfo {int [] value (); } // Método aplicável @retention (retentionPolicy.Runtime) @target (elementType.method) public @Interface MethodInfo {String name () padrão "long"; String data (); Int Age () Padrão 27; }Essas três anotações são aplicáveis a elementos diferentes e todos têm atributos diferentes. Ao usar anotações, você precisa definir esses valores de atributo.
Defina outra classe de teste para usar estas anotações:
/*** Anotação de tempo de execução de teste*/@Classinfo ("classe de teste") classe public TestRuntimeanNotation {@FieldInfo (value = {1, 2}) public string fieldInfo = "filedInfo";@fieldInfo (value = {10086}) public Int I = 100; @methodinfO getMethodinfo () {return testRuntimeanNotation.class.getsimplename ();}}Ainda é muito simples de usar. Por fim, vamos ver como obter informações de anotação no código:
/*** Anotação do tempo de execução do teste*/private void _TestRuntIMeanNoTation () {StringBuffer sb = new StringBuffer (); classe <?> Cls = testRuntimeanNoTation.class; construtor <?> [] SpeciFifedBinatores = cls.getConstructors (); // obtendo o anotador <?> ") .Append ("/n "); classinfo Classinfo = cls.getannotation (classinfo.class); if (classinfo! = null) {sb.append (modifier.toString (cls.getModifiers ()). Valor: ") .Append (Classinfo.Value ()). Append ("/n/n ");} sb.append (" anotação de campo: ") .append ("/n "); campo [] campos = fieldinfOInFONFO (fieldInfinfOnfOnfOnCoNdfields (); ! = null) {sb.append (modifier.toString (field.getModifiers ()). ").append(Arrays.toString(fieldInfo.value())).append("/n/n");}}sb.append("Method annotation: ").append("/n");Method[] methods = cls.getDeclaredMethods();for (Method method: methods) {MethodInfo methodInfo = Method.getAnnotation (MethodInfo.class); if (MethodInfo! = NULL) {SB.APPEND (Modifier.ToString (Method.getModifiers ())). Append ("") .Append (Method.getRettype (). GetSImplName ()). .Append (Method.getName ()). Append ("/n"); sb.append ("Valor da anotação:") .append ("/n"); sb.append ("nome:") .append (methodinfo.name ()). Append ("/n"); sb.Append ("Data: ") .Append (MethodInfo.Data ()). Append ("/n "); sb.append (" Age: ") .Append (MethodInfo.age ()). Append ("/n ");}} System.out.print (sb.tostring ());}As operações são feitas para obter o elemento correspondente através da reflexão e, em seguida, obter a anotação no elemento e, finalmente, obter o valor do atributo da anotação.
Vamos dar uma olhada na saída, aqui vou exibi -lo diretamente no meu telefone:
Resumir
O exposto acima é toda a explicação detalhada dos conceitos básicos da anotação da linguagem Java, e espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!