上一篇

AOP

AOP前言

背景

需求1-日志：在程序执行期间追踪正在发生的活动
需求2-验证：希望计算器只能处理正数的运算
代码实现：

问题
代码混乱：越来越多的非业务需求(日志和验证等)加入后, 原有的业务方法急剧膨胀. 每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点.
代码分散: 以日志需求为例, 只是为了满足这个单一需求, 就不得不在多个模块（方法）里多次重复相同的日志代码. 如果日志需求发生变化, 必须修改所有模块.
相关的类

package wo;
public interface ArithmeticCalculator {int add(int i, int j);int sub(int i, int j);int mul(int i, int j);int div(int i, int j);	
}
/////////////////////////////////////////////////////
package wo;public class ArithmeticCalculatorImpl implements ArithmeticCalculator {@Overridepublic int add(int i, int j) {int result = i + j;return result;}@Overridepublic int sub(int i, int j) {int result = i - j;return result;}@Overridepublic int mul(int i, int j) {int result = i * j;return result;}@Overridepublic int div(int i, int j) {int result = i / j;return result;}
}

使用动态代理解决上述问题

代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上.

代码：
代理类

package wo;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;public class ArithmeticCalculatorLoggingProxy {//要代理的对象private ArithmeticCalculator target;public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target) {super();this.target = target;}//返回代理对象public ArithmeticCalculator getLoggingProxy(){ArithmeticCalculator proxy = null;//代理类的加载器ClassLoader loader = target.getClass().getClassLoader();//代理对象的类型，即其中有哪些方法Class [] interfaces = new Class[]{ArithmeticCalculator.class};//当调用代理对象其中的方法时，该执行的代码InvocationHandler h = new InvocationHandler() {/*** proxy: 代理对象。 一般不使用该对象* method: 正在被调用的方法* args: 调用方法传入的参数*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {String methodName = method.getName();//打印日志System.out.println("[before] The method " + methodName + " begins with " + Arrays.asList(args));//调用目标方法Object result = null;try {//前置通知result = method.invoke(target, args);//返回通知, 可以访问到方法的返回值} catch (NullPointerException e) {e.printStackTrace();//异常通知, 可以访问到方法出现的异常}//后置通知. 因为方法可以能会出异常, 所以访问不到方法的返回值//打印日志System.out.println("[after] The method ends with " + result);return result;}};/*** loader: 代理对象使用的类加载器。 * interfaces: 指定代理对象的类型. 即代理代理对象中可以有哪些方法. * h: 当具体调用代理对象的方法时, 应该如何进行响应, 实际上就是调用 InvocationHandler 的 invoke 方法*/proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);return proxy;}
}
//////////////////////////////////////////////////////////////
//测试
ArithmeticCalculator arithmeticCalculator = new ArithmeticCalculatorImpl();arithmeticCalculator = new ArithmeticCalculatorLoggingProxy(arithmeticCalculator).getLoggingProxy();int result = arithmeticCalculator.add(11, 12);System.out.println("result:" + result);

AOP介绍

AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充.
AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点.
在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里.
AOP 的好处:
每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级
业务模块更简洁, 只包含核心业务代码.

AOP 术语

切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象
通知(Advice): 切面必须要完成的工作
目标(Target): 被通知的对象
代理(Proxy): 向目标对象应用通知之后创建的对象
连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。例如 ArithmethicCalculator#add() 方法执行前的连接点，执行点为 ArithmethicCalculator#add()； 方位为该方法执行前的位置
切点（pointcut）：每个类都拥有多个连接点：例如 ArithmethicCalculator 的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

Spring AOP

AspectJ：Java 社区里最完整最流行的 AOP 框架.
在 Spring2.0 以上版本中, 可以使用基于 AspectJ 注解或基于 XML 配置的 AOP

在 Spring 中启用 AspectJ 注解支持

要在 Spring 应用中使用 AspectJ 注解, 必须在 classpath 下包含 AspectJ 类库: aopalliance.jar、aspectj.weaver.jar 和 spring-aspects.jar
将 aop Schema 添加到 < beans> 根元素中.
要在 Spring IOC 容器中启用 AspectJ 注解支持, 只要在 Bean 配置文件中定义一个空的 XML 元素 < aop:aspectj-autoproxy>
当 Spring IOC 容器侦测到 Bean 配置文件中的 < aop:aspectj-autoproxy> 元素时, 会自动为与 AspectJ 切面匹配的 Bean 创建代理.

