Comprendre rapidement diverses annotations au printemps

Les annotations au printemps peuvent être à peu près divisées en deux catégories:

1) Annotations liées aux conteneurs de haricots de printemps ou aux usines de haricots;

2) Annotations liées à SpringMVC.

Les annotations liées au conteneur de bean de Spring incluent: @Required, @Autowired, @postConstruct, @Predestory et les annotations dans le JSR-330 standard javax.inject. * Ce Spring 3.0 a été pris en charge (@Inject, @named, @qualifier, @provider, @scope, @Singleton).

Les annotations liées à SpringMVC incluent: @Controller, @RequestMapping, @RequestParam, @ResponseBody, etc.

Pour comprendre les annotations au printemps, vous devez d'abord comprendre les annotations en Java.

1. Annotations en java

Les annotations ont commencé à être introduites dans Java 1.5. Celui que nous connaissons le plus devrait être: @Override, qui est défini comme suit:

 / ** * Indique qu'une déclaration de méthode est destinée à remplacer une déclaration de méthode * dans un supertype. Si une méthode est annotée avec * Ces compilateurs de type annotation sont tenus de générer un message d'erreur * à moins que l'une des conditions suivantes ne maintient: * La méthode remplace ou implémente une méthode déclarée dans un * supertype. * La méthode a une signature qui remplace l'équivalent à celle de * toute méthode publique déclarée dans l'objet. * * @author Peter von der aahé * @author Joshua Bloch * @Jls 9.6.1.4 @Override * @Since 1.5 * / @ Target (elementType.Method) @retention (RetentionPolicy.Source) public @Interface Override {}

De l'annotation, nous pouvons voir que la fonction de @Override est d'inviter le compilateur que la méthode utilisée par @Override Annotation doit remplacer la classe parent ou une méthode du même nom dans java.lang.object. Nous voyons que @Target et @retention sont utilisés dans la définition de @Override. Ce sont les soi-disant «méta-annotations» - ce sont les annotations qui définissent les annotations, ou les annotations que les annotations (étourdi ...). Jetons un coup d'œil à @retention

 / ** * Indique la durée des annotations avec le type annoté à conserver. Si aucune annotation de rétention n'est présente sur * une déclaration de type annotation, la politique de rétention par défaut est * retentepolicy.class. * / @ Documenté @ rétention (retenderPolicy.runtime) @target (elementType.annotation_type) public @Interface Rétention {/ ** * Renvoie la politique de rétention. * @return la politique de rétention * / RétentionPolicy Value ();}

@Retention est utilisé pour inviter la durée de la conservation de l'annotation. Il y a trois valeurs:

 Public Enum RetentionPolicy {/ ** * Les annotations doivent être divulguées par le compilateur. * / Source, / ** * Les annotations doivent être enregistrées dans le fichier de classe par le compilateur * mais n'ont pas besoin d'être conservées par la machine virtuelle au moment de l'exécution. Ceci est le comportement par défaut *. * / Classe, / ** * Les annotations doivent être enregistrées dans le fichier de classe par le compilateur et * conservé par la machine virtuelle au moment de l'exécution, afin qu'elles puissent être lues de manière réfléchie. * * @see java.lang.reflect.annoteatedElement * / runtime}

RetenderPolicy.source est conservé au niveau du code source et abandonné par le compilateur (@Override est ce type); RetenderPolicy.class est conservé au niveau du fichier de classe compilé par le compilateur, mais jeté par la machine virtuelle;

RetentionPolicy.runtime est réservé jusqu'à l'exécution et peut être lu par réflexion.

Regardez @Target:

 package java.lang.annotation; / ** * indique les contextes dans lesquels un type d'annotation est applicable. Les * contextes de déclaration et contextes de type dans lesquels un type d'annotation peuvent être * applicables sont spécifiés dans JLS 9.6.4.1, et indiquées dans le code source par enum * Constantes de Java.lang.annotation.ElementType * @Since 1.5 * @jls 9.6.4.1 @target * @jls 9.7.4 lorsque les annotations peuvent apparaître les annotations peut apparaître par * / @ Documenté @ retenue (retentionPolicy.runtime) @target (elementType.annotation_type) public @Interface Target {/ ** * Renvoie un tableau des types d'éléments auquel un type d'annotation * peut être appliqué. * @return un tableau des types d'éléments Un type d'annotation * peut être appliqué à * / elementType [] value ();}

@Target est utilisé pour inviter l'utilisation de cette annotation, et les valeurs sont:

 Classe publique ENUM ElementType {/ **, interface (y compris le type d'annotation), ou Déclaration d'énumération * / Type, / ** Déclaration de champ (inclut les constantes enum) * / champ, / ** Déclaration de méthode * / Méthode, / ** Déclaration de paramètre formel * / Paramètre, / ** Déclaration de constructeur * / Constructeur, / * Déclaration variable locale * * / Annotation_type, / ** Déclaration de package * / package, / ** * Declaration de paramètres de type * @Since 1.8 * / type_parameter, / ** * Utilisation d'un type * @Since 1.8 * / type_use}

Indique où cette annotation peut être utilisée séparément: 1) classe, interface, annotation, énumération; 2) Domaine d'attribut; 3) Méthode; 4) Paramètres; 5) constructeur; 6) variables locales; 7) Type d'annotation; 8) emballage

