As anotações na primavera podem ser divididas aproximadamente em duas categorias:
1) anotações relacionadas a recipientes de feijão da primavera ou fábricas de feijão;
2) Anotações relacionadas ao Springmvc.
As anotações relacionadas ao contêiner de feijão da primavera incluem: @Required, @Autowired, @Postconstruct, @Predestory e as anotações no Javax.inject JSR-330 Javax.Inject.
As anotações relacionadas ao SpringMVC incluem: @Controller, @RequestMapping, @RequestParam, @ResponseBody, etc.
Para entender as anotações na primavera, você deve primeiro entender as anotações em Java.
1. Anotações em Java
As anotações começaram a ser introduzidas no Java 1.5. O que estamos mais familiarizados deve ser: @Override, que é definido da seguinte maneira:
/** * Indica que uma declaração de método deve substituir uma declaração de método * em um supertipo. Se um método for anotado com *, esses compiladores do tipo de anotação serão necessários para gerar uma mensagem de erro *, a menos que pelo menos uma das seguintes condições mantenha: * O método substitui ou implementa um método declarado em um * supertipo. * O método possui uma assinatura que é equivalente à de * qualquer método público declarado em objeto. * * @Author Peter von der Ahé * @Author Joshua Bloch * @JLS 9.6.1.4 @Override * @since 1.5 */ @Target (ElementType.method) @retention (retentionpolicy.source) public @interface {}A partir da anotação, podemos ver que a função do @Override é solicitar ao compilador que o método usado por @Override Anotation deve substituir a classe pai ou um método de mesmo nome em java.lang.object. Vemos que o @Target e o @retention são usados na definição de @Override. Eles são os chamados "meta-anlações"-são as anotações que definem as anotações ou as anotações que anotações (tonturas ...). Vamos dar uma olhada no @retentente
/** * Indica quanto tempo as anotações com o tipo anotado devem * ser retidas. Se nenhuma anotação de retenção estiver presente em uma declaração do tipo de anotação, a política de retenção padrão * retentionpolicy.class. * /@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 ();}O @retention é usado para solicitar quanto tempo a anotação é mantida. Existem três valores:
public Enum RetentionPolicy { /*** As anotações devem ser divulgadas pelo compilador. * / Fonte, / ** * As anotações devem ser gravadas no arquivo de classe pelo compilador *, mas não precisam ser retidas pela VM no tempo de execução. Este é o comportamento padrão *. * / Classe, / ** * As anotações devem ser registradas no arquivo de classe pelo compilador e * retidas pela VM no tempo de execução, para que possam ser lidas reflexivamente. * * @see java.lang.reflect.annotateLement */ RunTime} RetentionPolicy.Source é retido no nível do código -fonte e abandonado pelo compilador (@Override é esse tipo); RetentionPolicy.class é retido no nível de arquivo de classe compilado pelo compilador, mas descartado pela máquina virtual;
RetentionPolicy.Runtime é reservado até o tempo de execução e pode ser lido por reflexão.
Olhe para @target:
pacote java.lang.annotation;/*** Indica os contextos nos quais um tipo de anotação é aplicável. Os contextos * da declaração e os contextos de tipo em que um tipo de anotação pode ser * aplicável são especificados na JLS 9.6.4.1 e indicados no código -fonte por enum * constantes de java.lang.annotation.ElementType * @since 1.5 * @JLS 9.6.4.4.1 @target * @jls 9.7.7.7.7.4.7.4.7.4.4.4. */@Documentado@retention (retentionpolicy.runtime) @target (elementType.annotation_type) public @interface alvo {/** * retorna uma matriz dos tipos de elementos que um tipo de anotação * pode ser aplicado a. * @return Uma matriz dos tipos de elementos Um tipo de anotação * pode ser aplicado a */elementType [] value ();}@Target é usado para solicitar o uso desta anotação, e os valores são:
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 * @since 1.8 */ type_parameter,/ ** * Uso de um tipo * @since 1.8 */ type_use}Indica onde essa anotação pode ser usada separadamente: 1) classe, interface, anotação, enum; 2) o domínio do atributo; 3) método; 4) parâmetros; 5) construtor; 6) variáveis locais; 7) Tipo de anotação; 8) pacote
então:
@Target (elementType.method) @retention (retentionpolicy.source) public @interface substituir {}Isso significa que o @Override só pode ser usado em métodos, retido no nível do código -fonte, processado pelo compilador e depois descartado.
Há também uma meta anotação frequentemente usada @Documented:
/** * Indica que as anotações com um tipo devem ser documentadas pelo Javadoc * e ferramentas semelhantes por padrão. Esse tipo deve ser usado para anotar as * declarações de tipos cujas anotações afetam o uso de elementos anotados * por seus clientes. Se uma declaração de tipo for anotada com * documentada, suas anotações se tornarão parte da API Public * dos elementos anotados. */@Documentado@retention (retentionpolicy.runtime) @target (elementType.annotation_type) public @interface documentado {}Indica se as anotações podem ser processadas pelo JAVADOC e retidas no documento.
2. Personalizar e processar anotações personalizadas com metanotações
Com as meta -anotações, posso usá -lo para personalizar as anotações de que precisamos. Combinar anotações personalizadas e AOP ou filtros é uma arma muito poderosa. Por exemplo, as anotações podem ser usadas para obter controle de granulação fina das permissões - use anotações de permissão em classes ou métodos e interceptá -las em AOP ou filtros. Aqui está uma implementação da anotação sobre permissões de login:
/*** Nenhuma anotação de login necessária*/@Target ({ElementType.Method, ElementType.Type})@Retention(retEntionPolicy.runtime)@documentedPublic @Interface nologin {}Temos anotação personalizada @nologin, que pode ser usada em métodos e classes. A anotação é retida até o tempo de execução e pode ser lida por reflexão. O significado desta anotação é: a classe ou método anotado por @nologin pode ser acessado mesmo que o usuário não esteja conectado. A seguir, é apresentado o processo da anotação:
/** * Check login interceptor* If you do not need to check the login, you can add @NoLogin to the method or controller */public class CheckLoginInterceptor implements HandlerInterceptor {private static final Logger logger = Logger.getLogger(CheckLoginInterceptor.class);@Override public Boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object manipulador) lança exceção {if (! (Instância do manipulador de handlermethod)) {Logger.warn ("O manipulador de operação atual não é handlermethod =" + handler.getclass (). getName () + ", req =" + request.getQuerystring ()); retorno; handlermethod.getMethod (). getName (); // Determine se você precisa verificar o login nologin = handlermethod.getMethod (). getAnnotation (nologin.class); if (null! = nologin) {if (logger.isdebugenabled ()) {Logger.debug ("Operação atual Metodname =" + MethodName + "Não é necessário verificar o login");} retornar true;} nologin = handlermethod.getMethod (). if (null! = nologin) {if (logger.isdebugenabled ()) {Logger.debug ("Operação atual Metodname =" + MethodName + "não precisa verificar o login");} retornar true;} se (null == request.getSession). "Usuário não conectado, ip =" + request.getRemoTeaddr ()); Response.getWriter (). Write (jsonConvertor.ConvertFailResult (ErrorCodeenum.Not_Login) .ToString (); // Mensagem de retorno Retornar; Handler, ModelAndView ModelAndView) lança Exceção {} @Override public void Aftercompletion (solicitação httpServletRequest, resposta httpSertletResponse, manipulador de objeto, exceção ex) lança exceção {}}Acima, definimos um interceptador de login, primeiro usando a reflexão para determinar se o método é anotado por @nologin:
Nologin nologin = handlermethod.getMethod (). GetAnnotation (nologin.class);
Em seguida, determine se a classe é anotada por @nologin:
nologin = handlermethod.getMethod (). getDecLaringClass (). getAnnotation (nologin.class);
Se for anotado, retornará verdadeiro. Se não estiver anotado, é determinado se ele foi conectado. Se não estiver conectado, retornará mensagens de erro ao primeiro plano e falsas. Este é um exemplo simples de usar anotações e filtros para processamento de permissão. Se expandirmos, podemos usar anotações para indicar que um determinado método ou classe só pode ser acessado por usuários com uma determinada função ou permissões e depois julgar no filtro.
3. Anotações relacionadas ao recipiente de feijão de primavera
1) @Autowired é a anotação que mais usamos. De fato, AutoCire = ByType é uma dependência de injeção automática com base no tipo (injeção de dependência baseada em anotação), que pode ser usada no domínio, método e construtor.
2) @Qualifier é AutoCire = ByName. Quando a anotação @Autowired determina que vários tipos de feijão são iguais, você precisa usar @qualifier ("xxbean") para especificar o ID do feijão dependente:
@Controlador @requestmapping ("/user") classe pública hellocontroller {@autowired @qualifier ("userService") privado usuários service service;3) @Resource pertence ao padrão JSR250 e é usado no domínio e nos métodos. É também uma injeção de dependência do tipo Byname. Método de uso: @resource (name = "xxbean"). @Resource sem parâmetros O nome da classe de valor padrão possui minúsculas.
4) anotações no JSR-330 Javax.inject. O @Inject é equivalente a @Autowired, @Named é equivalente a @qualifier, e o @Named também é usado na classe como @component.
5) @Component, @Controller, @Service, @Repository, essas anotações são diferentes das anotações acima. As anotações acima são injetadas no feijão dependente, e a função dessas anotações é produzir feijão. Essas anotações são anotadas na classe, anotando a classe em feijões, um por um na fábrica de feijão da primavera. @Controller, @Service, @Repository é basicamente @Component com uma semântica mais refinada.
6) @PostConstruct e @Predestroy não são usados para injeção de dependência, mas para o ciclo de vida do feijão. Semelhante ao init-method (InitializeingBean) Destory-Method (DisposableBean)
4. Processamento de anotações na primavera
O processamento de anotações na primavera é basicamente feito pela implementação da interface BeanPostProcessor:
interface pública BeanPostProcessor {Objeto PostprocessBeforeinitialization (objeto Bean, String beanname) lança Beansexception; Objeto pós -processamAfterinitialization (objeto Bean, String Beanname) lança Beansexception;}As classes de processamento relacionadas são: AutowiredannotationBeanPostProcessor, CommonannotationBeanPostProcessor, PersistenceanNotationBeanPostProcessor, requerirannOnationBeanPostProcessor
Essas classes de processamento podem ser configuradas implicitamente no recipiente de mola através de <Contexto: anotação-config/>. Tudo isso é processamento de injeção de dependência, bem como o processamento de anotações de feijão de produção (@component, @Controller, @service, @repository):
<Contexto: Componente-Scan Base-Package = "net.aazj.service, net.aazj.aop" />
Isso é feito especificando o caminho do pacote base digitalizado, examinando -os em recipientes de feijão de mola. Observe que o contexto: o componente-scan também configurará o AutowiredAnnotationBeanPostProcessor e o CommonannotationBeanPostProcessor por padrão. Portanto, <Contexto: Anotação-Config/> pode ser omitida. Além disso, contexto: a varredura de componentes também pode digitalizar a anotação de AOP de estilo @aspect, mas é necessário adicionar <aOP: aspectJ-autoProxy/> ao arquivo de configuração para cooperação.
5. A diferença entre as anotações da primavera e as anotações padrão JSR-330:
Resumir
O exposto acima é sobre entender rapidamente as várias anotações na primavera. 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!