Spring详细内容-Spring AOP En（4）

喜欢ヅ旅行 2023-09-24 19:11 223阅读 0赞

1.Spring AOP

  • Aspect Oriented Programming (AOP) compliments OOPs in the sense that it also provides modularity.
  • But the key unit of modularity is aspect than class.
  • AOP breaks the program logic into distinct parts (called concerns).
  • It is used to increase modularity by cross-cutting concerns.
  • A cross-cutting concern is a concern that can affect the whole application and should be centralized in one location in code as possible, such as transaction management, authentication, logging, security etc.

1)Why use AOP?

  • It provides the pluggable way to dynamically add the additional concern before, after or around the actual logic.

2)Where use AOP?

  • AOP is mostly used in following cases:

    • to provide declarative enterprise services such as declarative transaction management.
    • It allows users to implement custom aspects.

3)AOP Concepts and Terminology

  • Join point

    • Join point is any point in your program such as method execution, exception handling, field access etc.
    • Spring supports only method execution join point.

  • Advice

    • Before Advice: it executes before a join point.
    • After Returning Advice: it executes after a joint point completes normally.
    • After Throwing Advice: it executes if method exits by throwing an exception.
    • After (finally) Advice: it executes after a join point regardless of join point exit whether normally or exceptional return.
    • Around Advice: It executes before and after a join point.

  • Pointcut

    • It is an expression language of AOP that matches join points.

  • Introduction

    • It is an expression language of AOP that matches join points.

  • Target Object

    • It is the object i.e. being advised by one or more aspects.
    • It is also known as proxied object in spring because Spring AOP is implemented using runtime proxies.

  • Aspect

    • It is a class that contains advices, joinpoints etc.

  • Interceptor

    • It is an aspect that contains only one advice.

  • AOP Proxy

    • It is used to implement aspect contracts, created by AOP framework.
    • It will be a JDK dynamic proxy or CGLIB proxy in spring framework.

  • Weaving

    • It is the process of linking aspect with other application types or objects to create an advised object.
    • Weaving can be done at compile time, load time or runtime. Spring AOP performs weaving at runtime.

4)AOP Implementations

  • AspectJ
  • Spring AOP
  • JBoss AOP

5) 3 ways to use spring AOP

  • By Spring1.2 Old style (dtd based) (also supported in Spring3)
  • By AspectJ annotation-style
  • By Spring XML configuration-style(schema based)

2.By Spring1.2 Old style (dtd based) (also supported in Spring3)

There are 4 types of advices supported in spring1.2 old style aop implementation.

  • Before Advice it is executed before the actual method call.
  • After Advice it is executed after the actual method call. If method - returns a value, it is executed after returning value.
  • Around Advice it is executed before and after the actual method call.
  • throws Advice it is executed if actual method throws exception.

Understanding the hierarchy of advice interfaces

在这里插入图片描述
MethodBeforeAdvice interface extends the BeforeAdvice interface.

AfterReturningAdvice interface extends the AfterAdvice interface.

ThrowsAdvice interface extends the AfterAdvice interface.

MethodInterceptor interface extends the Interceptor interface. It is used in around advice.

1)Before Advice

  1. public class A{
  3.     public  void m(){
  4.     System.out.println("actual business logic");}
  5. }
  7. public class BeforeAdvisor implements MethodBeforeAdvice {
  9.     @Override
  10.     public void before(Method method, Object[] args, Object target) throws Throwable {
  12.         System.out.println("additional concern before actual logic");
  13.     }
  14. }
  16. <?xml version="1.0" encoding="UTF-8"?>
  17. <beans
  18.         xmlns="http://www.springframework.org/schema/beans"
  19.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  20.         xmlns:p="http://www.springframework.org/schema/p"
  21.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  22. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  24.     <bean id="a" class="com.amy.A"></bean>
  25.     <bean id="before" class="com.amy.BeforeAdvisor"></bean>
  27.     <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  28.         <property name="target" ref="a"></property>
  29.         <property name="interceptorNames">
  30.             <list>
  31.                 <value>before</value>
  32.             </list>
  33.         </property>
  34.     </bean>
  36. </beans>
  38. public class Test {
  40.     public static void main(String[] args) {
  42.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  43.         A a=  context.getBean("proxy",A.class);
  44.         a.m();
  45.     }
  46. }
  48. additional concern before actual logic
  49. actual business logic

