Se não houver métodos e tarefas para ler anotações, as anotações não serão mais úteis que as anotações. Uma parte importante do processo de uso de anotações é criada usando o processador de anotação. O Javase5 estende a API do mecanismo de reflexão para ajudar os programadores a construir rapidamente processadores de anotação personalizados.
Biblioteca de classes de processador anotada (java.lang.reflect.annotatedElement):
O Java usa a interface de anotação para representar a anotação na frente do elemento do programa, que é a interface pai de todos os tipos de anotação. Além disso, o Java adicionou uma interface AnnoTatedElement no pacote java.lang.reflect. Essa interface representa elementos do programa que podem aceitar anotações no programa. A interface possui principalmente as seguintes classes de implementação:
Classe: Definição de classe
Construtor: Definição do construtor
Campo: Definição Cumulativa do Membro
Método: Método Definição de Classe
Pacote: Pacote Definição de classe
O pacote java.lang.reflect contém principalmente algumas classes de ferramentas que implementam funções de reflexão. De fato, todas as APIs de reflexão fornecidas pelo pacote java.lang.reflect expandem a capacidade de ler as informações de anotação de tempo de execução. Quando um tipo de anotação é definido como uma anotação em tempo de execução, a anotação só pode ser visível em tempo de execução, e a anotação salva no arquivo de classe quando o arquivo de classe for carregado será lido pela máquina virtual.
A interface AnnoTatedElement é a interface pai de todos os elementos do programa (classe, método e construtor). Portanto, depois que o programa obtém o objeto AnoTatedElement de uma determinada classe por meio da reflexão, o programa pode chamar os quatro métodos a seguir do objeto para acessar as informações de anotação:
Método 1: <TextEndSannotation> tgetannotation (classe <t> anotaçãoclass): retorna uma anotação do tipo especificado que existe no elemento do programa. Se a anotação do tipo não existir, retorne nulo.
Método 2: anotação [] getAnnoTations (): retorna todas as anotações que existem no elemento do programa.
Método 3: BooleanisannotationPresent (Classe <? Extendsannotation> annotationClass): determina se o elemento do programa contém anotações do tipo especificado. Se existir, retornará verdadeiro, caso contrário, retornará false.
Método 4: 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.
Um processador de anotação simples:
/********************* Declaração de anotação ******************* */ @Target (ElementType.Field) @retention (retentionPolicy.Runtime) @DocumentEdPublic @Interface frutcolor {/** * color enum * @author peida * */public enum cor {bule, vermelho, verde};/** ** colorring attring *} @etrurn */color fruxcolor () {) sDORG. @author peida**/ @Target (elementType.field) @retention (retentionPolicy.Runtime) @DocumentEdPublic @Interface frutProvider {/*** Número do fornecedor* @return*/public int id () default -1; "";}/**************** Anotação usa ************************/public classe Apple {@fruitName ("Apple") Private String Applrename; @fruitColor (fruitcolor = cor.red) String privada hong; @fruitprovider (id = 1, name = "shaanxi) 89, Yan'an Road, Xi'an City, província de Shaanxi ") Private String AppleProvider; public void StappleColor (String AppleColor) {this.applecolor = AppColor;} public string getApplecolor () {return this ApplColor;} publicen sepplEnMaMaMaMaMaMen () {) this AppLame; getAppLename () {return appneName;} public void setAppleProvider (String appleProvider) {this.appleProvider = appleProvider;} public String getAppLeProvider () {return AppleProvider;} public void DisplayName () {System.out.Println ("o nome do norma; processador *********************** : campos) {if (field.isannotationPresent (fruitname.class)) {fruitname fruitname = (fruitname) field.getannotation (fruitname.class); strfruitName = strfruitName+fruitname.value (); if (field.isannotationPresent (fruitcolor.class)) {fruitcolor fruitcolor = (fruitcolor) campo.getannotation (fruitcolor.class); strfruitcolor = strfruitcolor+frutcolor.fruitcolor (). if (field.isannotationPresent (fruitprovider.class)) {fruitprovider frutprovider = (fruitprovider) campo.getannotation (frutprovider.class); strfruitprovicer = "Número do fornecedor:"+fruitprovider.id ()+"Nome do fornecedor:"+frutprovider.name () ()+"Supplier" " "+fruitprovider.address (); system.out.println (strfruitprovicer);}}}}/*************** {FruitInfoutil.getfruitInfo (Apple.class);}} ============================================================ Nome da fruta: Apple Fruit: Red Supplier número: 1================ Nome da fruta: Apple Fruit: Red Supply Hongfuji Building, nº 89, Yan'an Road, Xi'an City, província de ShaanxiEu basicamente li os pontos de conhecimento básicos das anotações Java (veja o mapa abaixo). No próximo artigo, projetamos uma estrutura ORM simples com base em anotações para aplicar de forma abrangente e aprofundar ainda mais o entendimento e a aplicação de vários pontos de conhecimento das anotações.
Resumir
O exposto acima é sobre os exemplos simples do processador de anotação Java neste artigo, 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!