用 AspectJ 注解声明切面

要在 Spring 中声明 AspectJ 切面, 只需要在 IOC 容器中将切面声明为 Bean 实例. 当在 Spring IOC 容器中初始化 AspectJ 切面之后, Spring IOC 容器就会为那些与 AspectJ 切面相匹配的 Bean 创建代理.
在 AspectJ 注解中, 切面只是一个带有 @Aspect 注解的 Java 类.
通知是标注有某种注解的简单的 Java 方法.
AspectJ 支持 5 种类型的通知注解:
@Before: 前置通知, 在方法执行之前执行
@After: 后置通知, 在方法执行之后执行
@AfterRunning: 返回通知, 在方法返回结果之后执行
@AfterThrowing: 异常通知, 在方法抛出异常之后
@Around: 环绕通知, 围绕着方法执行

前置通知

利用方法签名编写 AspectJ 切入点表达式

最典型的切入点表达式时根据方法的签名来匹配各种方法:
execution * com.atguigu.spring.ArithmeticCalculator.*(…): 匹配 ArithmeticCalculator 中声明的所有方法,第一个 * 代表任意修饰符及任意返回值. 第二个 * 代表任意方法. … 匹配任意数量的参数. 若目标类与接口与该切面在同一个包中, 可以省略包名.
execution public * ArithmeticCalculator.*(…): 匹配ArithmeticCalculator 接口的所有公有方法.
execution public double ArithmeticCalculator.*(…): 匹配 ArithmeticCalculator 中返回 double 类型数值的方法
execution public double ArithmeticCalculator.*(double, …): 匹配第一个参数为 double 类型的方法, … 匹配任意数量任意类型的参数
execution public double ArithmeticCalculator.*(double, double): 匹配参数类型为 double, double 类型的方法.

让通知访问当前连接点的细节

合并切入点表达式

在 AspectJ 中, 切入点表达式可以通过操作符 &&, ||, ! 结合起来.

例子(在前面的基础上)：

///spring2/src/wo/LoggingAspect.java
package wo;import java.util.Arrays;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;//通过添加 @Aspect 注解声明一个 bean 是一个切面!
@Aspect
@Component
public class LoggingAspect {@Before("execution(public int wo.ArithmeticCalculator.*(int, int))")public void beforeMethod(JoinPoint joinPoint){String methodName = joinPoint.getSignature().getName();Object [] args = joinPoint.getArgs();System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));}	
}
////////////////////////////////////////////////////////////////
//全局配置文件/spring2/src/applicationContext-aop.xml
<?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.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"><!-- 自动扫描的包 --><context:component-scan base-package="wo"></context:component-scan><!-- 使 AspectJ 的注解起作用 --><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>
////////////////////////////////////////////////////////
//测试
public static void main(String[] args) {// TODO Auto-generated method stubApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-aop.xml");ArithmeticCalculator a = (ArithmeticCalculator) ctx.getBean("arithmeticCalculatorImpl");System.out.println(a.add(2, 3));System.out.println(a.sub(2, 3));}

总结：

1. SpringAOP
   1).加入jar包:
   com. springsource. org . aopalliance-1.0.0.jar
   com. springsource .org . aspectj . weaver-1.6.8.RELEASE.jarspring- aop-4.0.0. RELEASE.jar
   spring- aspects-4.0.0. RELEASE. jar
   commons-1ogging-1.1.3.jar
   spring- beans-4.0.0. RELEASE .jarspring- context-4.0.0.RELEASE.jarspring- core-4.0.0.RELEASE.jar
   spring- expression-4.0.0. RELEASE.jar

2).在配置文件中加入aop的命名空间

3).基于注解的方式

⑨.在配置文件中加入如下
<aop :aspectj - autoproxy></aop: aspectj- autoproxy>
②.把横切关注点的代码抽象到切面的类中.
i. 切面首先是一个IOC中的bean, 即加入@Component 注解ii.切面还需要加入@Aspect注解
③.在类中声明各种通知:
i. 声明一个方法
ii.在方法前加入@Before注解

后置通知

后置通知是在连接点完成之后执行的, 即连接点返回结果或者抛出异常的时候, 下面的后置通知记录了方法的终止.
一个切面可以包括一个或者多个通知.
例子:在前面的基础上