Understanding ProxyFactoryBean class:

  • The ProxyFactoryBean class is provided by Spring Famework. It contains 2 properties target and interceptorNames.
  • The instance of A class will be considered astarget objectand the instance of advisor class as interceptor.

  • You need to pass the advisor object as the list object as in the xml file given above.





    before

    public class ProxyFactoryBean{

    1. private Object target;  
    2. private List interceptorNames;  
    3. //getters and setters

    }

Printing additional information in MethodBeforeAdvice

  1. public class A{
  3.     public  void m(){
  4.     System.out.println("actual business logic");}
  5. }
  7. <?xml version="1.0" encoding="UTF-8"?>
  8. <beans
  9.         xmlns="http://www.springframework.org/schema/beans"
  10.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  11.         xmlns:p="http://www.springframework.org/schema/p"
  12.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  13. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  15.     <bean id="a" class="com.amy.A"></bean>
  16.     <bean id="before" class="com.amy.BeforeAdvisor"></bean>
  18.     <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  19.         <property name="target" ref="a"></property>
  20.         <property name="interceptorNames">
  21.             <list>
  22.                 <value>before</value>
  23.             </list>
  24.         </property>
  25.     </bean>
  27. </beans>
  29. public class BeforeAdvisor implements MethodBeforeAdvice {
  31.     @Override
  32.     public void before(Method method, Object[] args, Object target) throws Throwable {
  34.         System.out.println("additional concern before actual logic");
  35.         System.out.println("method info:" +"  method.getName() is "+ method.getName() + " method.getModifiers() is " + method.getModifiers());
  36.         System.out.println("argument info:");
  38.         for (Object arg : args) {
  40.             System.out.println("arg: "+ arg);
  41.         }
  42.         System.out.println("target Object:" + target);
  43.         System.out.println("target object class name: " + target.getClass().getName());
  44.     }
  45. }
  47. public class Test {
  49.     public static void main(String[] args) {
  51.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  52.         A a=  context.getBean("proxy",A.class);
  53.         System.out.println("proxy class name: "+a.getClass().getName());
  54.         a.m();
  55.     }
  56. }
  58. proxy class name: com.amy.A$$EnhancerBySpringCGLIB$$46ca4f4d
  59. additional concern before actual logic
  60. method info:  method.getName() is m method.getModifiers() is 1
  61. argument info:
  62. target Object:com.amy.A@6a396c1e
  63. target object class name: com.amy.A
  64. actual business logic

2)After Advice

  1. public class A{
  3.     public  void m(){
  4.     System.out.println("actual business logic");}
  5. }
  7. public class AfterAdvisor implements AfterReturningAdvice {
  10.     @Override
  11.     public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
  13.         System.out.println("additional concern after returning advice");
  14.     }
  15. }
  17. <?xml version="1.0" encoding="UTF-8"?>
  18. <beans
  19.         xmlns="http://www.springframework.org/schema/beans"
  20.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  21.         xmlns:p="http://www.springframework.org/schema/p"
  22.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  23. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  25.     <bean id="a" class="com.amy.A"></bean>
  26.     <bean id="after" class="com.amy.AfterAdvisor"></bean>
  28.     <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  29.         <property name="target" ref="a"></property>
  30.         <property name="interceptorNames">
  31.             <list>
  32.                 <value>after</value>
  33.             </list>
  34.         </property>
  35.     </bean>
  37. </beans>
  39. public class Test {
  41.     public static void main(String[] args) {
  43.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  44.         A a=  context.getBean("proxy",A.class);
  45.         a.m();
  46.     }
  47. }
  49. actual business logic
  50. additional concern after returning advice

3)Around Advice

  1. public class A{
  3.     public  void m(){
  4.     System.out.println("actual business logic");}
  5. }
  7. public class AroundAdvisor implements MethodInterceptor {
  9.     @Override
  10.     public Object invoke(MethodInvocation invocation) throws Throwable {
  12.         Object object;
  13.         System.out.println("additional concern before actual logic");
  14.         object=invocation.proceed();
  15.         System.out.println("additional concern after actual logic");
  16.         return object;
  17.     }
  18. }
  20. <?xml version="1.0" encoding="UTF-8"?>
  21. <beans
  22.         xmlns="http://www.springframework.org/schema/beans"
  23.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  24.         xmlns:p="http://www.springframework.org/schema/p"
  25.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  26. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  28.     <bean id="a" class="com.amy.A"></bean>
  29. <!--    <bean id="before" class="com.amy.BeforeAdvisor"></bean>-->
  30. <!--    <bean id="after" class="com.amy.AfterAdvisor"></bean>-->
  31.     <bean id="around" class="com.amy.AroundAdvisor"></bean>
  33.     <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  34.         <property name="target" ref="a"></property>
  35.         <property name="interceptorNames">
  36.             <list>
  37.                 <value>around</value>
  38.             </list>
  39.         </property>
  40.     </bean>
  42. </beans>
  44. public class Test {
  46.     public static void main(String[] args) {
  48.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  49.         A a=  context.getBean("proxy",A.class);
  50.         a.m();
  51.     }
  52. }
  54. additional concern before actual logic
  55. actual business logic
  56. additional concern after actual logic

