一、什么是AOP
AOP: 对OOP的补充。一般处理非业务代码,如处理日志等,因为这种功能才具备复用性。
假设我们有四个方法,每个方法里面都含有function
这个功能,功能是类似的,那么就需要重复写4次该功能, 降低了代码的复用性。因此可以将改功能提取出来,做成一个切面。
因此可以将改功能提取出来,做成一个切面。
把切面aspect
抽象出来,行成一个对象function
,这==一个对象就表示四个切面。
AOP在spring中又叫“面向切面编程”,它可以说是对传统我们面向对象编程的一个补充,从字面上顾名思义就可以知道,它的主要操作对象就是==“切面”==,所以我们就可以简单的理解它是贯穿于方法之中,在方法执行前、执行时、执行后、返回值后、异常后要执行的操作。
相当于是将我们原本一条线执行的程序在中间切开加入了一些其他操作一样。
在应用AOP编程时,仍然需要定义公共功能,但可以明确的定义这个功能应用在哪里,以什么方式应用,并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的类里——这样的类我们通常就称之为“切面”。
例如下面这个图就是一个AOP切面的模型图,是在某一个方法执行前后执行的一些操作,并且这些操作不会影响程序本身的运行。
二、AOP概念
1.相关术语
术语 | 含义 |
---|---|
横切关注点 | 从每个方法中抽取出来的同一类非核心业务 |
切面(Aspect) | 封装横切关注点信息的类,每个关注点体现为一个通知方法。 |
通知(Advice) | 切面必须要完成的各个具体工作 |
目标(Target) | 被通知的对象 |
代理(proxy) | 向目标对象应用通知之后创建的代理对象 |
连接点(Joinpoint) | 横切关注点在程序代码中的具体体现,对应程序执行的某个特定位置。 |
切入点(pointcut) | 执行或找到连接点的一些方式 |
2.重要的术语
- 切面Aspect:跨多个类的关注点的模块化。事务管理是企业 Java 应用程序中横切关注点的一个很好的例子。在 Spring AOP 中,方面是通过使用常规类(基于模式的方法)或使用注释进行注释的常规类
@Aspect
(@AspectJ 风格)来实现的。 - 连接点Join point:程序执行过程中的点,例如方法的执行或异常的处理。在 Spring AOP 中,连接点始终代表方法执行。
- 通知Advice:某个方面在特定连接点采取的操作。通常使用
@Around
:环绕通知,围绕着方法执行。 - 切入点Pointcut:匹配连接点的谓词。建议与切入点表达式关联,并在与切入点匹配的任何连接点运行(例如,执行具有特定名称的方法)。与切入点表达式匹配的连接点的概念是 AOP 的核心,Spring 默认使用 AspectJ 切入点表达式语言。
3.五种通知注解
首先要在Spring中声明AspectJ切面
,只需要在IOC容器中将切面声明为bean实例。
当在Spring IOC容器中初始化AspectJ切面之后,Spring IOC容器就会为那些与 AspectJ切面相匹配的bean创建代理。
在AspectJ注解中,切面只是一个带有@Aspect
注解的Java类,它往往要包含很多通知。通知是标注有某种注解的简单的Java方法。
AspectJ支持5种类型的通知注解:
@Before
:前置通知,在方法执行之前执行@After
:后置通知,在方法执行之后执行@AfterRunning
:返回通知,在方法返回结果之后执行@AfterThrowing
:异常通知,在方法抛出异常之后执行@Around
:环绕通知,围绕着方法执行
三、切入点表达式
1.功能
用来指定哪一个切面方法在哪一个方法执行时触发。那么具体操作是怎么样的呢?
我们就可以通过表达式的方式定位一个或多个具体的连接点(Joinpoint),
2.语法格式规范
execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名] ([参数列表]))
其中在表达式中有两个常用的特殊符号:
星号“ * ”代表所有的意思,星号还可以表示任意的数值类型
“.”号:“…”表示任意类型,或任意路径下的文件,`
3.举例
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类型的方法
*/
execution("* *(…)")
/*
!!! 慎用 !!!
**表示任意包下任意类的任意方法**
*/
同时,在AspectJ中,切入点表达式可以通过 “&&”、“||”、“!”等操作符结合起来。
execution (* _.add(int,…)) || execution(_ *.sub(int,…))
/*
!!! 慎用 !!!
表示任意类中第一个参数为int类型的add方法或sub方法
*/
四、注解实践
1.切面类应用
将切入点表达式应用到实际的切面类中如下:
@Aspect //切面注解
@Component //其他业务层
public class LogUtli {
// 方法执行开始,表示目标方法是com.spring.inpl包下的任意类的任意以两个int为参数,返回int类型参数的方法
@Before("execution(public int com.spring.inpl.*.*(int, int))")
public static void LogStart(JoinPoint joinPoint) {
System.out.println("通知记录开始...");
}
// 方法正常执行完之后
/**
* 在程序正常执行完之后如果有返回值,我们可以对这个返回值进行接收
* returning用来接收方法的返回值
* */
@AfterReturning(pointcut="public int com.spring.inpl.*.*(int, int)",returning="result")
public static void LogReturn(JoinPoint joinPoint,Object result) {
System.out.println("【" + joinPoint.getSignature().getName() + "】程序方法执行完毕了...结果是:" + result);
}
}
以上只是一个最简单的通知方法,但是在实际的使用过程中我们可能会将多个通知方法切入到同一个目标方法上去,比如同一个目标方法上既有前置通知、又有异常通知和后置通知。
但是这样我们也只是在目标方法执行时切入了一些通知方法,那么我们能不能在通知方法中获取到执行的目标方法的一些信息呢?当然是可以的。
2.JoinPoint获取方法信息
在这里我们就可以使用JoinPoint接口来获取到目标方法的信息,如方法的返回值、方法名、参数类型等。
如我们在方法执行开始前,获取到该目标方法的方法名和输入的参数并输出。
// 方法执行开始
@Before("execution(public int com.spring.inpl.*.*(int, int))")
public static void LogStart(JoinPoint joinPoint) {
Object[] args = joinPoint.getArgs(); //获取到参数信息
Signature signature = joinPoint.getSignature(); //获取到方法签名
String name = signature.getName(); //获取到方法名
System.out.println("【" + name + "】记录开始...执行参数:" + Arrays.asList(args));
}
3.接收方法的返回值和异常信息
对于有些目标方法在执行完之后可能会有返回值,或者方法中途异常抛出,那么对于这些情况,我们应该如何获取到这些信息呢?
首先我们来获取当方法执行完之后获取返回值,
在这里我们可以使用@AfterReturning
注解,该注解表示的通知方法是在目标方法正常执行完之后执行的。
在返回通知中,只要将returning属性
添加到@AfterReturning
注解中,就可以访问连接点的返回值。
// 方法正常执行完之后
/**
* 在程序正常执行完之后如果有返回值,我们可以对这个返回值进行接收
* returning用来接收方法的返回值
* */
@AfterReturning(pointcut="public int com.spring.inpl.*.*(int, int)",returning="result")
public static void LogReturn(JoinPoint joinPoint,Object result) {
System.out.println("【" + joinPoint.getSignature().getName() + "】程序方法执行完毕了...结果是:" + result);
}
对于接收异常信息,方法其实是一样的。
我们需要将throwing属性
添加到@AfterThrowing
注解中,也可以访问连接点抛出的异常。
Throwable
是所有错误和异常类的顶级父类,所以在异常通知方法可以捕获到任何错误和异常。
// 异常抛出时
/**
* 在执行方法想要抛出异常的时候,可以使用throwing在注解中进行接收,
* 其中value指明执行的全方法名
* throwing指明返回的错误信息
* */
@AfterThrowing(pointcut="public int com.spring.inpl.*.*(int, int)",throwing="e")
public static void LogThowing(JoinPoint joinPoint,Object e) {
System.out.println("【" + joinPoint.getSignature().getName() +"】发现异常信息...,异常信息是:" + e);
}
五、环绕通知
环绕通知是所有通知类型中功能最为强大的,能够全面地控制连接点,甚至可以控制是否执行连接点。
对于环绕通知来说,连接点的参数类型必须是ProceedingJoinPoint
。它是 JoinPoint的子接口
,允许控制何时执行,是否执行连接点。
在环绕通知中需要明确调用ProceedingJoinPoint
的proceed()
方法来执行被代理的方法。
如果忘记这样做就会导致通知被执行了,但目标方法没有被执行。
这就意味着我们需要在方法中传入参数ProceedingJoinPoint
来接收方法的各种信息。
/**
* 环绕通知方法
* 使用注解@Around()
* 需要在方法中传入参数proceedingJoinPoint 来接收方法的各种信息
* 使用环绕通知时需要使用proceed方法来执行方法
* 同时需要将值进行返回,环绕方法会将需要执行的方法进行放行
* *********************************************
* @throws Throwable
* */
@Around("public int com.spring.inpl.*.*(int, int)")
public Object MyAround(ProceedingJoinPoint pjp) throws Throwable {
// 获取到目标方法内部的参数
Object[] args = pjp.getArgs();
System.out.println("【方法执行前】");
// 获取到目标方法的签名
Signature signature = pjp.getSignature();
String name = signature.getName();
Object proceed = null;
try {
// 进行方法的执行
proceed = pjp.proceed();
System.out.println("方法返回时");
} catch (Exception e) {
System.out.println("方法异常时" + e);
}finally{
System.out.println("后置方法");
}
//将方法执行的返回值返回
return proceed;
}
六、通知注解的执行顺序
在正常情况下执行:
@Before(前置通知)—>@After(后置通知)---->@AfterReturning(返回通知)
在异常情况下执行:
@Before(前置通知)—>@After(后置通知)---->@AfterThrowing(异常通知)
当普通通知和环绕通知同时执行时:
环绕前置----普通前置----环绕返回/异常----环绕后置----普通后置----普通返回/异常
七、重用切入点定义
对于上面的通知注解,我们都是在每一个通知注解上都定义了一遍切入点表达式,
但是试想一个问题,如果我们不想给这个方法设置通知方法了,或者我们想要将这些通知方法切入到另一个目标方法,那么我们岂不是要一个一个的更改注解中的切入点表达式吗?这样也太麻烦了吧?
所以spring就想到了一个办法,重用切入点表达式。
也就是说将这些会重复使用的切入点表达式用一个方法来表示,那么我们的通知注解只需要调用这个使用了该切入点表达式的方法即可实现和之前一样的效果,这样的话,我们即使想要更改切入点表达式的接入方法,也不用一个一个的去通知注解上修改了。
获取可重用的切入点表达式的方法是:
- 随便定义一个void的无实现的方法
- 为方法添加注解@Pointcut()
- 在注解中加入抽取出来的可重用的切入点表达式
- 使用value属性将方法加入到对应的切面函数的注解中
@Aspect //切面注解
@Component //其他业务层
public class LogUtli {
/**
* 定义切入点表达式的可重用方法
* */
@Pointcut("execution(public int com.spring.inpl.MyMathCalculator.*(int, int))")
public void MyCanChongYong() {}
// 方法执行开始
@Before("MyCanChongYong()")
public static void LogStart(JoinPoint joinPoint) {
Object[] args = joinPoint.getArgs(); //获取到参数信息
Signature signature = joinPoint.getSignature(); //获取到方法签名
String name = signature.getName(); //获取到方法名
System.out.println("【" + name + "】记录开始...执行参数:" + Arrays.asList(args));
}
// 方法正常执行完之后
/**
* 在程序正常执行完之后如果有返回值,我们可以对这个返回值进行接收
* returning用来接收方法的返回值
* */
@AfterReturning(value="MyCanChongYong()",returning="result")
public static void LogReturn(JoinPoint joinPoint,Object result) {
System.out.println("【" + joinPoint.getSignature().getName() + "】程序方法执行完毕了...结果是:" + result);
}
// 异常抛出时
/**
* 在执行方法想要抛出异常的时候,可以使用throwing在注解中进行接收,
* 其中value指明执行的全方法名
* throwing指明返回的错误信息
* */
@AfterThrowing(value="MyCanChongYong()",throwing="e")
public static void LogThowing(JoinPoint joinPoint,Object e) {
System.out.println("【" + joinPoint.getSignature().getName() +"】发现异常信息...,异常信息是:" + e);
}
// 结束得出结果
@After(value = "execution(public int com.spring.inpl.MyMathCalculator.add(int, int))")
public static void LogEnd(JoinPoint joinPoint) {
System.out.println("【" + joinPoint.getSignature().getName() +"】执行结束");
}
/**
* 环绕通知方法
* @throws Throwable
* */
@Around("MyCanChongYong()")
public Object MyAround(ProceedingJoinPoint pjp) throws Throwable {
// 获取到目标方法内部的参数
Object[] args = pjp.getArgs();
System.out.println("【方法执行前】");
// 获取到目标方法的签名
Signature signature = pjp.getSignature();
String name = signature.getName();
Object proceed = null;
try {
// 进行方法的执行
proceed = pjp.proceed();
System.out.println("方法返回时");
} catch (Exception e) {
System.out.println("方法异常时" + e);
}finally{
System.out.println("后置方法");
}
//将方法执行的返回值返回
return proceed;
}
}
参考:
https://bbs.huaweicloud.com/blogs/289045