Spring--AOP 例子

Posted 2020-09-28 我是修电脑的

先用代码讲一下什么是传统的AOP(面向切面编程)编程

需求：实现一个简单的计算器，在每一步的运算前添加日志。最传统的方式如下：

Calculator.Java

 

[java] view plain copy

 

 print?

1. package cn.limbo.spring.aop.calculator;  
2.   
3. /** 
4.  * Created by Limbo on 16/7/14. 
5.  */  
6. public interface Calculator {  
7.     int add(int i , int j);  
8.     int sub(int i , int j);  
9.     int mul(int i , int j);  
10.     int div(int i , int j);  
11. }  

CalculatorImpl.java

 

 

[java] view plain copy

 

 print?

1. package cn.limbo.spring.aop.calculator;  
2.   
3. /** 
4.  * Created by Limbo on 16/7/14. 
5.  */  
6. public class CalculatorImpl implements Calculator {  
7.     @Override  
8.     public int add(int i, int j) {  
9.         System.out.println("The method add begin with [ "+ i +"," + j+" ]");  
10.         System.out.println("The method add end with [ "+ i +"," + j+"]");  
11.         return i + j;  
12.     }  
13.   
14.     @Override  
15.     public int sub(int i, int j) {  
16.         System.out.println("The method sub begin with [ "+ i +"," + j+" ]");  
17.         System.out.println("The method sub end with [ "+ i +"," + j+" ]");  
18.         return i - j;  
19.     }  
20.   
21.     @Override  
22.     public int mul(int i, int j) {  
23.         System.out.println("The method mul begin with [ "+ i +"," + j+" ]");  
24.         System.out.println("The method mul end with [ "+ i +"," + j+" ]");  
25.         return i * j;  
26.     }  
27.   
28.     @Override  
29.     public int div(int i, int j) {  
30.         System.out.println("The method div begin with [ "+ i +"," + j+" ]");  
31.         System.out.println("The method div end with [ "+ i +"," + j+" ]");  
32.         return i / j;  
33.     }  
34. }  

这样就完成了需求，但是我们发现，倘若是要修改日志的信息，那么就需要在具体方法里面改，这样做很麻烦，而且把原本清爽的方法改的十分混乱，方法应该表现的是核心功能，而不是这些无关紧要的关注点，下面用原生的java的方式实现在执行方法时，动态添加输出日志方法

 

CalculatorImpl.java

 

[java] view plain copy

 

 print?

1. package cn.limbo.spring.aop.calculator;  
2.   
3. /** 
4.  * Created by Limbo on 16/7/14. 
5.  */  
6. public class CalculatorImpl implements Calculator {  
7.     @Override  
8.     public int add(int i, int j) {  
9.         return i + j;  
10.     }  
11.   
12.     @Override  
13.     public int sub(int i, int j) {  
14.         return i - j;  
15.     }  
16.   
17.     @Override  
18.     public int mul(int i, int j) {  
19.         return i * j;  
20.     }  
21.   
22.     @Override  
23.     public int div(int i, int j) {  
24.         return i / j;  
25.     }  
26. }  

CalculatorLoggingProxy.java

 

 

[java] view plain copy

 

 print?