4)Throws Advice

  1. public class Validator {
  3.     public void  Validate(int age) throws ArithmeticException {
  5.         if(age<18){
  7.             throw new ArithmeticException("No Valid Age");
  8.         }else{
  10.             System.out.println("vote confirmed");
  11.         }
  12.     }
  13. }
  15. public class ThrowsAdvisor implements ThrowsAdvice {
  17.     public void afterThrowing(Exception ex){
  19.         System.out.println("additional concern if exception occurs");
  21.     }
  22. }
  24. <?xml version="1.0" encoding="UTF-8"?>
  25. <beans
  26.         xmlns="http://www.springframework.org/schema/beans"
  27.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  28.         xmlns:p="http://www.springframework.org/schema/p"
  29.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  30. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  32.     <bean id="v" class="com.amy.Validator"></bean>
  33. <!--    <bean id="before" class="com.amy.BeforeAdvisor"></bean>-->
  34. <!--    <bean id="after" class="com.amy.AfterAdvisor"></bean>-->
  35. <!--    <bean id="around" class="com.amy.AroundAdvisor"></bean>-->
  36.     <bean id="throw" class="com.amy.ThrowsAdvisor"></bean>
  38.     <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  39.         <property name="target" ref="v"></property>
  40.         <property name="interceptorNames">
  41.             <list>
  42.                 <value>throw</value>
  43.             </list>
  44.         </property>
  45.     </bean>
  47. </beans>
  49. public class Test {
  51.     public static void main(String[] args) {
  53.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  54.         Validator v=  context.getBean("proxy",Validator.class);
  55.         try{
  57.             v.Validate(12);
  58.         }catch (Exception e){
  60.             e.printStackTrace();
  61.         }
  62.     }
  63. }
  65. additional concern if exception occurs
  66. java.lang.ArithmeticException: No Valid Age
  67.     at com.amy.Validator.Validate(Validator.java:10)
  68.     at com.amy.Validator$$FastClassBySpringCGLIB$$f91662a4.invoke(<generated>)
  69.     at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
  70.     at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:793)
  71.     at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
  72.     at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:763)
  73.     at org.springframework.aop.framework.adapter.ThrowsAdviceInterceptor.invoke(ThrowsAdviceInterceptor.java:113)
  74.     at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
  75.     at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:763)
  76.     at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:708)
  77.     at com.amy.Validator$$EnhancerBySpringCGLIB$$629ab8c0.Validate(<generated>)
  78.     at com.amy.Test.main(Test.java:21)
  80. Process finished with exit code 0

3.Spring AOP AspectJ Annotation

  • The Spring Framework recommends you to use Spring AspectJ AOP implementation over the Spring 1.2 old style dtd based AOP implementation because it provides you more control and it is easy to use.

  • There are two ways to use Spring AOP AspectJ implementation:

    • By annotation: We are going to learn it here.
    • By xml configuration (schema based): We will learn it in next page.

1)By annotation

  • Spring AspectJ AOP implementation provides many annotations:

    @Aspect declares the class as aspect.
    @Pointcut declares the pointcut expression.

  • The annotations used to create advices are given below:

    @Before declares the before advice. It is applied before calling the actual method.
    @After declares the after advice. It is applied after calling the actual method and before returning result.
    @AfterReturning declares the after returning advice. It is applied after calling the actual method and before returning result. But you can get the result value in the advice.
    @Around declares the around advice. It is applied before and after calling the actual method.
    @AfterThrowing declares the throws advice. It is applied if actual method throws exception.

(1)Pointcut

  • Pointcut is an expression language of Spring AOP.
  • The @Pointcut annotation is used to define the pointcut.

  • We can refer the pointcut expression by name also.

    @Pointcut(“execution( Operation.(..))”)
    private void doSomething() {

    1. }

It will be applied on all the public methods.

  1. @Pointcut("execution(public Operation.*(..))")

It will be applied on all the methods of Operation class.

  1. @Pointcut("execution(* Operation.*(..))")

It will be applied on all the public setter methods of Employee class.

  1. @Pointcut("execution(public Employee.set*(..))")