///spring2/src/wo/LoggingAspect.java 加入//后置通知:在目标方法执行后(无论是否发生异常)，执行的通知.
//在后置通知中还不能访问目标方法执行的结果.
@After("execution(* wo.*.*(..))")public void afterMethod(JoinPoint joinPoint){String methodName = joinPoint.getSignature().getName();System.out.println("The method " + methodName + " ends");}

返回通知

无论连接点是正常返回还是抛出异常, 后置通知都会执行. 如果只想在连接点返回的时候记录日志, 应使用返回通知代替后置通知.
在返回通知中, 只要将 returning 属性添加到 @AfterReturning 注解中, 就可以访问连接点的返回值. 该属性的值即为用来传入返回值的参数名称.
必须在通知方法的签名中添加一个同名参数. 在运行时, Spring AOP 会通过这个参数传递返回值.
原始的切点表达式需要出现在 pointcut 属性中
例子:在前面的基础上

///spring2/src/wo/LoggingAspect.java 加入/*** 在方法法正常结束受执行的代码* 返回通知是可以访问到方法的返回值的!*/@AfterReturning(value="execution(* wo.*.*(..))",returning="result")public void afterReturning(JoinPoint joinPoint, Object result){String methodName = joinPoint.getSignature().getName();System.out.println("The method " + methodName + " ends with " + result);}

异常通知

只在连接点抛出异常时才执行异常通知
将 throwing 属性添加到 @AfterThrowing 注解中, 也可以访问连接点抛出的异常. Throwable 是所有错误和异常类的超类. 所以在异常通知方法可以捕获到任何错误和异常.
如果只对某种特殊的异常类型感兴趣, 可以将参数声明为其他异常的参数类型. 然后通知就只在抛出这个类型及其子类的异常时才被执行.
例子:在前面的基础上

///spring2/src/wo/LoggingAspect.java 加入/*** 在目标方法出现异常时会执行的代码.* 可以访问到异常对象; 且可以指定在出现特定异常时在执行通知代码*/@AfterThrowing(value="execution(* wo.*.*(..))",throwing="e")public void afterThrowing(JoinPoint joinPoint, Exception e){String methodName = joinPoint.getSignature().getName();System.out.println("The method " + methodName + " occurs excetion:" + e);}

环绕通知

环绕通知是所有通知类型中功能最为强大的, 能够全面地控制连接点. 甚至可以控制是否执行连接点.
对于环绕通知来说, 连接点的参数类型必须ProceedingJoinPoint . 它是 JoinPoint 的子接口, 允许控制何时执行, 是否执行连接点.
在环绕通知中需要明确调用 ProceedingJoinPoint 的 proceed() 方法来执行被代理的方法. 如果忘记这样做就会导致通知被执行了, 但目标方法没有被执行.
注意: 环绕通知的方法需要返回目标方法执行之后的结果, 即调用 joinPoint.proceed(); 的返回值, 否则会出现空指针异常
例子:在前面的基础上

