spring之为什么要使用AOP（面向切片编程）？
需求1-日志：在程序执行期间追踪正在发生的活动；
需求2-验证：希望计算器只处理正数的运算；
一、普通方法实现
Calculator.java
package com.gong.spring.aop.helloworld; public interface Calculator { int add(int i, int j); int sub(int i, int j); int mul(int i, int j); int div(int i, int j); }
CalculatorImpl.java
package com.gong.spring.aop.helloworld; public class CalculatorImpl implements Calculator{ @Override public int add(int i, int j) { System.out.println("add begin"); // TODO Auto-generated method stub int result = i+j; System.out.println("add end"); return result; } @Override public int sub(int i, int j) { System.out.println("sub begin"); // TODO Auto-generated method stub int result = i - j; System.out.println("sub end"); return result; } @Override public int mul(int i, int j) { System.out.println("mul begin"); // TODO Auto-generated method stub int result = i * j; System.out.println("mul end"); return result; } @Override public int div(int i, int j) { System.out.println("div begin"); // TODO Auto-generated method stub int result = i / j; System.out.println("div end"); return result; } }
Main.java
package com.gong.spring.aop.helloworld; public class Main { public static void main(String[] args) { Calculator calculator = new CalculatorImpl(); int i = 2; int j = 1; int res = calculator.add(i, j); System.out.println(res); res = calculator.sub(i, j); System.out.println(res); res = calculator.mul(i, j); System.out.println(res); res = calculator.div(i, j); System.out.println(res); } }
输出：
存在两个问题：
（1）代码混乱：每个方法在处理逻辑核心问题时还要关注其它问题，比如日志和计算。
（2）代码分散：如果日志发生变化，则需要修改所有方法的日志。
二、第一种解决方法：使用动态代理。
动态代理原理：使用一个代理将对象包装起来，然后调用该代理对象取代原始对象，任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法转到原始的对象上。
CalculatorLoggingImpl.java
package com.gong.spring.aop.helloworld; public class CalculatorLoggingImpl implements Calculator{ @Override public int add(int i, int j) { // TODO Auto-generated method stub int result = i+j; return result; } @Override public int sub(int i, int j) { // TODO Auto-generated method stub int result = i - j; return result; } @Override public int mul(int i, int j) { // TODO Auto-generated method stub int result = i * j; return result; } @Override public int div(int i, int j) { // TODO Auto-generated method stub int result = i / j; return result; } }
package com.gong.spring.aop.helloworld; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class CalculatorLoggingProxy { public CalculatorLoggingProxy(Calculator target) { this.target = target; } //要代理的对象 private Calculator target; public Calculator getLoggingProxy() { Calculator proxy = null; //代理对象由哪一个类加载器进行加载 ClassLoader loader = target.getClass().getClassLoader(); //代理对象的类型，即其中有哪些方法 Class [] interfaces = new Class[]{Calculator.class}; //调用代理对象其中的方法时，该执行的代码 InvocationHandler h = new InvocationHandler() { /*proxy:正在返回的代理对象 *method:：正在被调用的方法 *args：调用方法时传入的参数 * */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub String methodName = method.getName(); //日志 System.out.println(methodName+" begin"); //执行方法 Object result = method.invoke(target, args); //日志 System.out.println(methodName+" end"); return result; } }; proxy = (Calculator) Proxy.newProxyInstance(loader, interfaces, h); return proxy; } }
Main.java
package com.gong.spring.aop.helloworld; public class Main { public static void main(String[] args) { Calculator calculator = new CalculatorLoggingImpl(); Calculator proxy = new CalculatorLoggingProxy(calculator).getLoggingProxy(); int i = 2; int j = 1; int result =proxy.add(i, j); System.out.println(result); result = proxy.sub(i, j); System.out.println(result); result = proxy.mul(i, j); System.out.println(result); result = proxy.div(i, j); System.out.println(result); } }
输出：
可以达到同样的效果，但是我们的日志模块只需要关注在代理中如何修改，进而可以影响到普通实现的所有方法。
三、第二种方式：使用AOP
AOP是对传统OOP（面向对象编程）的一种补充。其主要编程对象是切面，而切面模块化横切关注点。在应用AOP时，仍然需要定义公共功能，但可以明确定义这个功能在哪里，以什么方式应用。并且不必修改受影响的类，这样一来横切关注点就被模块化到特殊对象（切面）里。
新建一个包，目录结构如下：
需要加入到build path中的包：
说明：注解中的value属性标识了为哪些方法加上通知。
Calculator.java
package com.gong.spring.aop.impl; public interface Calculator { int add(int i, int j); int sub(int i, int j); int mul(int i, int j); int div(int i, int j); }
CalculatorImpl.java
package com.gong.spring.aop.impl; import org.springframework.stereotype.Component; @Component public class CalculatorImpl implements Calculator{ @Override public int add(int i, int j) { // TODO Auto-generated method stub int result = i+j; return result; } @Override public int sub(int i, int j) { // TODO Auto-generated method stub int result = i - j; return result; } @Override public int mul(int i, int j) { // TODO Auto-generated method stub int result = i * j; return result; } @Override public int div(int i, int j) { // TODO Auto-generated method stub int result = i / j; return result; } }
applicationContext.java
<?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" xmlns:context="http://www.springframework.org/schema/context" 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-4.3.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd"> <context:component-scan base-package="com.gong.spring.aop.impl"></context:component-scan> <!-- 使AspectJ注解起作用：自动为匹配的类生成代理对象 --> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans>
在LoggingAspect.java中先只定义这么一个类，并且加上注解：
package com.gong.spring.aop.impl; import java.util.Arrays; import java.util.List; import javax.management.RuntimeErrorException; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; //把这个类声明为一个切面：需要把该类放入到IOC容器中，再声明为一个切面 @Aspect @Component public class LoggingAspect { }
Main.java（这里只测试两个）
package com.gong.spring.aop.impl; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Main { public static void main(String[] args) { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); //从IOC容器中获取bean的实例 Calculator calculator = (Calculator) ctx.getBean(Calculator.class); int res = calculator.add(2, 1); System.out.println("在主函数中加法计算的结果="+res); res = calculator.div(2, 1); System.out.println("在主函数中除法计算的结果="+res); } }
1.前置通知
在applicationContext.java中先加入：
//声明该方法为一个前置通知，在目标方法之前执行 @Before("execution(public int com.gong.spring.aop.impl.Calculator.*(int, int))") public void beforeMethod(JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName(); List<Object> args = Arrays.asList(joinPoint.getArgs()); System.out.println(methodName+" begin with "+args); }
输出：
即前置通知是在目标函数调用前执行。
2.后置通知
再加入：
//后置通知：在目标方法执行后，无论是否发生异常，执行的通知 //在后置通知中不能访问目标的执行结果 @After("execution(public int com.gong.spring.aop.impl.Calculator.*(int, int))") public void afterMethod(JoinPoint joinPoint) { //获取名字 String methodName = joinPoint.getSignature().getName(); //获取参数 List<Object> args = Arrays.asList(joinPoint.getArgs()); System.out.println(methodName+" end with "+args); }
输出：
后置通知在目标函数执行后执行，并且无论目标函数是否出现异常，都会执行。 j假设将除法分母设置为0，那么结果为：
3.带返回值的后置通知
注释掉 afterMethod方法，再加上：
//在方法正常结束后执行的代码 //返回通知是可以访问到方法的返回值的 @AfterReturning(value="execution(public int com.gong.spring.aop.impl.Calculator.*(..))", returning="result") public void afterReturning(JoinPoint joinPoint,Object result) { String methodName = joinPoint.getSignature().getName(); List<Object> args = Arrays.asList(joinPoint.getArgs()); System.out.println("在afterReturning得到返回值："+ result); System.out.println(methodName+" end with "+args); }
输出：
可以在通知函数里面获得计算的值。
4.当发生异常时才会运行的通知
还有一种当只有发生异常时才会执行该通知：将除法分母变为0
@AfterThrowing(value="execution(public int com.gong.spring.aop.impl.Calculator.*(..))", throwing="ex") public void afterThrowing(JoinPoint joinPoint,Exception ex) { String methodName = joinPoint.getSignature().getName(); System.out.println(methodName+" occurs exception:"+ex); }
输出：
5.环绕通知
@Around(value="execution(public int com.gong.spring.aop.impl.Calculator.*(..))") public Object aroundMethod(ProceedingJoinPoint pjd) { Object result = null; String methodName = pjd.getSignature().getName(); //执行目标方法 try { //前置通知 System.out.println(methodName+" begin with "+Arrays.asList(pjd.getArgs())); //执行目标方法 result = pjd.proceed(); //后置通知 System.out.println("在aroundMethod中得到值："+result); } catch (Throwable e) { // TODO Auto-generated catch block //异常通知 System.out.println("the method occurs exception：" + e); throw new RuntimeException(e); } //后置通知 System.out.println(methodName+" end with "+Arrays.asList(pjd.getArgs())); return result; }
输出：
当然，在环绕通知中也能狗处理异常。
AOP的好处：
（1）每个事物逻辑位于一个位置，代码不分散，便于维护和升级；
（2）业务模块更简洁，只包含核心业务代码；
版权声明：本文为xiximayou原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。