It will be applied on all the methods of Operation class that returns int value.

  1. @Pointcut("execution(int Operation.*(..))")

(2)@Before

  1. public class Operation {
  3.     public void msg(){
  4.     System.out.println("msg method invoked");}
  5.     public int m(){
  6.     System.out.println("m method invoked");return 2;}
  7.     public int k(){
  8.     System.out.println("k method invoked");return 3;}
  9. }
  11. package com.amy;
  13. import org.aspectj.lang.JoinPoint;
  14. import org.aspectj.lang.annotation.Aspect;
  15. import org.aspectj.lang.annotation.Before;
  16. import org.aspectj.lang.annotation.Pointcut;
  18. /**
  19.  * @author: Amy
  20.  * @create: 2023-02-20 15:05
  21.  **/
  22. @Aspect
  23. public class TrackOperation {
  25.     @Pointcut("execution(* Operation.*(..))")
  26.     public void k(){
  27.     }//pointcut name
  28.     @Before("k()")//applying pointcut on before advice  
  29.     public void myadvice(JoinPoint jp){
  30.     //it is advice (before advice)  
  31.         System.out.println("additional concern");
  32.     }
  33. }
  35. <?xml version="1.0" encoding="UTF-8"?>
  36. <beans
  37.         xmlns="http://www.springframework.org/schema/beans"
  38.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  39.         xmlns:p="http://www.springframework.org/schema/p"
  40.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  41. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  43.     <bean id="op" class="com.amy.Operation"></bean>
  44.     <bean id="trackOperation" class="com.amy.TrackOperation"></bean>
  46.     <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"></bean>
  48. </beans>
  50. public class Test {
  52.     public static void main(String[] args) {
  54.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  55.        Operation o= (Operation) context.getBean("op");
  56.         System.out.println("calling msg...");
  57.         o.msg();
  58.         System.out.println("calling m...");
  59.         o.m();
  60.         System.out.println("calling k...");
  61.         o.k();
  63.     }
  64. }
  66. calling msg...
  67. additional concern
  68. msg method invoked
  69. calling m...
  70. additional concern
  71. m method invoked
  72. calling k...
  73. additional concern
  74. k method invoked

if you change the pointcut expression

before

  1. @Pointcut("execution(* Operation.*(..))")
  3. calling msg...
  4. additional concern
  5. msg method invoked
  6. calling m...
  7. additional concern
  8. m method invoked
  9. calling k...
  10. additional concern
  11. k method invoked

modify

  1. @Pointcut("execution(* Operation.m*(..))")

Now additional concern will be applied for the methods starting with m in Operation class

  1. calling msg...
  2. additional concern
  3. msg method invoked
  4. calling m...
  5. additional concern
  6. m method invoked
  7. calling k...
  8. k method invoked//have no "additional concern"

(3)@After

  1. public class Operation {
  3.     public void msg(){
  4.     System.out.println("msg method invoked");}
  5.     public int m(){
  6.     System.out.println("m method invoked");return 2;}
  7.     public int k(){
  8.     System.out.println("k method invoked");return 3;}
  9. }
  11. import org.aspectj.lang.JoinPoint;
  12. import org.aspectj.lang.annotation.After;
  13. import org.aspectj.lang.annotation.Aspect;
  14. import org.aspectj.lang.annotation.Pointcut;
  16. /**
  17.  * @author: Amy
  18.  * @create: 2023-02-20 15:05
  19.  **/
  20. @Aspect
  21. public class TrackOperation {
  23.     @Pointcut("execution(* Operation.*(..))")
  24.     public void k(){
  25.     }//pointcut name
  26.     @After("k()")//applying pointcut on after advice  
  27.     public void myadvice(JoinPoint jp){
  29.         System.out.println("additional concern");
  30.     }
  31. }
  33. <?xml version="1.0" encoding="UTF-8"?>
  34. <beans
  35.         xmlns="http://www.springframework.org/schema/beans"
  36.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  37.         xmlns:p="http://www.springframework.org/schema/p"
  38.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  39. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  41.     <bean id="op" class="com.amy.Operation"></bean>
  42.     <bean id="trackOperation" class="com.amy.TrackOperation"></bean>
  44.     <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"></bean>
  46. </beans>
  48. public class Test {
  50.     public static void main(String[] args) {
  52.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  53.        Operation o= (Operation) context.getBean("op");
  54.         System.out.println("calling msg...");
  55.         o.msg();
  56.         System.out.println("calling m...");
  57.         o.m();
  58.         System.out.println("calling k...");
  59.         o.k();
  61.     }
  62. }
  64. calling msg...
  65. msg method invoked
  66. additional concern
  67. calling m...
  68. m method invoked
  69. additional concern
  70. calling k...
  71. k method invoked
  72. additional concern

