1. Qu'est-ce que AOP
AOP est l'abréviation de la programmation orientée vers l'aspect, ce qui signifie la programmation orientée vers l'aspect. AOP est en fait une continuation du modèle de conception GoF.
2. Quelques termes sur Spring AOP:
ASPOSTE: Dans Spring AOP, la facette peut être mise en œuvre en utilisant une classe générale ou dans une classe normale avec @aspect Annotation (@aspectj style)
B. JOINPOINT: Dans Spring AOP, un point de connexion représente l'exécution d'une méthode.
C. Conseils: une action effectuée sur un point conjoint spécifique sur la section. Il existe différents types de notifications, y compris "autour", "avant" et "après". De nombreux cadres AOP, y compris le printemps, utilisent les intercepteurs comme modèles de notification et maintiennent une chaîne d'intercepteur centrée sur le point de liaison.
D. Pointcut: définissez une ou un groupe de méthodes, qui peuvent générer des notifications lors de l'exécution de ces méthodes. Spring utilise la syntaxe point-point AspectJ par défaut.
3. Type de notification
A. Pré-notification (@Before): Une notification exécutée avant un point de jointure, mais cette notification ne peut pas empêcher l'exécution avant le point de connexion (sauf si elle lance une exception)
B. Notification après retour (@Afterreturning): la notification exécutée après un point de connexion (point de jointure) est terminée normalement: par exemple, une méthode ne lance aucune exception et revient normalement
C. Notification après l'exception lancée (@afterthrowing): Notification exécutée lorsque la méthode lance l'exception et sort
D. Post Notification (@After): Notification exécutée lorsqu'un point de connexion sort (qu'il s'agisse d'un rendement normal ou d'une sortie anormale)
E. Notification surround (@around): Notifications entourant un point de jointure, telles que les appels de méthode. Il s'agit du type de notification le plus puissant, et les notifications surround peuvent compléter les comportements personnalisés avant et après les appels de méthode. Il choisit également de continuer à exécuter les points de connexion ou à renvoyer directement leur propre valeur de retour ou à lancer une exception pour mettre fin à l'exécution
4. Configuration AOP de style @aspectj
La configuration de Spring AOP a deux styles:
A. Style XML = Implémentez Spring AOP sous forme déclarative
B. style aspectj = implémenter Spring AOP en utilisant le formulaire d'annotation
5. Exemple
Testaspect
package com.spring.aop; / ** * section * / public class testAspect {public void doafter (joinpoint jp) {System.out.println ("Méthode de fin de log:" + jp.getTarget (). GetClass (). GetName () + "." + Jp.getSignature (). GetName ()); } public Object Daround (ProcedingJoinpoint PJP) lève le throwable {long time = System.currentTimeMILLIS (); Objet retval = pjp.proceed (); Time = System.CurrentTimeMillis () - Time; System.out.println ("Temps de processus:" + Time + "MS"); retour retval; } public void dobefore (joinpoint jp) {System.out.println ("Log Begining Method:" + jp.getTarget (). getClass (). getName () + "." + jp.getSignature (). getName ()); } public void dothrowing (joinpoint jp, throwable ex) {System.out.println ("méthode" + jp.getTarget (). getClass (). getName () + "." + jp.getSignature (). getName () + "Throw Exception"); System.out.println (ex.getMessage ()); } private void SendEx (String ex) {// todo envoyer des SMS ou un rappel par e-mail}} package com.spring.service; / ** * Interface A * / interface publique Aservice {public void fooa (String _MSG); public void Bara (); } package com.spring.service; / ** * Implémentation Classe de l'interface A * / classe publique ASERVICEIMPL implémente ASERVICE {public void Bara () {System.out.println ("ASERVICEIMPL.BARA ()"); } public void fooa (string _msg) {System.out.println ("ASERVICEIMPL.fooa (msg:" + _ msg + ")"); }} package com.spring.service; / ** * Classe de service B * / classe publique BServiceIMPl {public void Barb (String _msg, int _type) {System.out.println ("bServiceImpl.Barb (msg:" + _ msg + "type:" + _ type + ")"); if (_Type == 1) lancer un nouveau IllégalArgumentException ("Tester Exception"); } public void foob () {System.out.println ("bServiceImpl.foob ()"); }}ApplicationContext
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/Spring-aop-2.5 ou interfaces dans le package com.spring.service -> <aop: Pointcut id = "busingservice" expression = "EXECUTION (* com.spring.service. *. * (..))" /> <aop: avant Pointcut-ref = "BusinessService" Method = "DoBefore" /> <aop: after Pointcut-ref = "BusinessSensice" Method = "Doafter" PointCut-ref = "BusinessVice" Method = "Doaround" /> <aop: après-lancement PointCut-Ref = "BusinessVice" Method = "DothRowing" /> </ Aop: Aspect> </ Aop: Config> <Bean Id = "AspectBean" /> <Bean Id = "Aservice"> </Ean> </EANTS>
Test Class AOPTest
La classe publique AOPTest étend AbstractDependencyInjectionsPringContextTests {Asive privé Asice Asvice; BServiceImpl privé BService; String protégé [] getConfigLocations () {String [] configs = new String [] {"/ApplicationContext.xml"}; return configs; } / ** * Test Normal Call * / public void testCall () {System.out.println ("Springtest Junit Test"); ASERVICE.FOOA ("Junit Test Fooa"); ASERVICE.BARA (); BService.foob (); BService.barb ("Junit Test Barb", 0); } / ** * Tester après le lancement * / public void testThrow () {try {bService.barb ("Junit Call Barb", 1); } catch (illégalArgumentException e) {}} public void setaService (ASERVICE Service) {ASERVICE = service; } public void setBservice (service BServiceImpl) {bService = service; }}
Les résultats de l'opération sont les suivants:
Méthode de début du journal: com.spring.service.aserviceImpl.fooa asserviceimpl.fooa (msg: junit test fooa) Méthode de fin de journal: com.spring.service.aserviceImpl.fooa Temps de processus: 0 MS Log Méthode de début: com.sprice.service.ServiceImpl com.spring.service.aserviceimpl.bara Temps de processus: 0 ms journal Méthode de début: com.spring.service.bserviceImpl.foob bserviceImpl.foob () Méthode de fin de log: Com.spring.service.bserviceImpl.foob Temps de processus: 0 MS MES Méthode de début: com.sprice. BServiceImpll.Barb (MSG: Test de test JUnit Type: 0) Méthode de fin du journal: com.spring.service.bserviceImpll.Barb Temps de processus: 0 MS Méthode de début du journal: com.spring.service.BServiceImpl.Barb BServiceImpl com.spring.service.bservicempl