AOP 前奏
代码实现
Calculator.java
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);
}
CalculatorLogger.java
public class CalculatorLogger implements Calculator {
@Override
public int add(int i, int j) {
System.out.println("The method add with ["+i+" , "+j+"]");
int result = i + j;
System.out.println("The method add ends with"+ result);
return result;
}
@Override
public int sub(int i, int j) {
System.out.println("The method sub with ["+i+" , "+j+"]");
int result = i - j;
System.out.println("The method sub ends with"+ result);
return result;
}
@Override
public int mul(int i, int j) {
System.out.println("The method mul with ["+i+" , "+j+"]");
int result = i * j;
System.out.println("The method mul ends with"+ result);
return result;
}
@Override
public int div(int i, int j) {
System.out.println("The method div with ["+i+" , "+j+"]");
int result = i / j;
System.out.println("The method div ends with"+ result);
return result;
}
}
public class ApplicationBasic {
public static void main(String[] args) {
Calculator calculator = null;
calculator = new CalculatorLogger();
int result = calculator.add(3, 2);
System.out.println("-->"+result);
result = calculator.div(9, 3);
System.out.println("-->"+result);
}
}
测试结果:
上述实现问题:
- 代码混乱:越来越多的非业务需求(日志和验证等)加入后,原有的业务方法急剧膨胀. 每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点.
- 代码分散: 以日志需求为例, 只是为了满足这个单一需求, 就不得不在多个模块(方法)里多次重复相同的日志代码.如果日志需求发生变化, 必须修改所有模块.
使用动态代理解决上述问题
- 代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上.
代码实现:
CalculatorLogger.java
public class CalculatorLogger implements Calculator {
@Override
public int add(int i, int j) {
int result = i + j;
return result;
}
@Override
public int sub(int i, int j) {
int result = i - j;
return result;
}
@Override
public int mul(int i, int j) {
int result = i * j;
return result;
}
@Override
public int div(int i, int j) {
int result = i / j;
return result;
}
}
CalculatorLoggerProxy.java
/**
*
* @ClassName: CalculatorLoggerProxy
* @Description:动态代理实现AOP
* @author: xyc
* @date: 2016年12月24日 下午8:25:01
*
*/
public class CalculatorLoggerProxy {
//要代理的对象
private Calculator target;
public CalculatorLoggerProxy(Calculator target) {
this.target = target;
}
public Calculator getLoggerProxy(){
Calculator proxy = null;
//打理对象由哪一个类加载器加载
ClassLoader loader = target.getClass().getClassLoader();
//代理对象的类型,即其中有那些方法
Class[] interfaces = new Class[]{Calculator.class};
//当调用代理对象其中的方法时,该执行的代码
InvocationHandler h = new InvocationHandler() {
/**
*
* <p>Title: invoke</p>
* <p>Description: </p>
* @param proxy 正在返回的那个代理对象,一般情况下,在invoke方法中不使用该对象
* @param method 正在被调用的那个方法
* @param args 调用方法时,传递的参数
* @return
* @throws Throwable
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
//执行方法
Object result = null ;
try {
//前置通知
System.out.println("The method "+methodName+" with "+Arrays.asList(args));
result = method.invoke(target, args);
//返回通知
} catch (Exception e) {
//异常通知
}
//后置通知
System.out.println("The method "+result+" ends with"+ result);
return result;
}
};
proxy = (Calculator) Proxy.newProxyInstance(loader, interfaces, h);
return proxy;
}
}
ApplicationProxy.java
public class ApplicationProxy {
public static void main(String[] args) {
CalculatorLogger calculatorLogger = new CalculatorLogger();
Calculator proxy = new CalculatorLoggerProxy(calculatorLogger).getLoggerProxy();
int result = proxy.add(3, 2);
System.out.println("-->"+result);
result = proxy.div(9, 3);
System.out.println("-->"+result);
}
}
测试结果:
好了,说了这么多,到底什么是Aop?
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
AspectJ 支持 5 种类型的通知注解:
@Before: 前置通知, 在方法执行之前执行
@After: 后置通知, 在方法执行之后执行
@AfterRunning: 返回通知, 在方法返回结果之后执行
@AfterThrowing: 异常通知, 在方法抛出异常之后
@Around: 环绕通知, 围绕着方法执行
在 Spring 中启用 AspectJ 注解支持
①.引入依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.2.RELEASE<version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.6.11</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.11</version>
</dependency>
②要在 Spring IOC 容器中启用 AspectJ 注解支持, 只要在 Bean 配置文件中定义一个空的 XML 元素 <aop:aspectj-autoproxy> 当 Spring IOC 容器侦测到 Bean 配置文件中的 <aop:aspectj-autoproxy> 元素时, 会自动为与 AspectJ 切面匹配的 Bean 创建代理.
③.在切面类中使用@Aspect,然后在类中声明各种通知
④.可以在通知方法中声明一个类型为JoinPoint的参数,然后就能访问链接明细,如方法名称和参数
⑤.切入点表达式根据方法的签名来匹配各种方法(execution(* com.xyc.spring.aop.CalculatorLogger.*(..) ) 第一个 * 代表任意修饰符及任意返回值. 第二个 * 代表任意方法. .. 匹配任意数量的参数
⑥.在 AspectJ 中, 切入点表达式可以通过操作符 &&, ||, ! 结合起来. (execution(* com.xyc.spring.aop.CalculatorLogger.add(..) || execution(* com.xyc.spring.aop.CalculatorLogger.div(..))
前置通知:
- 前置通知:在方法执行之前执行的通知
- 前置通知使用 @Before 注解, 并将切入点表达式的值作为注解值.
/**
*
* @ClassName: LoggerAspectJ
* @Description:把这个类声明为一个切面:需要先将该类放入到IOC容器中,然后在声明为切面
* @author: xyc
* @date: 2016年12月24日 下午6:04:05
*
*/
@Component
@Aspect
public class LoggerAspectJ {
/**
*
* @Title: beforeMethod
* @Description: 声明该方法是一个前置通知:在目标方法之前执行
* @param: @param joinPoint
* @return: void
* @throws
*/
@Before("execution(* com.xyc.spring.aop.Calculator.*(..))")
public void beforeMethod(JoinPoint joinPoint){
System.out.println("This is 前置通知");
}
}
后置通知:
- 后置通知是在连接点完成之后执行的, 即连接点返回结果或者抛出异常的时候, 下面的后置通知记录了方法的终止.
- 一个切面可以包括一个或者多个通知.
/**
*
* @ClassName: LoggerAspectJ
* @Description:把这个类声明为一个切面:需要先将该类放入到IOC容器中,然后在声明为切面
* @author: xyc
* @date: 2016年12月24日 下午6:04:05
*
*/
@Component
@Aspect
public class LoggerAspectJ {
/**
*
* @Title: afterMethod
* @Description: 后置通知:在目标方法执行后执行(无论执行目标方法过程中是否发生异常都会执行),执行的通知
* @param: @param joinPoint
* @return: void
* @throws
*/
@After("execution(* com.xyc.spring.aop.Calculator.*(..))")
public void afterMethod(JoinPoint joinPoint){
System.out.println("This is 后置通知");
}
}
返回通知:
- 无论连接点是正常返回还是抛出异常, 后置通知都会执行. 如果只想在连接点返回的时候记录日志, 应使用返回通知代替后置通知.
- 在返回通知中, 只要将 returning 属性添加到 @AfterReturning 注解中, 就可以访问连接点的返回值. 该属性的值即为用来传入返回值的参数名称.
- 必须在通知方法的签名中添加一个同名参数. 在运行时, Spring AOP 会通过这个参数传递返回值.
- 原始的切点表达式需要出现在 pointcut 属性中
/**
*
* @Title: afterReturning
* @Description: 在方法正常结束后执行的代码 返回通知是可以访问到方法的返回值的
* @param: @param joinPoint
* @param: @param result
* @return: void
* @throws
*/
@AfterReturning(value="execution(* com.xyc.spring.aop.Calculator.*(..))",returning="result")
public void afterReturning(JoinPoint joinPoint,Object result){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" result "+result);
}
异常通知:
- 只在连接点抛出异常时才执行异常通知
- 将 throwing 属性添加到 @AfterThrowing 注解中, 也可以访问连接点抛出的异常. Throwable 是所有错误和异常类的超类. 所以在异常通知方法可以捕获到任何错误和异常.
- 如果只对某种特殊的异常类型感兴趣, 可以将参数声明为其他异常的参数类型. 然后通知就只在抛出这个类型及其子类的异常时才被执行.
/**
*
* @Title: afterThrowing
* @Description: 在目标方法出现异常时会执行的代码 可以访问到异常对象,切可以指定在出现特定异常时再执行通知代码
* @param: @param joinPoint
* @param: @param e
* @return: void
* @throws
*/
@AfterThrowing(value="execution(* com.xyc.spring.aop.Calculator.*(..))",throwing="e")
public void afterThrowing(JoinPoint joinPoint,Exception e){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method "+methodName+" Exception "+e);
}
环绕通知:
- 环绕通知是所有通知类型中功能最为强大的, 能够全面地控制连接点. 甚至可以控制是否执行连接点.
- 对于环绕通知来说, 连接点的参数类型必须是 ProceedingJoinPoint . 它是 JoinPoint 的子接口, 允许控制何时执行, 是否执行连接点.
- 在环绕通知中需要明确调用 ProceedingJoinPoint 的 proceed() 方法来执行被代理的方法. 如果忘记这样做就会导致通知被执行了, 但目标方法没有被执行.
- 注意: 环绕通知的方法需要返回目标方法执行之后的结果, 即调用 joinPoint.proceed(); 的返回值, 否则会出现空指针异常
/**
*
* @Title: around
* @Description: 环绕通知需要携带 ProceedingJoinPoint 类型的参数
* 环绕通知类似于动态代理的全过程,ProceedingJoinPoint 类型的参数可以决定是否执行目标方法.
* 且环绕通知必须有返回值,返回值即为目标方法的返回值
* @param: @param pjp
* @param: @return
* @return: Object
* @throws
*/
@Around("execution(* com.xyc.spring.aop.Calculator.*(..))")
public Object around(ProceedingJoinPoint pjp){
Object result = null;
String methodName = pjp.getSignature().getName();
try {
//前置通知、
System.out.println("The method "+methodName+" with "+Arrays.asList(pjp.getArgs()));
//执行目标方法
result = pjp.proceed();
//返回通知
System.out.println("The method "+methodName+" result "+result);
} catch (Throwable e) {
//异常通知
System.out.println("The method "+methodName+" Exception "+e);
throw new RuntimeException(e);
}
//后置通知
System.out.println("The method "+methodName+" end ");
return result;
}
AOP实现前奏需求:
LoggerAspectJ.java
package com.xyc.spring.aop;
import java.util.Arrays;
import java.util.List;
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;
/**
*
* @ClassName: LoggerAspectJ
* @Description:把这个类声明为一个切面:需要先将该类放入到IOC容器中,然后在声明为切面
* @author: xyc
* @date: 2016年12月24日 下午6:04:05
*
*/
@Component
@Aspect
public class LoggerAspectJ {
/**
*
* @Title: beforeMethod
* @Description: 声明该方法是一个前置通知:在目标方法之前执行
* @param: @param joinPoint
* @return: void
* @throws
*/
@Before("execution(* com.xyc.spring.aop.Calculator.*(int, int))")
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+" with "+args);
}
/**
*
* @Title: afterMethod
* @Description: 后置通知:在目标方法执行后执行(无论执行目标方法过程中是否发生异常都会执行),执行的通知
* @param: @param joinPoint
* @return: void
* @throws
*/
@After("execution(* com.xyc.spring.aop.Calculator.*(int, int))")
public void afterMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
//在后置通知中不能访问目标方法执行的结果
System.out.println("The method "+methodName+" end ");
}
}
ApplicationAop.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.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<!-- 配置自动扫描包 -->
<context:component-scan base-package="com.xyc.spring.aop"></context:component-scan>
<!-- 使用aspectj注解起作用:自动为匹配的类生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
/**
*
* @ClassName: ApplicationAop
* @Description:测试AOP
* @author: xyc
* @date: 2016年12月24日 下午6:12:59
*
*/
public class ApplicationAop {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationAop.xml");
Calculator bean = context.getBean(Calculator.class);
int result = bean.add(3, 2);
System.out.println("-->"+result);
result = bean.div(9, 3);
System.out.println("-->"+result);
}
}
测试结果:切面的优先级
- 在同一个连接点上应用不止一个切面时, 除非明确指定, 否则它们的优先级是不确定的.
- 切面的优先级可以通过实现 Ordered 接口或利用 @Order 注解指定.
- 实现 Ordered 接口, getOrder() 方法的返回值越小, 优先级越高.
- 若使用 @Order 注解, 序号出现在注解中
@Order(2)
@Aspect
@Component
public class LoggerAspectJ {}
@Order(1)
@Aspect
@Component
public class ViladationAspectj {}
重用切入点定义
- 在编写 AspectJ 切面时, 可以直接在通知注解中书写切入点表达式. 但同一个切点表达式可能会在多个通知中重复出现.
- 在 AspectJ 切面中, 可以通过 @Pointcut 注解将一个切入点声明成简单的方法. 切入点的方法体通常是空的, 因为将切入点定义与应用程序逻辑混在一起是不合理的.
- 切入点方法的访问控制符同时也控制着这个切入点的可见性. 如果切入点要在多个切面中共用, 最好将它们集中在一个公共的类中. 在这种情况下, 它们必须被声明为 public. 在引入这个切入点时, 必须将类名也包括在内. 如果类没有与这个切面放在同一个包中, 还必须包含包名.
- 其他通知可以通过方法名称引入该切入点.
同一个类中,只需要引入方法名称.
/**
*
* @Title: declareJoinPointExpression
* @Description: 定义一个方法,声明切入点表达式,该方法不需要其他代码
* @param:
* @return: void
* @throws
*/
@Pointcut("execution(* com.xyc.spring.aop.Calculator.*(..))")
public void declareJoinPointExpression(){}
@Before("declareJoinPointExpression()")
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+" with "+args);
}
同包不同类中,需要类名.方法@Before("LoggerAspectJ.declareJoinPointExpression()")
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("--->ViladationAspectj "+methodName+" with "+args);
}
不同包下,需要全类名.方法
@Before("com.xyc.spring.aop.LoggerAspectJ.declareJoinPointExpression()")
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("--->ViladationAspectj "+methodName+" with "+args);
}