(4) @AfterReturning

By using after returning advice, we can get the result in the advice.

  1. public class Operation {
  3.     public int m(){
  4.     System.out.println("m method invoked");return 2;}
  5.     public int k(){
  6.     System.out.println("k method invoked");return 3;}
  7. }
  9. package com.amy;
  11. import org.aspectj.lang.JoinPoint;
  12. import org.aspectj.lang.annotation.AfterReturning;
  13. import org.aspectj.lang.annotation.Aspect;
  15. /**
  16.  * @author: Amy
  17.  * @create: 2023-02-20 15:05
  18.  **/
  19. @Aspect
  20. public class TrackOperation {
  22.     @AfterReturning(
  23.             pointcut = "execution(* Operation.*(..))",
  24.             returning= "result")
  26.     public void myadvice(JoinPoint jp,Object result){
  28.         System.out.println("additional concern");
  29.         System.out.println("Method Signature: "  + jp.getSignature());
  30.         System.out.println("Result in advice: "+result);
  31.         System.out.println("end of after returning advice...");
  32.     }
  33. }
  35. <?xml version="1.0" encoding="UTF-8"?>
  36. <beans
  37.         xmlns="http://www.springframework.org/schema/beans"
  38.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  39.         xmlns:p="http://www.springframework.org/schema/p"
  40.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  41. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  43.     <bean id="op" class="com.amy.Operation"></bean>
  44.     <bean id="trackOperation" class="com.amy.TrackOperation"></bean>
  46.     <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"></bean>
  48. </beans>
  50. public class Test {
  52.     public static void main(String[] args) {
  54.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  55.        Operation o= (Operation) context.getBean("op");
  56.         System.out.println("calling m...");
  57.         o.m();
  58.         System.out.println("calling k...");
  59.         o.k();
  61.     }
  62. }
  64. calling m...
  65. m method invoked
  66. additional concern
  67. Method Signature: int com.amy.Operation.m()
  68. Result in advice: 2
  69. end of after returning advice...
  70. calling k...
  71. k method invoked
  72. additional concern
  73. Method Signature: int com.amy.Operation.k()
  74. Result in advice: 3
  75. end of after returning advice...

(5) @Around

  • The AspectJ around advice is applied before and after calling the actual business logic methods.

  • Here, we are assuming that applicationContext.xml file is same as given in @Before example.

    public class Operation {

    1. public void msg(){
    2. System.out.println("msg() is invoked");}
    3. public void display(){
    4. System.out.println("display() is invoked");}

    }

    package com.amy;

  1. import org.aspectj.lang.ProceedingJoinPoint;
  2. import org.aspectj.lang.annotation.Around;
  3. import org.aspectj.lang.annotation.Aspect;
  4. import org.aspectj.lang.annotation.Pointcut;
  6. /**
  7.  * @author: Amy
  8.  * @create: 2023-02-20 15:05
  9.  **/
  10. @Aspect
  11. public class TrackOperation {
  13.     @Pointcut("execution(* Operation.*(..))")
  14.     public void k(){
  15.     }//pointcut name
  16.     @Around("k()")//applying pointcut on before advice
  17.     public Object myadvice(ProceedingJoinPoint jp) throws Throwable{
  18.     //it is advice (before advice)
  19.         System.out.println("Additional Concern Before calling actual method");
  20.         Object obj = jp.proceed();
  21.         System.out.println("Additional Concern After calling actual method");
  22.         return obj;
  23.     }
  24. }
  26. <?xml version="1.0" encoding="UTF-8"?>
  27. <beans
  28.         xmlns="http://www.springframework.org/schema/beans"
  29.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  30.         xmlns:p="http://www.springframework.org/schema/p"
  31.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  32. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  34.     <bean id="op" class="com.amy.Operation"></bean>
  35.     <bean id="trackOperation" class="com.amy.TrackOperation"></bean>
  37.     <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"></bean>
  39. </beans>
  41. public class Test {
  43.     public static void main(String[] args) {
  45.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  46.        Operation o= (Operation) context.getBean("op");
  47.         o.msg();
  48.         o.display();
  50.     }
  51. }
  53. Additional Concern Before calling actual method
  54. msg() is invoked
  55. Additional Concern After calling actual method
  56. Additional Concern Before calling actual method
  57. display() is invoked
  58. Additional Concern After calling actual method

