1: Introdução às anotações Java
As anotações são frequentemente usadas no desenvolvimento, e ocasionalmente vejo anotações personalizadas em projetos. Hoje, vamos discutir qual é a anotação, bem como os cenários de aplicação da anotação e como personalizar a anotação.
Os seguintes listas seguintes anotações em desenvolvimento
@Override: usado para identificar que o método herda da superclasse. Quando o método da classe pai for excluído ou modificado, o compilador solicitará uma mensagem de erro (você sempre pode ver isso no método ToString () que vemos com mais frequência)
@Deprecated: Isso significa que esta classe ou método está descontinuado e expirou. Se o usuário ainda quiser usá -lo, um aviso de compilação será gerado.
@Suppresswarnings: mensagem de aviso do compilador para ignorar
Teste Junit: @Test
Algumas anotações da primavera: @Controller, @RequestMapping, @RequestParam, @ResponseBody, @service, @Component, @repository, @Resource, @Autowire
Anotações para Java Verificação: @NotNull, @Email
Vamos dar uma olhada na face verdadeira do Monte Lu na anulação substituta.java
@Target (elementType.method) @retention (retentionpolicy.source) public @interface substituir {} 2: Conhecimento básico da anotação Java
1. Tipo de dados de anotação Java
As anotações são escritas em arquivos .java e use @Interface como palavra -chave, portanto, as anotações também são um tipo de dados de Java. De uma definição ampla, classe, interface, enum e anotação são todos os tipos de classe.
2. Anotação de meta java
Ao criar anotações, você precisa usar algumas anotações para descrever as anotações que você criou, ou seja, as anotações escritas no @Interface. Essas anotações são chamadas de meta anotações, como @target, @retention, etc. vistas em substituição. Aqui estão algumas meta -anotações
@Documented: Usado para marcar se a anotação está incluída ao gerar Javadoc. Você pode ver que essa anotação é a mesma que @Override, a anotação está vazia e não há nada.
@Documentado@retention (retentionpolicy.runtime) @target (elementType.annotation_type) public @interface documentado {}@Target: usado para definir onde as anotações podem ser usadas. Por padrão, ele pode ser usado em qualquer lugar ou pode especificar o escopo do uso. No desenvolvimento, é mais comum o uso de anotações nas classes (como @Controller), campos (como @Autowire), métodos (como @RequestMapping), parâmetros de métodos (como @RequestParam), etc.
Tipo: classe, interface ou declaração de enum
Campo: Declaração de Domínio (Atributo)
Método: Declaração do Método
Parâmetro: Declaração do parâmetro
Construtor: Declaração do Método Construtor
Local_variable: Declaração de variável local
Anotação_type: Declaração do tipo de comentário
Pacote: declaração do pacote
Target.java
@Documentado@retention (retentionpolicy.runtime) @target (elementType.annotation_type) public @Interface Target { /** * retorna uma matriz dos tipos de elementos a que um tipo de anotação * pode ser aplicado. * @return Uma matriz dos tipos de elementos Um tipo de anotação * pode ser aplicado a */ elementType [] value ();} public enum elementType { /** classe, interface (incluindo tipo de anotação) ou declaração de enum* /type, /** Declaração de campo (inclui constantes enum)* /campo, /** Declaração do método /método /método, /** Declaração de parâmetro formal* /parâmetro /** Construtor Declaration* /Construtor, /* Declaração*/ ANNOTATION_TYPE,/ ** Declaração do pacote*/ pacote,/ ** Declaração de parâmetro do tipo*/ type_parameter,/ ** Uso de um tipo*/ type_use}@InHerited: permite que as subclasses herdem as anotações na classe pai e possam obter as anotações da classe pai por meio de reflexão.
@Documentado@retention (retentionpolicy.runtime) @target (elementType.annotation_type) public @interface herded {}@Constraint: usado para verificar se o valor do atributo é legal
@Documentado@target ({elementType.annotation_type})@retention (retentionpolicy.runtime) public @interface restrind {class <? estende o restrintValidator <?,? >> [] validado ();}@Retention: O ciclo da declaração de anotação é usado para definir o estágio de sobrevivência da anotação. Ele pode sobreviver no nível do código -fonte, nível de compilação (nível de código de bytes) e nível de tempo de execução.
Fonte: Nível de código -fonte, as anotações estão presentes apenas no código -fonte e geralmente são usadas para interagir com o compilador e são usadas para detectar código. Como @Override, @suppresswarings.
Classe: Nível de ByteCode, existem anotações no código -fonte e arquivos BYTECODE. Eles são usados principalmente para gerar arquivos adicionais durante a compilação, como XML, arquivos Java etc., mas não podem ser obtidos durante o tempo de execução. Por exemplo, o mybatis gera arquivos de entidade e mapeamento. Nesse nível, é necessário adicionar um proxy (javaagent) quando a JVM é carregada e usar um proxy para modificar dinamicamente o arquivo bytecode.
Tempo de execução: nível de execução, existem anotações no código -fonte, bytecode e java virtual máquinas. Eles são usados principalmente para tempo de execução e a reflexão pode ser usada para obter informações relevantes.
@Documentado@retention (retentionpolicy.runtime) @target (elementType.annotation_type) public @Interface Retention { /*** retorna a política de retenção. * @RETURN A POLÍTICA DE RETENÇÃO */ RetentionPolicy Value ();} 3. Conteúdo das anotações Java
No código -fonte da anotação acima, você pode ver que algumas anotações não têm conteúdo e algumas anotações têm conteúdo, o que parece ser um método.
Formato de sintaxe do conteúdo anotado: Nome do atributo de tipo de dados () Valor padrão padrão, o tipo de dados é usado para descrever o tipo de dados do atributo. O valor padrão significa que, quando nenhum atributo é atribuído, o valor padrão é usado. Geralmente, a String usa uma string vazia "" como o valor padrão e as matrizes geralmente usam uma matriz vazia {} como o valor padrão.
Vamos dar uma olhada na declaração da anotação do RequestMapping no Springmvc
@Target ({elementType.method, elementType.type})@retention (retentionpolicy.runtime)@documentado@mappingpublic @interface requestmapping {string name () padrão ""; @Aliasfor ("path") string [] value () padrão {}; @Aliasfor ("value") string [] path () padrão {}; RequestMethod [] método () padrão {}; String [] params () padrão {}; String [] headers () padrão {}; String [] consumers () padrão {}; String [] produz () padrão {};}Usando a anotação requestmapping no springmvc
@RequestMapping (Value = "/List", Method = RequestMethod.Post, Produces = {"Application/JSON; Charset = utf-8;"}) public string list () {} 4. Use cenários de anotações
Você pode analisar os cenários de uso das anotações durante o período de declaração das anotações:
Nível de código -fonte da fonte: Para compiladores, como @Override, @Deprecated, etc., não há muitos cenários que os desenvolvedores devem usar.
Classe: ByteCode Nível, esta parte raramente é vista
Tempo de execução: o nível de tempo de execução, este é o mais comum e quase todas as anotações usadas pelos desenvolvedores são o nível de tempo de execução. As anotações de tempo de execução são comumente usadas nas seguintes situações
Anotação sem nenhum atributo na anotação. Esta parte da anotação geralmente desempenha um papel de anotação, como @Test, @Before, @after. Ao obter essas anotações de tags, é feito algum processamento lógico.
Você pode usar a anotação de restrição @Constraint para verificar o valor do atributo, como @email, @NotNull, etc.
Você pode configurar alguns parâmetros usando propriedades na anotação e, em seguida, pode usar a reflexão para obter esses parâmetros. Essas anotações não têm outras funções especiais, elas simplesmente configuram alguns parâmetros em vez da configuração XML. Usando anotações para configurar parâmetros, isso é popular na bota da primavera, como @configuration
Em relação ao método de configuração XML vs anotação, geralmente use o XML para configurar algumas configurações que não estão muito próximas do relacionamento comercial e use anotações para configurar alguns parâmetros que estão intimamente relacionados aos negócios.
Três: Anotação e reflexão Java API básico
// Obtenha anotação de um determinado tipo público <a estende anotação> uma getAnnotation (classe <a> AnoTationClass); // Obtenha todas as anotações (incluindo as anotações modificadas por herdadas na classe pai) Annotação pública [] getAnnotações (); // Get the annotations declared (but does not include the annotations modified by Inherited in the parent class) public Annotation[] getDeclaredAnnotations();// Test whether an object is annotated by an annotation public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)// Get all fields declared by a certain class public Field[] getDeclaredFields() throws SecurityException; // Obtenha um determinado método do método público getMethod (nome da string, classe <?> ... parameterTypes);
Quatro: anotações personalizadas
Use anotações personalizadas + interceptores ou AOPs para controlar as permissões.
O exemplo a seguir é usado para definir uma anotação para restringir o usuário deve fazer login ao acessar uma interface.
Etapa 1: Defina a anotação
Requerlogin.java
@Documentado@target ({elementType.method})@retention (retentionpolicy.runtime) public @interface requerSlogin {}Etapa 2: Use anotações
@Controlador @requestmapping ("/user") public class UserController {@ReQuiresLogin @RequestMapping (value = "/list", produz = {"Application/json; charset = utf-8;"}) public string getUserlist () {System.out.println ("-----------------------In) retornar "[{'id': 1, 'nome de usuário': 'zhangsan'}]"; }}Etapa 3: Use AOP para interceptar e analisar as anotações
classe pública Loginadvices {public void antes (juntpointintpoint) lança exceção {objeto alvo = junção.getTarget (); String MethodName = junçãoPoint.getSignature (). GetName (); System.out.println (Target + "-------" + MethodName); Método Método = Target.getClass (). GetMethod (MethodName); anotação booleana (method.isannotationPresent (requerSlogin.class); if (anotaçãopresent) {// o usuário deve fazer login no boolean islogin = false; if (! islogin) {lança nova exceção ("você deve fazer login para acessar esta interface"); } else {System.out.println ("Login ..."); }}}}Configurar AOP em ApplicationContext.xml
<bean id = "loginadvices"/> <!-AOP Configuration-> <AOP: Config proxy-target-class = "true"> <!-seção-> <aOp: aspecto ref = "loginadvices"> <!-Point-> <AOP: Pointcut id = "Pointcut1" Expression = "ExecutionD (*com.meng.meng (*com.meng.meng (*. <!-Connect Notification Method and Point-> <AOP: Antes Method = "Antes" Pointcut-ref = "Pointcut1"/> </AOP: Aspect> </AOP: Config>
Exceções personalizadas
Por que personalizar exceções
Embora o Java ofereça uma rica variedade de aulas de manuseio de exceção, exceções personalizadas são frequentemente usadas em projetos. O principal motivo é que as classes de exceção fornecidas pelo Java ainda não podem atender às necessidades de várias empresas em alguns casos. Por exemplo, alguns erros no sistema cumprem a sintaxe Java, mas não cumprem a lógica de negócios. Se a conta não existir quando o usuário efetuar login ou a conta estiver bloqueada, você poderá personalizar uma conta da conta da conta da conta.
Ou, em alguns casos, a mesma exceção em Java pode ser causada por vários motivos. Não é fácil localizar erros ao solucionar problemas. Neste momento, você pode usar a personalização de uma exceção mais clara.
Benefícios das exceções personalizadas: Exceções personalizadas podem tornar as exceções mais claras e ocultar exceções subjacentes, o que é mais seguro e intuitivo.
Uso de exceções personalizadas: as exceções personalizadas são geralmente herdadas da exceção ou do tempo de execução da USCECCECTION. De acordo com as necessidades dos negócios, alguns atributos podem ser tomados como parâmetros do construtor. Exceções personalizadas exigem que os programadores joguem manualmente exceções e lidem com exceções.
Abaixo está um exemplo de exceções personalizadas em Apache Shiro
classe pública ShiroException estende a RUNTimeException {public ShiroException () {} public ShiroException (string message) {super (message); } public ShiroException (causa de arremesso) {super (causa); } public ShiroException (mensagem da string, causa de arremesso) {super (mensagem, causa); }}O exposto acima é uma descrição detalhada da anotação Java e anotações personalizadas