1. package cn.limbo.spring.aop.calculator;  
2.   
3.   
4. import java.lang.reflect.InvocationHandler;  
5. import java.lang.reflect.Method;  
6. import java.lang.reflect.Proxy;  
7. import java.util.Arrays;  
8. import java.util.Objects;  
9.   
10. /** 
11.  * Created by Limbo on 16/7/14. 
12.  */  
13. public class CalculatorLoggingProxy {  
14.   
15.     //要代理的对象  
16.     private Calculator target;  
17.   
18.     public CalculatorLoggingProxy(Calculator target) {  
19.         this.target = target;  
20.     }  
21.   
22.     public Calculator getLoggingProxy(){  
23.   
24.         //代理对象由哪一个类加载器负责加载  
25.         ClassLoader loader = target.getClass().getClassLoader();  
26.         //代理对象的类型,即其中有哪些方法  
27.         Class[] interfaces = new Class[]{Calculator.class};  
28.         // 当调用代理对象其中的方法时,执行改代码  
29.         InvocationHandler handler = new InvocationHandler() {  
30.             @Override  
31.             /** 
32.              * proxy:正在返回的那个对象的代理,一般情况下,在invoke方法中不使用该对象 
33.              * method:正在被调用的方法 
34.              * args:调用方法时,传入的参数 
35.              */  
36.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
37.                 String methodName = method.getName();  
38.                 System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));  
39.                 //日志  
40.                 Object result = method.invoke(target,args);  
41.                 System.out.println("The method " + methodName + " ends with " + result);  
42.   
43.                 return result;  
44.             }  
45.         };  
46.         Calculator proxy = (Calculator) Proxy.newProxyInstance(loader,interfaces,handler);  
47.   
48.         return proxy;  
49.     }  
50.   
51. }  

Main.java

 

 

[java] view plain copy

 

 print?

1. package cn.limbo.spring.aop.calculator;  
2.   
3. /** 
4.  * Created by Limbo on 16/7/14. 
5.  */  
6. public class Main {  
7.     public static void main(String[] args) {  
8.         Calculator calculator = new CalculatorImpl();  
9.         Calculator proxy = new CalculatorLoggingProxy(calculator).getLoggingProxy();  
10.   
11.         int result = proxy.add(1,2);  
12.         System.out.println("--->" + result);  
13.   
14.         result = proxy.sub(1,2);  
15.         System.out.println("--->" + result);  
16.   
17.         result = proxy.mul(3,2);  
18.         System.out.println("--->" + result);  
19.   
20.         result = proxy.div(14,2);  
21.         System.out.println("--->" + result);  
22.     }  
23. }  

这样写虽然已经简化了代码，而且可以任意修改日志信息代码，但是写起来还是很麻烦！！！

 

下面我们使用spring自带的aop包实现但是要加入

 com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.8.5.RELEASE.jar

这两个额外的包

下面看代码，要点全部卸载代码里面了

Calculator.java

[java] view plain copy

 

 print?

1. package cn.limbo.spring.aop.impl;  
2.   
3. /** 
4.  * Created by Limbo on 16/7/14. 
5.  */  
6. public interface Calculator {  
7.     int add(int i, int j);  
8.     int sub(int i, int j);  
9.     int mul(int i, int j);  
10.     int div(int i, int j);  
11. }  

CalculatorImpl.java

 

 

[java] view plain copy

 

 print?

1. package cn.limbo.spring.aop.impl;  
2.   
3. import org.springframework.stereotype.Component;  
4.   
5. /** 
6.  * Created by Limbo on 16/7/14. 
7.  */  
8. @Component("calculatorImpl")  
9. public class CalculatorImpl implements Calculator {  
10.     @Override  
11.     public int add(int i, int j) {  
12.         return i + j;  
13.     }  
14.   
15.     @Override  
16.     public int sub(int i, int j) {  
17.         return i - j;  
18.     }  
19.   
20.     @Override  
21.     public int mul(int i, int j) {  
22.         return i * j;  
23.     }  
24.   
25.     @Override  
26.     public int div(int i, int j) {  
27.         return i / j;  
28.     }  
29. }  

LoggingAspect.java

 

[java] view plain copy

 

 print?