(6)@AfterThrowing

  • By using after throwing advice, we can print the exception in the TrackOperation class.

    public class Operation {

    1. public void validate(int age)throws Exception{
    3.     if(age<18){
    5.         throw new ArithmeticException("Not valid age");
    6.     }
    7.     else{
    9.         System.out.println("Thanks for vote");
    10.     }
    11. }

    }

    package com.amy;

  1. import org.aspectj.lang.JoinPoint;
  2. import org.aspectj.lang.annotation.AfterThrowing;
  3. import org.aspectj.lang.annotation.Aspect;
  6. /**
  7.  * @author: Amy
  8.  * @create: 2023-02-20 15:05
  9.  **/
  10. @Aspect
  11. public class TrackOperation {
  13.     @AfterThrowing(
  14.             pointcut = "execution(* Operation.*(..))",
  15.             throwing= "error")
  17.     public void myadvice(JoinPoint jp, Throwable error)//it is advice
  18.     {
  20.         System.out.println("additional concern");
  21.         System.out.println("Method Signature: "  + jp.getSignature());
  22.         System.out.println("Exception is: "+error);
  23.         System.out.println("end of after throwing advice...");
  24.     }
  25. }
  27. <?xml version="1.0" encoding="UTF-8"?>
  28. <beans
  29.         xmlns="http://www.springframework.org/schema/beans"
  30.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  31.         xmlns:p="http://www.springframework.org/schema/p"
  32.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  33. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  35.     <bean id="op" class="com.amy.Operation"></bean>
  36.     <bean id="trackOperation" class="com.amy.TrackOperation"></bean>
  38.     <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"></bean>
  40. </beans>
  42. public class Test {
  44.     public static void main(String[] args) {
  46.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  47.        Operation o= (Operation) context.getBean("op");
  48.         try{
  50.             o.validate(19);
  51.         }catch(Exception e){
  52.     System.out.println(e);}
  53.         System.out.println("calling validate again...");
  55.         try{
  57.             o.validate(11);
  58.         }catch(Exception e){
  59.     System.out.println(e);}
  60.     }
  62. }
  64. Thanks for vote
  65. calling validate again...
  66. additional concern
  67. Method Signature: void com.amy.Operation.validate(int)
  68. Exception is: java.lang.ArithmeticException: Not valid age
  69. end of after throwing advice...
  70. java.lang.ArithmeticException: Not valid age

2)By xml configuration (schema based)

  • Spring enables you to define the aspects, advices and pointcuts in xml file.
    aop:before It is applied before calling the actual business logic method.
    aop:after It is applied after calling the actual business logic method.
    aop:after-returning it is applied after calling the actual business logic method. It can be used to intercept the return value in advice.
    aop:aroundIt is applied before and after calling the actual business logic method.
    aop:after-throwing It is applied if actual business logic method throws exception.

(1) aop:before

  1. public class Operation {
  3.     public void msg(){
  4.     System.out.println("msg method invoked");}
  5.     public int m(){
  6.     System.out.println("m method invoked");return 2;}
  7.     public int k(){
  8.     System.out.println("k method invoked");return 3;}
  9. }
  11. public class TrackOperation {
  13.     public void myadvice(JoinPoint jp)//it is advice
  14.     {
  16.         System.out.println("additional concern");
  17.     }
  18. }
  20. <?xml version="1.0" encoding="UTF-8"?>
  21. <beans xmlns="http://www.springframework.org/schema/beans"
  22.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  23.        xmlns:aop="http://www.springframework.org/schema/aop"
  24.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  25.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  26.     http://www.springframework.org/schema/aop
  27.     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
  29.     <aop:aspectj-autoproxy />
  30.     <bean id="op" class="com.amy.Operation"></bean>
  31.     <bean id="trackOperation" class="com.amy.TrackOperation"></bean>
  33.     <aop:config>
  34.             <aop:aspect id="myaspect"  ref="trackOperation">
  35.                 <!-- @Before -->
  36.                 <aop:pointcut id="pointCutBefore" expression="execution(* com.amy.Operation.*(..))"/>
  37.                 <aop:before method="myadvice" pointcut-ref="pointCutBefore" />
  38.             </aop:aspect>
  39.     </aop:config>
  41. </beans>
  43. public class Test {
  45.     public static void main(String[] args) {
  47.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  48.        Operation o= (Operation) context.getBean("op");
  49.         System.out.println("calling msg...");
  50.         o.msg();
  51.         System.out.println("calling m...");
  52.         o.m();
  53.         System.out.println("calling k...");
  54.         o.k();
  55.     }
  57. }
  59. calling msg...
  60. additional concern
  61. msg method invoked
  62. calling m...
  63. additional concern
  64. m method invoked
  65. calling k...
  66. additional concern
  67. k method invoked