donc:

 @Target (elementType.Method) @retention (retenderPolicy.source) public @Interface Override {}

Cela signifie que @Override ne peut être utilisé que sur des méthodes, conservés au niveau du code source, traités par le compilateur, puis jetés.

Il existe également une méta-annotation fréquemment utilisée @Documented:

 / ** * Indique que les annotations avec un type doivent être documentées par Javadoc * et des outils similaires par défaut. Ce type doit être utilisé pour annoter les * déclarations de types dont les annotations affectent l'utilisation d'éléments annotés * par leurs clients. Si une déclaration de type est annotée avec * documentée, ses annotations font partie de l'API publique * des éléments annotés. Notre

Indique si les annotations peuvent être traitées par Javadoc et conservées dans le document.

2. Personnaliser et traiter les annotations personnalisées avec des méta-annotations

Avec des méta-annotations, je peux l'utiliser pour personnaliser les annotations dont nous avons besoin. Combiner des annotations personnalisées et AOP ou filtres est une arme très puissante. Par exemple, les annotations peuvent être utilisées pour obtenir un contrôle à grain fin des autorisations - utilisez des annotations d'autorisation sur les classes ou les méthodes, puis les intercepter dans AOP ou filtres. Voici une mise en œuvre de l'annotation sur les autorisations de connexion:

 / ** * Aucune annotation de connexion requise * / @ Target ({elementType.Method, elementType.type}) @ rétention(retentionpolicy.runtime)@documendedpublic @interface nologin {}