///spring2/src/wo/LoggingAspect.java 加入
@Around("execution(* wo.*.*(..))")public Object aroundMethod(ProceedingJoinPoint pjd){Object result = null;String methodName = pjd.getSignature().getName();try {//前置通知System.out.println("The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));//执行目标方法result = pjd.proceed();//返回通知System.out.println("The method " + methodName + " ends with " + result);} catch (Throwable e) {//异常通知System.out.println("The method " + methodName + " occurs exception:" + e);throw new RuntimeException(e);}//后置通知System.out.println("The method " + methodName + " ends");return result;}

指定切面的优先级

在同一个连接点上应用不止一个切面时, 除非明确指定, 否则它们的优先级是不确定的.
切面的优先级可以通过实现 Ordered 接口或利用 @Order 注解指定.实现 Ordered 接口, getOrder() 方法的**返回值越小, 优先级越高.**若使用 @Order 注解, 序号出现在注解中

重用切入点定义

在编写 AspectJ 切面时, 可以直接在通知注解中书写切入点表达式. 但同一个切点表达式可能会在多个通知中重复出现.
在 AspectJ 切面中, 可以通过 @Pointcut 注解将一个切入点声明成简单的方法. 切入点的方法体通常是空的, 因为将切入点定义与应用程序逻辑混在一起是不合理的.
切入点方法的访问控制符同时也控制着这个切入点的可见性. 如果切入点要在多个切面中共用, 最好将它们集中在一个公共的类中. 在这种情况下, 它们必须被声明为 public. 在引入这个切入点时, 必须将类名也包括在内. 如果类没有与这个切面放在同一个包中, 还必须包含包名.
其他通知可以通过方法名称引入该切入点.
例子:在前面的基础上

///spring2/src/wo/LoggingAspect.java 
@Aspect
@Component
public class LoggingAspect {/*** 定义一个方法, 用于声明切入点表达式. 一般地, 该方法中再不需要添入其他的代码. * 使用 @Pointcut 来声明切入点表达式. * 后面的其他通知直接使用方法名来引用当前的切入点表达式. */@Pointcut("execution(* wo.*.*(..))")public void declareJointPointExpression(){}@Around("declareJointPointExpression()")//若不在一文件中需：x.declareJointPointExpression()public Object aroundMethod(ProceedingJoinPoint pjd){Object result = null;String methodName = pjd.getSignature().getName();try {//前置通知System.out.println("The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));//执行目标方法result = pjd.proceed();//返回通知System.out.println("The method " + methodName + " ends with " + result);} catch (Throwable e) {//异常通知System.out.println("The method " + methodName + " occurs exception:" + e);throw new RuntimeException(e);}//后置通知System.out.println("The method " + methodName + " ends");return result;}
}

_Spring_基于配置文件的方式来配置 AOP

例子：
相应的类改变如下

///spring2/src/wo/ArithmeticCalculatorImpl.java
package wo;import org.springframework.stereotype.Component;public class ArithmeticCalculatorImpl implements ArithmeticCalculator {@Overridepublic int add(int i, int j) {int result = i + j;return result;}@Overridepublic int sub(int i, int j) {int result = i - j;return result;}@Overridepublic int mul(int i, int j) {int result = i * j;return result;}@Overridepublic int div(int i, int j) {int result = i / j;return result;}
}
////////////////////////////////////////////////////////////////
////spring2/src/wo/LoggingAspect.java
package wo;import java.util.Arrays;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;public class LoggingAspect {public void beforeMethod(JoinPoint joinPoint){String methodName = joinPoint.getSignature().getName();Object [] args = joinPoint.getArgs();System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));}public void afterMethod(JoinPoint joinPoint){String methodName = joinPoint.getSignature().getName();System.out.println("The method " + methodName + " ends");}public void afterReturning(JoinPoint joinPoint, Object result){String methodName = joinPoint.getSignature().getName();System.out.println("The method " + methodName + " ends with " + result);}public void afterThrowing(JoinPoint joinPoint, Exception e){String methodName = joinPoint.getSignature().getName();System.out.println("The method " + methodName + " occurs excetion:" + e);}public Object aroundMethod(ProceedingJoinPoint pjd){Object result = null;String methodName = pjd.getSignature().getName();try {//前置通知System.out.println("The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));//执行目标方法result = pjd.proceed();//返回通知System.out.println("The method " + methodName + " ends with " + result);} catch (Throwable e) {//异常通知System.out.println("The method " + methodName + " occurs exception:" + e);throw new RuntimeException(e);}//后置通知System.out.println("The method " + methodName + " ends");return result;}
}
///////////////////////////////////////////////////////
//全局配置文件/spring2/src/applicationContext-aop.xml
<?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.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd"><!-- 配置 bean --><bean id="arithmeticCalculator" class="wo.ArithmeticCalculatorImpl"></bean><!-- 配置切面的 bean. --><bean id="loggingAspect"class="wo.LoggingAspect"></bean><!-- 配置 AOP --><aop:config><!-- 配置切点表达式 --><aop:pointcut expression="execution(* wo.ArithmeticCalculator.*(int, int))" id="pointcut"/><!-- 配置切面及通知 --><aop:aspect ref="loggingAspect" order="2">
<!--			<aop:before method="beforeMethod" pointcut-ref="pointcut"/>-->
<!--			<aop:after method="afterMethod" pointcut-ref="pointcut"/>-->
<!--			<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/>-->
<!--			<aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>-->
<!--			  --><aop:around method="aroundMethod" pointcut-ref="pointcut"/></aop:aspect>	</aop:config>
</beans>
////////////////////////////////////////////////////////////
//测试
public static void main(String[] args) {// TODO Auto-generated method stubApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-aop.xml");ArithmeticCalculator a = (ArithmeticCalculator) ctx.getBean("arithmeticCalculator");System.out.println(a.add(2, 3));System.out.println(a.div(2, 2));}