(2)aop:after

  1. public class Operation {
  3.     public void msg(){
  4.     System.out.println("msg method invoked");}
  5.     public int m(){
  6.     System.out.println("m method invoked");return 2;}
  7.     public int k(){
  8.     System.out.println("k method invoked");return 3;}
  9. }
  11. public class TrackOperation {
  13.     public void myadvice(JoinPoint jp)//it is advice
  14.     {
  16.         System.out.println("additional concern");
  17.     }
  18. }
  20. <?xml version="1.0" encoding="UTF-8"?>
  21. <beans xmlns="http://www.springframework.org/schema/beans"
  22.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  23.        xmlns:aop="http://www.springframework.org/schema/aop"
  24.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  25.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  26.     http://www.springframework.org/schema/aop
  27.     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
  29.     <aop:aspectj-autoproxy />
  30.     <bean id="op" class="com.amy.Operation"></bean>
  31.     <bean id="trackOperation" class="com.amy.TrackOperation"></bean>
  33.     <aop:config>
  34.             <aop:aspect id="myaspect"  ref="trackOperation">
  35.                 <!-- @After -->
  36.                 <aop:pointcut id="pointCutAfter"    expression="execution(* com.amy.Operation.*(..))" />
  37.                 <aop:after method="myadvice" pointcut-ref="pointCutAfter" />
  38.             </aop:aspect>
  39.     </aop:config>
  41. </beans>
  43. public class Test {
  45.     public static void main(String[] args) {
  47.        ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");
  48.        Operation o= (Operation) context.getBean("op");
  49.         System.out.println("calling msg...");
  50.         o.msg();
  51.         System.out.println("calling m...");
  52.         o.m();
  53.         System.out.println("calling k...");
  54.         o.k();
  55.     }
  57. }
  59. calling msg...
  60. msg method invoked
  61. additional concern
  62. calling m...
  63. m method invoked
  64. additional concern
  65. calling k...
  66. k method invoked
  67. additional concern

(3)aop:after-returning

  1. public class Operation {
  3.     public int m(){
  4.     System.out.println("m method invoked");return 2;}
  5.     public int k(){
  6.     System.out.println("k method invoked");return 3;}
  7. }
  9. public class TrackOperation {
  11.     public void myadvice(JoinPoint jp,Object result)//it is advice (after advice)
  12.     {
  14.         System.out.println("additional concern");
  15.         System.out.println("Method Signature: "  + jp.getSignature());
  16.         System.out.println("Result in advice: "+result);
  17.         System.out.println("end of after returning advice...");
  18.     }
  19. }
  21. <?xml version="1.0" encoding="UTF-8"?>
  22. <beans xmlns="http://www.springframework.org/schema/beans"
  23.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  24.        xmlns:aop="http://www.springframework.org/schema/aop"
  25.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  26.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  27.     http://www.springframework.org/schema/aop
  28.     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
  30.     <aop:aspectj-autoproxy />
  31.     <bean id="op" class="com.amy.Operation"></bean>
  32.     <bean id="trackOperation" class="com.amy.TrackOperation"></bean>
  34.     <aop:config>
  35.             <aop:aspect id="myaspect"  ref="trackOperation">
  36.                 <!-- @AfterReturning -->
  37.                 <aop:pointcut id="pointCutAfterReturning"   expression="execution(* com.amy.Operation.*(..))" />
  38.                 <aop:after-returning method="myadvice" returning="result" pointcut-ref="pointCutAfterReturning" />
  39.             </aop:aspect>
  40.     </aop:config>
  42. </beans>
  44. public class Test {
  46.     public static void main(String[] args) {
  48.         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  49.         Operation o = (Operation) context.getBean("op");
  50.         System.out.println("calling m...");
  51.         System.out.println(o.m());
  52.         System.out.println("calling k...");
  53.         System.out.println(o.k());
  54.     }
  56. }
  58. calling m...
  59. m method invoked
  60. additional concern
  61. Method Signature: int com.amy.Operation.m()
  62. Result in advice: 2
  63. end of after returning advice...
  64. 2
  65. calling k...
  66. k method invoked
  67. additional concern
  68. Method Signature: int com.amy.Operation.k()
  69. Result in advice: 3
  70. end of after returning advice...
  71. 3