Nous avons une annotation personnalisée @nologin, qui peut être utilisée sur les méthodes et les classes. L'annotation est conservée jusqu'à l'exécution et peut être lue par réflexion. La signification de cette annotation est: la classe ou la méthode annotée par @nologin est accessible même si l'utilisateur n'est pas connecté. Ce qui suit est le processus de l'annotation:

 / ** * Vérifiez l'intercepteur de connexion * Si vous n'avez pas besoin de vérifier la connexion, vous pouvez ajouter @nologin à la méthode ou contrôleur * / classe publique CheckLoginInterceptor implémente HandlerInterceptor {private static final logger = logger.getLogger (CheckLoginInterceptor.class); @ override boolean réponse (httppservleter Handler) lève une exception {if (! (Handler instanceof handLerMethod)) {logger.warn ("Le gestionnaire d'opération actuel n'est pas handlerMoD =" + handler.getClass (). getName () + ", req =" + request.getQuerystring ()); return true;} handlerMethod HandlerMoD = (handLerMethod) Handler; handlerMethod.getMethod (). getName (); // déterminer si vous devez vérifier la connexion Nologin = handlerMethod.getMethod (). getAnnotation (nologin.class); if (null! = nologin) {if (logger.isdebugeNabled ()) {logger.debug ("opération actuelle méthodename =" + méthodyname + "pas besoin de vérifier la connexion");} return true;} nologin = handLerMethod.getMethod (). if (null! = nologin) {if (logger.isdebugeNabled ()) {logger.debug ("opération actuelle methodname =" + méthodyname + "pas besoin de vérifier la connexion");} return true;} if (null == request.getSession (). getTraut ("CommonConstants. "L'utilisateur n'est pas connecté, ip =" + request.getRemoteadDr ()); réponse.getwriter (). Write (jsonConvert.ConvertFailResult (retour errorCodeenum.not_login) .toString ()); // return Message de retour false;} return true;} @ override public Posthandle Posthandle, httppservlate Handler, ModelandView ModelAndView) lève l'exception {} @Override public void aftercompletion (httpsservletRequest request, httpservletResponse réponse, objet handler, exception ex) lève une exception {}}

Ci-dessus, nous définissons un intercepteur de connexion, en utilisant d'abord la réflexion pour déterminer si la méthode est annotée par @nologin:

Nologin Nologin = handlerMethod.getMethod (). GetAnnotation (nologin.class);
Déterminez ensuite si la classe est annotée par @nologin:

nologin = handlerMethod.getMethod (). getDeclaringClass (). getAnnotation (nologin.class);
S'il est annoté, il renvoie vrai. S'il n'est pas annoté, il est déterminé s'il a été connecté. S'il n'est pas connecté, il renvoie les messages d'erreur au premier plan et faux. Il s'agit d'un exemple simple d'utilisation d'annotations et de filtres pour le traitement de l'autorisation. Si nous nous détendons, nous pouvons utiliser des annotations pour indiquer qu'une certaine méthode ou classe ne peut être accessible que par les utilisateurs avec un certain rôle ou des autorisations, puis juger dans le filtre.

3. Annotations liées au conteneur de haricots de printemps

1) @Autowired est l'annotation que nous utilisons le plus. En fait, Autowire = ByType est une dépendance d'injection automatique basée sur le type (injection de dépendance basée sur l'annotation), qui peut être utilisée dans le domaine, la méthode et le constructeur.

2) @qualifier est autowire = byname. Lorsque l'annotation @Autowired détermine que plusieurs types de haricots sont les mêmes, vous devez utiliser @qualifier ("xxbean") pour spécifier l'ID du haricot dépendant:

 @ Contrôleur @ requestmapping ("/ user") classe publique HelloController {@Autowired @Qualifier ("UserService") Private UserService UserService;

3) @Resource appartient à la norme JSR250 et est utilisé dans le domaine et les méthodes. Il s'agit également d'une injection de dépendance du type de nom. Méthode d'utilisation: @Resource (name = "xxbean"). @Resource Sans paramètres Le nom de classe de valeur par défaut a des minuscules.

4) Annotations dans JSR-330 Standard Javax.inject. * (@Inject, @Named, @qualifier, @Provider, @Scope, @Singleton). @Inject est équivalent à @Autowired, @Named est équivalent à @qualifier et @Named est également utilisé dans la classe en tant que @Component.

5) @Component, @Controller, @Service, @Repository, ces annotations sont différentes des annotations ci-dessus. Les annotations ci-dessus sont injectées dans les haricots dépendants, et la fonction de ces annotations est de produire des haricots. Ces annotations sont annotées sur la classe, annotant la classe en haricots un par un dans l'usine de haricots de printemps. @Controller, @Service, @Repository est essentiellement @component avec une sémantique plus raffinée.

6) @postConstruct et @predestroy ne sont pas utilisés pour l'injection de dépendance, mais pour le cycle de vie du haricot. Semblable à la méthode init-méthode (initialingbean) destory (DisposableBean)

4. Traitement des annotations au printemps

Le traitement des annotations au printemps se fait essentiellement en mettant en œuvre l'interface BeanPostProcessor:

 Interface publique BeanPostProcessor {objet postprocessBeforeInitialization (objet Bean, String Beanname) lève BeanSexception; Objet postprocessafterinitialisation (objet Bean, String Beanname) lance BeanSexception;}

Les cours de traitement connexes sont: AutowiredannotationBeanPostProcessor, CommonannotationBeanPostprocessor, PersistenceAnNotationBeanPostprocessor, Obligation requise

Ces classes de traitement peuvent être implicitement configurées dans le conteneur de ressort via <context: annotation-config />. Ce sont tous le traitement de l'injection de dépendance, ainsi que le traitement des annotations de bean de production (@Component, @Controller, @Service, @Repository):

<Context: Component-Scan Base-Package = "net.aazj.service, net.aazj.aop" />

Ceux-ci se font en spécifiant le chemin de paquet de base numérisé, en les balayant dans des conteneurs de haricots à ressort. Notez que le contexte: Component-Scan configurera également AutowirenannotationBeanPostProcessor et CommonannotationBeanPostProcessor par défaut. Par conséquent, <Context: Annotation-Config /> peut être omis. De plus, le contexte: Composant-Scan peut également scanner l'annotation AOP de style @aspect, mais il est nécessaire d'ajouter <aop: aspectj-autoproxy /> au fichier de configuration pour la coopération.

5. La différence entre les annotations de printemps et les annotations standard JSR-330:

Résumer

Ce qui précède consiste à comprendre rapidement les différentes annotations au printemps. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!