1. package cn.limbo.spring.aop.impl;  
2.   
3. import org.aspectj.lang.JoinPoint;  
4. import org.aspectj.lang.ProceedingJoinPoint;  
5. import org.aspectj.lang.annotation.*;  
6. import org.springframework.core.annotation.Order;  
7. import org.springframework.stereotype.Component;  
8.   
9. import java.util.Arrays;  
10. import java.util.List;  
11. import java.util.Objects;  
12.   
13. /** 
14.  * Created by Limbo on 16/7/14. 
15.  */  
16. //把这个类声明为切面:需要该类放入IOC容器中,再声明为一个切面  
17. @Order(0)//指定切面优先级,只越小优先级越高  
18. @Aspect  
19. @Component  
20. public class LoggingAspect {  
21.   
22.     /** 
23.      * 定义一个方法,用于声明切入点表达式,一般的,该方法中再不需要添加其他代码 
24.      * 主要是为了重用路径,使用@Pointcut来声明切入点表达式 
25.      * 后面的其他通知直接使用方法名来引用当前的切入点表达式 
26.      */  
27.     @Pointcut("execution(* cn.limbo.spring.aop.impl.Calculator.*(..))")  
28.     public void declareJointPointExpression()  
29.     {  
30.   
31.     }  
32.   
33.   
34.     //声明该方法是一个前置通知:在目标方法之前执行  
35.     @Before("declareJointPointExpression()")  
36. //  @Before("execution(* cn.limbo.spring.aop.impl.*.*(..))")  该包下任意返回值,任意类,任意方法,任意参数类型  
37.     public void beforeMethod(JoinPoint joinPoint)  
38.     {  
39.         String methodName = joinPoint.getSignature().getName();  
40.         List<Object> args = Arrays.asList(joinPoint.getArgs());  
41.         System.out.println("The Method "+ methodName+" Begins With " + args);  
42.     }  
43.     //在目标方法执行之后执行,无论这个方法是否出错  
44.     //在后置通知中还不能访问目标方法的返回值,只能通过返回通知访问  
45.     @After("execution(* cn.limbo.spring.aop.impl.Calculator.*(int,int))")  
46.     public void afterMethod(JoinPoint joinPoint)  
47.     {  
48.         String methodName = joinPoint.getSignature().getName();  
49.         System.out.println("The Method "+ methodName+" Ends ");  
50.     }  
51.   
52.     /** 
53.      * 在方法正常结束后执行的代码 
54.      * 返回通知是可以访问到方法的返回值 
55.      */  
56.     @AfterReturning(value = "execution(* cn.limbo.spring.aop.impl.Calculator.*(..))",returning = "result")  
57.     public void afterReturning(JoinPoint joinPoint , Object result)  
58.     {  
59.         String methodName = joinPoint.getSignature().getName();  
60.         System.out.println("The Method " + methodName + " Ends With " + result);  
61.     }  
62.   
63.   
64.     /** 
65.      *在目标方法出现异常的时候执行代码 
66.      * 可以访问异常对象,且可以指定出现特定异常时再执行通知 
67.      */  
68.     @AfterThrowing(value = "execution(* cn.limbo.spring.aop.impl.Calculator.*(..))",throwing = "ex")  
69.     public void afterThrowing(JoinPoint joinPoint,Exception ex)//Exception 可以改成 NullPointerException等特定异常  
70.     {  
71.         String methodName = joinPoint.getSignature().getName();  
72.         System.out.println("The Method " + methodName + " Occurs With " + ex);  
73.     }  
74.   
75.     /** 
76.      * 环绕通知需要ProceedingJoinPoint 类型参数 功能最强大 
77.      * 环绕通知类似于动态代理的全过程:ProceedingJoinPoint 类型的参数可以决定是否执行目标方法 
78.      * 且环绕通知必须有返回值,返回值即为目标方法的返回值 
79.      */  
80.     @Around("execution(* cn.limbo.spring.aop.impl.Calculator.*(..))")  
81.     public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint)  
82.     {  
83.         Object result =null;  
84.         String methodName = proceedingJoinPoint.getSignature().getName();  
85.         try {  
86.             //前置通知  
87.             System.out.println("The Method " + methodName + " Begins With " + Arrays.asList(proceedingJoinPoint.getArgs()));  
88.             result = proceedingJoinPoint.proceed();  
89.             // 返回通知  
90.             System.out.println("The Method " + methodName + " Ends With " + result);  
91.         } catch (Throwable throwable) {  
92.             //异常通知  
93.             throwable.printStackTrace();  
94.         }  
95.         System.out.println("The Method " + methodName + " Ends ");  
96.         return result;  
97.     }  
98. }  

 

