1 AOP的几个核心技术
AOP-面向切面编程的实现的核心技术:jvm运行期间对字节码进行修改或者动态生成新的字节码文件(asm技术)。
2 AOP的几个核心概念
AOP在运行期间我们要对class文件做修改或者生成新的。AOP就定义了一套规范,包括了切面、切点、连接点、通知、织入等等这些内容。
(1)连接点(Join point):指程序运行过程中所执行的方法。在Spring AOP中,一个连接点总代表一个方法的执行。
(2)切面(Aspect):被抽取出来的公共模块,可以用来横切多个对象。Aspect切面可以看成 Pointcut切点 和 Advice通知 的结合,一个切面可以由多个切点和通知组成。在Spring AOP中,切面可以在类上使用 @AspectJ 注解来实现。
(3)切点(Pointcut):切点用于定义 要对哪些Join point进行拦截。切点分为execution方式和annotation方式。execution方式可以用路径表达式指定对哪些方法拦截,比如指定拦截add*、search*。annotation方式可以指定被哪些注解修饰的代码进行拦截。
(4)通知(Advice):指要在连接点(Join Point)上执行的动作,即增强的逻辑,比如权限校验和、日志记录等。通知有各种类型,包括Around、Before、After、After returning、After throwing。
(5)目标对象(Target):包含连接点的对象,也称作被通知(Advice)的对象。 由于Spring AOP是通过动态代理实现的,所以这个对象永远是一个代理对象。
(6)织入(Weaving):通过动态代理,在目标对象(Target)的方法(即连接点Join point)中执行增强逻辑(Advice)的过程。
(7)引入(Introduction):添加额外的方法或者字段到被通知的类。Spring允许引入新的接口(以及对应的实现)到任何被代理的对象。例如,你可以使用一个引入来使bean实现 IsModified 接口,以便简化缓存机制。
3 通知
3.1 前置通知
前置通知:在方法执行之前执行的通知。前置通知使用 @Before 注解, 并将切入点表达式的值作为注解值.
@Before("declareJoinPointExpression()")
public void beforMethod(JoinPoint joinPoint){
/*获取方法名*/
String methodName = joinPoint.getSignature().getName();
/*获取方法的参数*/
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+" begins with"+args);
}
外部类切入点表达式方法引用如下:
使用类全路径+方法名
@Before("com.web.aop.LogAspects.pointCut()")
public void logEnd(JoinPoint joinPoint){
System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
}
3.2 后置通知
后置通知:在目标方法执行后执行,无论是否抛出异常。后置通知中不能访问目标方法执行后返回的结果。
@After("execution(* com.web.aop.impl.*.*(int , int ))")
/*表示该包下所有返回类型的所有类的所有方法*/
public void afterMethod(JoinPoint joinPoint){
/*获取方法名*/
String methodName = joinPoint.getSignature().getName();
/*获取方法的参数*/
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+" ends with"+args);
}
3.3 返回通知
返回通知 :在方法正常执行返回结果后执行,返回通知可以获取目标方法的返回值。
在返回通知中, 只要将 returning 属性添加到 @AfterReturning 注解中, 就可以访问连接点的返回值。 该属性的值即为用来传入返回值的参数名称。
必须在通知方法的签名中添加一个同名参数,在运行时Spring AOP 会通过这个参数传递返回值。
原始的切点表达式需要出现在 pointcut 属性中。
@AfterReturning(pointcut="execution(* com.web.aop.impl.*.*(int , int ))",returning="result")
/*表示该包下所有返回类型的所有类的所有方法*/
public void afterReturning(JoinPoint joinPoint ,Object result){
/*获取方法名*/
String methodName = joinPoint.getSignature().getName();
/*获取方法的参数*/
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+" ends with "+result);
}
3.4 异常通知
在方法抛出异常后执行,可以访问到异常对象。且可以指定在出现特定异常对象时,再执行。
只在连接点抛出异常时才执行异常通知
将 throwing 属性添加到 @AfterThrowing 注解中, 也可以访问连接点抛出的异常.
Throwable 是所有错误和异常类的超类. 所以在异常通知方法可以捕获到任何错误和异常.
如果只对某种特殊的异常类型感兴趣, 可以将参数声明为其他异常的参数类型. 然后通知就只在抛出这个类型及其子类的异常时才被执行。
@AfterThrowing(value="execution(* com.web.aop.impl.*.*(int , int ))",throwing="exception")
/*表示该包下所有返回类型的所有类的所有方法*/
public void afterThrowing(JoinPoint joinPoint ,Exception exception){
/*获取方法名*/
String methodName = joinPoint.getSignature().getName();
/*获取方法的参数*/
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method "+methodName+" throws exception :"+exception);
}
3.5 环绕通知
环绕通知是所有通知类型中功能最为强大的, 能够全面地控制连接点. 甚至可以控制是否执行连接点.动态代理,手动推进目标方法运行(joinPoint.procced())
环绕通知需要携带ProceedingJoinPoint类型的参数;
环绕通知类似于动态代理的全过程:ProceedingJoinPoint类型的参数可以决定是否执行目标方法;
环绕通知必须有返回值,返回值即为目标方法的返回值 !
对于环绕通知来说, 连接点的参数类型必须是 ProceedingJoinPoint 。它是 JoinPoint 的子接口, 允许控制何时执行, 是否执行连接点。
在环绕通知中需要明确调用 ProceedingJoinPoint 的 proceed() 方法来执行被代理的方法。 如果忘记这样做就会导致通知被执行了, 但目标方法没有被执行。
注意: 环绕通知的方法需要返回目标方法执行之后的结果, 即调用 joinPoint.proceed() 的返回值, 否则会出现空指针异常。
@Around("execution(* com.web.aop.impl.*.*(int , int ))")
/*表示该包下所有返回类型的所有类的所有方法*/
public Object aroundMethod(ProceedingJoinPoint joinPoint){
System.out.println("This is aroundMethod....");
/*获取方法名*/
String methodName = joinPoint.getSignature().getName();
/*获取方法的参数*/
List<Object> args = Arrays.asList(joinPoint.getArgs());
Object result = null;
try {
//前置通知
System.out.println("The method "+methodName+" begins with :"+args);
result = joinPoint.proceed();
//返回通知
System.out.println();
System.out.println("The method "+methodName+" ends with :"+result);
} catch (Throwable e) {
// 异常通知
System.out.println("The method "+methodName+" throws exception :"+e);
throw new RuntimeException(e);
}
//后置通知
System.out.println("The method "+methodName+" ends ");
return result;
}
3.6 切点的表达式
4 AOP的执行过程
具体顺序
1)从chain取出around通知对象,执行自定义的aorund通知方法前置通知内容(Object proceed = joinPoint.proceed()之前的内容)
2)从chain取出before通知对象,执行自定义的before通知方法
3)从chain取出after通知对象
4)从chain取出afterreturning通知对象
5)从chain取出atferthrowing通知对象
6)执行连接点的逻辑方法
7)执行自定义的afterthrowing的通知方法(没有异常不会执行)
8)执行自定义的afterreturning的通知方法
9)执行自定义的afterre的通知方法
10)继续执行自定义的around通知方法,执行后置通知内容(Object proceed = joinPoint.proceed()之后的内容)
5 测试代码(配合上图看)
5.1 切面
@Component
@Aspect
public class AopLogUtils {
@Pointcut("execution(public * com.ruoyi.weixin.user.AopTest.AopTestServiceImpl.test(..)))")
public void myPointCut(){};
@Around(value = "myPointCut()")
public Object doAround(ProceedingJoinPoint joinPoint)
{
int result = 0;
try {
System.out.println("doAround 前面执行");
Object proceed = joinPoint.proceed();
System.out.println("doAround 后面执行");
}catch (Throwable t){
System.out.println("doAround 出错");
}finally {
System.out.println("doAround finally执行");
}
return result;
}
@Before(value = "myPointCut()")
public void doBefore(JoinPoint joinPoint)
{
System.out.println("doBefore 执行");
}
@After(value = "myPointCut()")
public void doAfter(JoinPoint joinPoint)
{
System.out.println("doAfter 执行");
}
@AfterReturning(value = "myPointCut()",returning = "jsonResult")
public void doAfterReturning(JoinPoint joinPoint, Object jsonResult)
{
System.out.println("doAfterReturning 执行");
}
@AfterThrowing(value = "myPointCut()", throwing = "e")
public void doAfterThrowing(JoinPoint joinPoint, Exception e)
{
System.out.println("AfterThrowing 执行");
}
}
5.2 业务代码
public interface AopTestService {
void test();
}
@Service("aoptestservice")
public class AopTestServiceImpl implements AopTestService{
@Override
public void test(){
System.out.println("asdf");
}
}
@RestController
public class MyAopTest {
@Autowired
@Qualifier("aoptestservice")
private AopTestService aoptestservice;
@GetMapping("/lj_weixin/aoptest")
public void test(){
aoptestservice.test();
}
5.3 执行调用debug
进入controller,我们看一下aoptestservice,发现它是一个代理对象
看它的属性,里面有一个CALLBACK数组
class CglibAopProxy implements AopProxy, Serializable {
2 public static class SerializableNoOp implements NoOp, Serializable {}
private static class StaticUnadvisedInterceptor implements MethodInterceptor, Serializable {}
1 private static class StaticUnadvisedExposedInterceptor implements MethodInterceptor, Serializable {}
private static class DynamicUnadvisedInterceptor implements MethodInterceptor, Serializable {}
private static class DynamicUnadvisedExposedInterceptor implements MethodInterceptor, Serializable {}
3 private static class StaticDispatcher implements Dispatcher, Serializable {}
4 private static class AdvisedDispatcher implements Dispatcher, Serializable {}
5 private static class EqualsInterceptor implements MethodInterceptor, Serializable {}
6 private static class HashCodeInterceptor implements MethodInterceptor, Serializable {}
private static class FixedChainStaticTargetInterceptor implements MethodInterceptor, Serializable {}
0 private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {}
private static class CglibMethodInvocation extends ReflectiveMethodInvocation {}
private static class ProxyCallbackFilter implements CallbackFilter {}
}
6 f7进入方法来到CglibAopProxy.java里面的内部类DynamicAdvisedInterceptor的intercept方法
和上面的CALLBACK数组的元素比对,发现它的0号元素就是DynamicAdvisedInterceptor
往下执行,一直到下面代码执行完
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
chain是一个集合,里面存储了通知对象,我们可以看到,一共有6个元素。
但是我们实际上只定义了5个通知,多了一个元素0号元素:ExposeInvocationInterceptor
1-5号元素就是我们定义的通知:它们的顺序是around-before-after-afterreturn-afterthrowing
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
chain放入CglibMethodInvocation对象中,调用proceed()方法
7 进入CglibAopProxy.java.CglibMethodInvocation.java的proceed方法
private static class CglibMethodInvocation extends ReflectiveMethodInvocation {
public Object proceed() throws Throwable {
try {
return super.proceed();
}
8 进入super.proceed,也就是ReflectiveMethodInvocation.java的proceed方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
currentInterceptorIndex = -1 ,this.interceptorsAndDynamicMethodMatchers.size() = 6
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
获取到的interceptorOrInterceptionAdvice是ExposeInvocationInterceptor对象,也就是chain里面的0好元素
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
里面传入的this是上面创建的CglibMethodInvocation对象(它里面有chain对象)
9 进入ExposeInvocationInterceptor的invoke方法
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
MethodInvocation oldInvocation = invocation.get();
invocation.set(mi);
try {
return mi.proceed();
}
finally {
invocation.set(oldInvocation);
}
}
把mi对象(也就是上面传入的this对象-CglibAopProxy.java.CglibMethodInvocation对象)赋值给invocation
invocation是当前类ExposeInvocationInterceptor的一个static final静态变量
private static final ThreadLocal<MethodInvocation> invocation =
new NamedThreadLocal<>("Current AOP method invocation");
10 然后调用mi的proceed方法
就是CglibAopProxy.java.CglibMethodInvocation.java的proceed方法
进入proceed方法
public Object proceed() throws Throwable {
try {
return super.proceed();
}
11 调用super.proceed方法,又回到了ReflectiveMethodInvocation的proceed方法
此时currentInterceptorIndex值为0
get(++this.currentInterceptorIndex)取出来的是AspectAroundAdvice 环绕通知
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
12 执行((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);进入AspectJAroundAdvice.java的invoke方法
进入invokeAdviceMethod方法
进入invokeAdviceMethodWithGivenArgs方法
进入this.aspectJAdviceMethod.invoke方法,也就是Method.java的invoke方法
执行ma.invoke(obj, args);
执行,来到环绕通知方法
执行完System.out.println("doAround 前面执行");这个就是around的第一次执行
13 接着执行我们定义的环绕通知方法里面的代码Object proceed = joinPoint.proceed();进入MethodInvocationProceedingJoinPoint.java的proceed方法
14 进入this.methodInvocation.invocableClone().proceed()也就是CglibAopProcy.java.CglibMethodInvocation.java.proceed方法(又回到这个方法)
15 (同11步)进入super.proceed,就是ReflectiveMethodInvocation.java的proceed方法
此时currentInterceptorIndex为1
取出++this.currentInterceptorIndex号元素,为MethodBeforeAdviceInterceptor,也就是before通知
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
16 执行((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);进入MethodBeforeAdviceInterceptor.java的invoke方法
执行完this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
before通知方法已执行
17 (同11步)调用super.proceed方法,又回到了ReflectiveMethodInvocation的proceed方法
此时currentInterceptorIndex为2
取出++this.currentInterceptorIndex号元素,为AspectJAfterAdvice,也就是after通知
18 执行((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);进入AspectJAfterAdvice.java的invoke方法
直接执行return mi.proceed();并没有去调用我们定义的after通知的方法
19 (同11步)调用super.proceed方法,又回到了ReflectiveMethodInvocation的proceed方法
此时currentInterceptorIndex为2
取出++this.currentInterceptorIndex号元素,为AfterReturningAdviceInterceptor,也就是afterReturning通知
20 执行((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);进入AfterReturningAdviceInterceptor.java的invoke方法
先直接执行Object retVal = mi.proceed();等它执行完成,才去执行this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
也就是我们自定义的通知方法
21 (同11步)调用super.proceed方法,又回到了ReflectiveMethodInvocation的proceed方法
此时currentInterceptorIndex为4
取出++this.currentInterceptorIndex号元素,为AspectAfterThrowingAdvice,也就是afterrThrowing通知
22 执行((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);进入AspectJAfterThrowingAdvice.java的invoke方法
直接执行mi.proceed();执行完成后,采取执行invokeAdviceMethod(getJoinPointMatch(), null, ex);也就是我们自定义的通知方法
23 进入super.proceed,也就是ReflectiveMethodInvocation.java的proceed方法
此时currentInterceptorIndex为5,判断为true,执行return invokeJoinpoint();
24 执行return invokeJoinpoint();
进入CglibAopProxy.java.CglibMethodInvocation.java的invokeJoinpoint方法
执行this.methodProxy.invoke(this.target, this.arguments);来到MethodProxy的invoke方法
25 执行 fci.f1.invoke(fci.i1, obj, args);来到我们的连接点方法
26 一步步执行,回到AspectJAfterThrowingAdvice.invoke方法
回到ThrowingAdvice通知的invoke方法,继续执行,由于没有异常,不会执行catch里面的invokeAdviceMethod(getJoinPointMatch(), null, ex);,所以自定义的通知方法不会执行
27 继续执行,回到AfterReturningAdviceInterceptor的invoke方法
回到了AfterReturning通知的invoke方法
执行this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
一步步往里面走,直到执行我们自定义的通知方法
28 继续执行,回到AspectJAfterAdvice的invoke方法
执行invokeAdviceMethod(getJoinPointMatch(), null, null);
一步步往里面走,直到执行我们自定义的通知方法
29 继续走,回到自定义的around通知方法
执行完
到此,五个通知全部执行完成
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· DeepSeek “源神”启动!「GitHub 热点速览」
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· NetPad:一个.NET开源、跨平台的C#编辑器
2021-03-03 redis-04配置文件
2021-03-03 Redis-03 数据格式和基础命令