(4)aop:around

  1. public class Operation {
  3.     public void msg(){
  4.     System.out.println("msg() is invoked");}
  5.     public void display(){
  6.     System.out.println("display() is invoked");}
  7. }
  9. public class TrackOperation {
  11.     public Object myadvice(ProceedingJoinPoint pjp) throws Throwable
  12.     {
  14.         System.out.println("Additional Concern Before calling actual method");
  15.         Object obj=pjp.proceed();
  16.         System.out.println("Additional Concern After calling actual method");
  17.         return obj;
  18.     }
  19. }
  21. <?xml version="1.0" encoding="UTF-8"?>
  22. <beans xmlns="http://www.springframework.org/schema/beans"
  23.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  24.        xmlns:aop="http://www.springframework.org/schema/aop"
  25.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  26.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  27.     http://www.springframework.org/schema/aop
  28.     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
  30.     <aop:aspectj-autoproxy />
  31.     <bean id="op" class="com.amy.Operation"></bean>
  32.     <bean id="trackOperation" class="com.amy.TrackOperation"></bean>
  34.     <aop:config>
  35.             <aop:aspect id="myaspect"  ref="trackOperation">
  36.                 <!-- @Around -->
  37.                 <aop:pointcut id="pointCutAround"   expression="execution(* com.amy.Operation.*(..))" />
  38.                 <aop:around method="myadvice" pointcut-ref="pointCutAround" />      </aop:aspect>
  39.     </aop:config>
  41. </beans>
  43. public class Test {
  45.     public static void main(String[] args) {
  47.         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  48.         Operation o = (Operation) context.getBean("op");
  49.         o.msg();
  50.         o.display();
  51.     }
  53. }
  55. Additional Concern Before calling actual method
  56. msg() is invoked
  57. Additional Concern After calling actual method
  58. Additional Concern Before calling actual method
  59. display() is invoked
  60. Additional Concern After calling actual method

(5)aop:after-throwing

  1. public class Operation {
  3.     public void validate(int age)throws Exception{
  5.         if(age<18){
  7.             throw new ArithmeticException("Not valid age");
  8.         }
  9.         else{
  11.             System.out.println("Thanks for vote");
  12.         }
  13.     }
  14. }
  16. public class TrackOperation {
  18.     public void myadvice(JoinPoint jp,Throwable error)//it is advice
  19.     {
  21.         System.out.println("additional concern");
  22.         System.out.println("Method Signature: "  + jp.getSignature());
  23.         System.out.println("Exception is: "+error);
  24.         System.out.println("end of after throwing advice...");
  25.     }
  26. }
  28. <?xml version="1.0" encoding="UTF-8"?>
  29. <beans xmlns="http://www.springframework.org/schema/beans"
  30.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  31.        xmlns:aop="http://www.springframework.org/schema/aop"
  32.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  33.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  34.     http://www.springframework.org/schema/aop
  35.     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
  37.     <aop:aspectj-autoproxy />
  38.     <bean id="op" class="com.amy.Operation"></bean>
  39.     <bean id="trackOperation" class="com.amy.TrackOperation"></bean>
  41.     <aop:config>
  42.             <aop:aspect id="myaspect"  ref="trackOperation">
  43.                 <!-- @AfterThrowing -->
  44.                 <aop:pointcut id="pointCutAfterThrowing"    expression="execution(* com.amy.Operation.*(..))" />
  45.                 <aop:after-throwing method="myadvice" throwing="error" pointcut-ref="pointCutAfterThrowing" />
  46.             </aop:aspect>
  47.     </aop:config>
  49. </beans>
  51. public class Test {
  53.     public static void main(String[] args) {
  55.         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  56.         Operation o = (Operation) context.getBean("op");
  57.         System.out.println("calling validate...");
  58.         try{
  60.             o.validate(19);
  61.         }catch(Exception e){
  62.     System.out.println(e);}
  63.         System.out.println("calling validate again...");
  65.         try{
  67.             o.validate(11);
  68.         }catch(Exception e){
  69.     System.out.println(e);}
  70.     }
  72. }
  74. calling validate...
  75. Thanks for vote
  76. calling validate again...
  77. additional concern
  78. Method Signature: void com.amy.Operation.validate(int)
  79. Exception is: java.lang.ArithmeticException: Not valid age
  80. end of after throwing advice...
  81. java.lang.ArithmeticException: Not valid age

发表评论

表情：
评论列表 （有 0 条评论，223人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Spring AOP详细介绍

    AOP称为面向切面编程，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等待，Struts2的拦截器设计就是基于AOP的思想，是个比较经典的例子。 一 AO

    浅浅的花香味﹌浅浅的花香味﹌/ 0 赞/ 328 阅读