applicationContext.xml

 

[html] view plain copy

 

 print?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xmlns:context="http://www.springframework.org/schema/context"  
5.        xmlns:aop="http://www.springframework.org/schema/aop"  
6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">  
7.     <!--配置自动扫描的包-->  
8.     <context:component-scan base-package="cn.limbo.spring.aop.impl"></context:component-scan>  
9.   
10.     <!--使Aspect注解起作用,自动为匹配的类生成代理对象-->  
11.     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>  
12.   
13.   
14. </beans>  

用xml来配置aop

application-config.xml

 

[html] view plain copy

 

 print?

1. <?xml version="1.0" encoding="UTF-8"?>  
2.   
3. <beans xmlns="http://www.springframework.org/schema/beans"  
4.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
5.          xmlns:aop="http://www.springframework.org/schema/aop"  
6.          xmlns:tx="http://www.springframework.org/schema/tx"  
7.          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
8.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd  
9.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">  
10.                
11.       
12.     <bean id="userManager" class="com.tgb.aop.UserManagerImpl"/>  
13.       
14.     <!--<bean id="aspcejHandler" class="com.tgb.aop.AspceJAdvice"/>-->  
15.     <bean id="xmlHandler" class="com.tgb.aop.XMLAdvice" />  
16.     <aop:config>  
17.         <aop:aspect id="aspect" ref="xmlHandler">  
18.             <aop:pointcut id="pointUserMgr" expression="execution(* com.tgb.aop.*.find*(..))"/>  
19.               
20.             <aop:before method="doBefore"  pointcut-ref="pointUserMgr"/>  
21.             <aop:after method="doAfter"  pointcut-ref="pointUserMgr"/>  
22.             <aop:around method="doAround"  pointcut-ref="pointUserMgr"/>  
23.             <aop:after-returning method="doReturn"  pointcut-ref="pointUserMgr"/>  
24.             <aop:after-throwing method="doThrowing" throwing="ex" pointcut-ref="pointUserMgr"/>  
25.               
26.         </aop:aspect>  
27.     </aop:config>  
28. </beans>  

 

一共有5类的通知，其中around最为强大，但是不一定最常用，aspect的底层实现都是通过代理来实现的，只能说这个轮子造的不错

2016.12.09更新

最近在实际项目中配置aop发现了几个问题，实际的项目配置的的模式是ssh即Spring4+SpringMVC+Hibernate4的模式。

基于注解的方式配置方式有些坑点：

1.发现SpringMVC中aop不起任何作用

经过排查和查找网上的资料，发现问题如下：

Spring MVC启动时的配置文件，包含组件扫描、url映射以及设置freemarker参数，让spring不扫描带有@Service注解的类。为什么要这样设置？因为springmvc.xml与applicationContext.xml不是同时加载，如果不进行这样的设置，那么，spring就会将所有带@Service注解的类都扫描到容器中，等到加载applicationContext.xml的时候，会因为容器已经存在Service类，使得cglib将不对Service进行代理，直接导致的结果就是在applicationContext 中的事务配置不起作用，发生异常时，无法对数据进行回滚。以上就是原因所在。

 

所以改进后的applicationContext.xml如下（只是更改自动扫描包的那个配置）：

 

[html] view plain copy

 

 print?

1. <context:component-scan base-package="cn.limbo">  
2.         <!--不要将Controller扫进来，否则aop无法使用-->  
3.         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />  
4.     </context:component-scan>  

spring-mvc.xml扫描包配置如下：

 

 

[html] view plain copy

 

 print?

1. <context:component-scan base-package="cn.limbo">  
2.         <!--不要将Service扫进来，否则aop无法使用-->  
3.         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service" />  
4.     </context:component-scan>  

这样就可以成功解决ssh配置下不能使用aop的情况。看来扫描包的时候不能暴力直接全部扫描进来啊，真是成也扫描，败也扫描，手动哭笑不得。