17-spring aop调用过程概述

已于 2023-10-22 10:07:05 修改
阅读量390 收藏
点赞数
分类专栏： # spring源码学习笔记 文章标签： spring java 后端
于 2023-10-20 22:12:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39530821/article/details/133955126
版权

文章目录

1.源码

public class TestAop {

  public static void main(String[] args) throws Exception {
    saveGeneratedCGlibProxyFiles(System.getProperty("user.dir") + "/proxy");
    ApplicationContext ac = new ClassPathXmlApplicationContext("META-INF/aop.xml");
    MyCalculator bean = ac.getBean(MyCalculator.class);
    System.out.println(bean.toString());
    bean.add(1, 1);
    bean.sub(1, 1);

  }

  public static void saveGeneratedCGlibProxyFiles(String dir) throws Exception {
    Field field = System.class.getDeclaredField("props");
    field.setAccessible(true);
    Properties props = (Properties) field.get(null);
    //dir为保存文件路径
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, dir);
    props.put("net.sf.cglib.core.DebuggingClassWriter.traceEnabled", "true");
  }
}


public class MyCalculator /*implements Calculator */ {

  public Integer add(Integer i, Integer j) throws NoSuchMethodException {
    Integer result = i + j;
    System.out.println("MyCalculator add method invoked");
    return result;
  }

  public Integer sub(Integer i, Integer j) throws NoSuchMethodException {
    Integer result = i - j;
    return result;
  }

  public Integer mul(Integer i, Integer j) throws NoSuchMethodException {
    Integer result = i * j;
    return result;
  }

  public Integer div(Integer i, Integer j) throws NoSuchMethodException {
    Integer result = i / j;
    return result;
  }

  public Integer show(Integer i) {
    System.out.println("show .....");
    return i;
  }

  @Override
  public String toString() {
    return "super.toString()";
  }
}


public class LogUtil {

  private int start(JoinPoint joinPoint) {
    //获取方法签名
    Signature signature = joinPoint.getSignature();
    //获取参数信息
    Object[] args = joinPoint.getArgs();
    System.out.println("log---Before advice: " + signature.getName() + "方法开始执行：参数是" + Arrays.asList(args));
    return 100;
  }

  public static void stop(JoinPoint joinPoint, Object result) {
    Signature signature = joinPoint.getSignature();
    System.out.println("log---AfterReturning advice: " + signature.getName() + "方法执行结束，结果是：" + result);
  }

  public static void logException(JoinPoint joinPoint, Exception e) {
    Signature signature = joinPoint.getSignature();
    System.out.println("log--- AfterThrowing advice: " + signature.getName() + "方法抛出异常：" + e.getMessage());
  }

  public static void logFinally(JoinPoint joinPoint) {
    Signature signature = joinPoint.getSignature();
    System.out.println("log---After advice: " + signature.getName() + "方法执行结束。。。。。over");

  }

  public Object around(ProceedingJoinPoint pjp) throws Throwable {
    Signature signature = pjp.getSignature();
    Object[] args = pjp.getArgs();
    Object result = null;
    try {
      System.out.println("log---Around advice start：" + signature.getName() + "方法开始执行，参数为：" + Arrays.asList(args));
      //通过反射的方式调用目标的方法，相当于执行method.invoke(),可以自己修改结果值
      result = pjp.proceed(args);
      //            result=100;
      System.out.println("log---Around advice end: " + signature.getName() + "方法执行结束");
    } catch (Throwable throwable) {
      System.out.println("log---Around advice error：" + signature.getName() + "出现异常");
      throw throwable;
    } finally {
      System.out.println("log---Around advice finally：" + signature.getName() + "方法返回结果是：" + result);
    }
    return result;
  }
}


<?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.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
">

  <!--    <bean class="com.mashibing.MyBeanFactoryPostProcessorBySelf" ></bean>-->
  <bean id="logUtil" class="org.geekbang.thinking.in.spring.ioc.overview.aop.xml.util.LogUtil"></bean>
  <bean id="myCalculator" class="org.geekbang.thinking.in.spring.ioc.overview.aop.xml.service.MyCalculator"></bean>
  <aop:config>
    <aop:aspect ref="logUtil">
      <aop:pointcut id="myPoint"
        expression="execution( Integer org.geekbang.thinking.in.spring.ioc.overview.aop.xml.service.MyCalculator.*  (..))"/>
      <aop:around method="around" pointcut-ref="myPoint"></aop:around>
     <aop:after method="logFinally" pointcut-ref="myPoint"></aop:after>
      <aop:before method="start" pointcut-ref="myPoint"></aop:before>
      <aop:after-returning method="stop" pointcut-ref="myPoint" returning="result"></aop:after-returning>
      <aop:after-throwing method="logException" pointcut-ref="myPoint" throwing="e"></aop:after-throwing>
    </aop:aspect>
  </aop:config>
  <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

2. debug过程

生成的源码：

public class MyCalculator$$EnhancerBySpringCGLIB$$3f411fc extends MyCalculator implements SpringProxy, Advised, Factory {
  private boolean CGLIB$BOUND;
  public static Object CGLIB$FACTORY_DATA;
  private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
  private static final Callback[] CGLIB$STATIC_CALLBACKS;
  private MethodInterceptor CGLIB$CALLBACK_0;
  private MethodInterceptor CGLIB$CALLBACK_1;
  private NoOp CGLIB$CALLBACK_2;
  private Dispatcher CGLIB$CALLBACK_3;
  private Dispatcher CGLIB$CALLBACK_4;
  private MethodInterceptor CGLIB$CALLBACK_5;
  private MethodInterceptor CGLIB$CALLBACK_6;
  private static Object CGLIB$CALLBACK_FILTER;
  private static final Method CGLIB$add$0$Method;
  private static final MethodProxy CGLIB$add$0$Proxy;
  private static final Object[] CGLIB$emptyArgs;
  private static final Method CGLIB$toString$1$Method;
  private static final MethodProxy CGLIB$toString$1$Proxy;
  private static final Method CGLIB$sub$2$Method;
  private static final MethodProxy CGLIB$sub$2$Proxy;
  private static final Method CGLIB$mul$3$Method;
  private static final MethodProxy CGLIB$mul$3$Proxy;
  private static final Method CGLIB$show$4$Method;
  private static final MethodProxy CGLIB$show$4$Proxy;
  private static final Method CGLIB$div$5$Method;
  private static final MethodProxy CGLIB$div$5$Proxy;
  private static final Method CGLIB$equals$6$Method;
  private static final MethodProxy CGLIB$equals$6$Proxy;
  private static final Method CGLIB$hashCode$7$Method;
  private static final MethodProxy CGLIB$hashCode$7$Proxy;
  private static final Method CGLIB$clone$8$Method;
  private static final MethodProxy CGLIB$clone$8$Proxy;

  static void CGLIB$STATICHOOK1() {
    CGLIB$THREAD_CALLBACKS = new ThreadLocal();
    CGLIB$emptyArgs = new Object[0];
    Class var0 = Class.forName("org.geekbang.thinking.in.spring.ioc.overview.aop.xml.service.MyCalculator$$EnhancerBySpringCGLIB$$3f411fc");
    Class var1;
    Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
    CGLIB$equals$6$Method = var10000[0];
    CGLIB$equals$6$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$6");
    CGLIB$hashCode$7$Method = var10000[1];
    CGLIB$hashCode$7$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$7");
    CGLIB$clone$8$Method = var10000[2];
    CGLIB$clone$8$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$8");
    var10000 = ReflectUtils.findMethods(new String[]{"add", "(Ljava/lang/Integer;Ljava/lang/Integer;)Ljava/lang/Integer;", "toString", "()Ljava/lang/String;", "sub", "(Ljava/lang/Integer;Ljava/lang/Integer;)Ljava/lang/Integer;", "mul", "(Ljava/lang/Integer;Ljava/lang/Integer;)Ljava/lang/Integer;", "show", "(Ljava/lang/Integer;)Ljava/lang/Integer;", "div", "(Ljava/lang/Integer;Ljava/lang/Integer;)Ljava/lang/Integer;"}, (var1 = Class.forName("org.geekbang.thinking.in.spring.ioc.overview.aop.xml.service.MyCalculator")).getDeclaredMethods());
    CGLIB$add$0$Method = var10000[0];
    CGLIB$add$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Integer;Ljava/lang/Integer;)Ljava/lang/Integer;", "add", "CGLIB$add$0");
    CGLIB$toString$1$Method = var10000[1];
    CGLIB$toString$1$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$1");
    CGLIB$sub$2$Method = var10000[2];
    CGLIB$sub$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Integer;Ljava/lang/Integer;)Ljava/lang/Integer;", "sub", "CGLIB$sub$2");
    CGLIB$mul$3$Method = var10000[3];
    CGLIB$mul$3$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Integer;Ljava/lang/Integer;)Ljava/lang/Integer;", "mul", "CGLIB$mul$3");
    CGLIB$show$4$Method = var10000[4];
    CGLIB$show$4$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Integer;)Ljava/lang/Integer;", "show", "CGLIB$show$4");
    CGLIB$div$5$Method = var10000[5];
    CGLIB$div$5$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Integer;Ljava/lang/Integer;)Ljava/lang/Integer;", "div", "CGLIB$div$5");
  }

  final Integer CGLIB$add$0(Integer var1, Integer var2) throws NoSuchMethodException {
    return super.add(var1, var2);
  }

  public final Integer add(Integer var1, Integer var2) throws NoSuchMethodException {
    MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
    if (var10000 == null) {
      CGLIB$BIND_CALLBACKS(this);
      var10000 = this.CGLIB$CALLBACK_0;
    }
    // 从这里进入MethodInterceptor的接口
    return var10000 != null ? (Integer)var10000.intercept(this, CGLIB$add$0$Method, new Object[]{var1, var2}, CGLIB$add$0$Proxy) : super.add(var1, var2);
  }
............
}

在这里插入图片描述

CGLIB$CALLBACK_0的advised对象的targetSource有一个普通对象MyCalculate.
在这里插入图片描述

获得执行链
在这里插入图片描述

进入调用链

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

进入实际的方法
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

tobebetter9527
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP无法调用自身方法的原因
实践是最好的方法
08-29 2543
1、问题概述 在使用Spring AOP时，或多或少会碰到一些方法无法被增强的问题，有时同一个类里面的方法有的可以被增强，有的却无法被增强。要分析原因，首先要从Spring AOP的实现机制入手。 Aop底层实现有两种方法：  1、基于JDK动态代理，通过接口来实现方法拦截，所以必须要确保要拦截的目标方法在接口中有定义，否则将无法实现拦截  2、GCLib动态代理，通过动态生成子类来实现方法拦...
一文搞懂AOP调用原理
朱守成
10-14 405
一． 前言 AOP是spring框架的两大核心之一，在日常工作中也会经常会到它，典型的应用用来记录日志，包括spring的注解事务也是通过AOP实现的。大家是否都对AOP原理都很清楚呢？AOP底层到底是如何实现的？AOP在什么场景下会失效？ 二． AOP失效例子 带着这些疑问，我们从一个AOP失效的例子开始揭开AOP的面纱。 定义一个切点 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public
Spring AOP系列学习笔记四：AOP具体调用流程分析
zhengguofeng0328的博客
07-07 492
原文地址程序员囧辉大佬 文章目录JdkDynamicAopProxy#invoke代码块1：ReflectiveMethodInvocation 构造函数代码块2：ReflectiveMethodInvocation#proceed代码块3：invokeJoinpoint代码块4：ExposeInvocationInterceptor # invoke代码块5：AspectJAroundAdvice # invoke代码块6：invokeAdviceMethod代码块7：argBinding代码块8：inv
Spring AOP三部曲之调用
孤芳不自赏
05-24 286
前言 上篇文章我们讲解了Spring AOP是如何创建代理对象的，在这篇文章我们继续讲解AOP是如何调用的。 这是从网上找的一个简单demo，大家可以对照着去理解。 注意：本文是以5.2.3版本为讲解。 步骤一：创建代理 在昨天我们讲解了通过createAopProxy()方法里我们根据不同策略是通过JDK和CGLIB的代理，在这里我们以JDK创建代理对象为讲解。 步骤二：创建JDK动态代理 大致业务如下： completeProxiedInterfaces...
AOP的使用（详细讲解）
酷小亚
08-31 1万+
一、AOP基本概念 二、AOP底层原理 三、AOP的JDK动态代理 四、AOP术语 五、AOP操作（准备） 六、AOP操作（AspectJ注解）【重点】 七、AOP操作（AspectJ配置文件）
Spring AOP中自我调用的问题
398701344努力加油！
05-21 5629
前几天在做项目的时候同事说，在使用AOP进行拦截的时候发现有些方法有时候能输出拦截的日志有时候不输出拦截的日志。发现在单独调用这些方法的时候是有日志输出，在被同一个类中的方法调用的时候没有日志输出。我记得之前看过一篇文章是讲Spring事务自我调用不起作用的问题，应该是同样的问题(如果要观看那篇文章请点击这里http://jinnianshilongnian.iteye.com/blog/1487...
2024-spring-aop学习项目
最新发布
01-26
一、Spring AOP概述 Spring AOP是Spring框架中的一个关键特性，它通过将关注点分离，实现了业务逻辑与系统服务（如日志、事务管理）的解耦。AOP的核心理念在于，将那些分散在各处的交叉性关注点（如日志、安全检查等...
拿捏面试官-Spring AOP IOC源码笔记
01-30
- **AOP的概述**：AOP用于封装横切关注点，如日志、事务、性能监控等。 - **Spring AOP开发步骤**：引入AOP命名空间，使用注解或XML配置定义切面、切点和通知。 8. **JDBCTemplate和Spring事务** - **...
SpringAOP.rar_springAOP
09-23
一、Spring AOP概述 1.1 面向切面编程 面向切面编程是一种编程范式，旨在将关注点分离，使程序结构更清晰，提高代码重用性和可维护性。在Spring AOP中，关注点被划分为“切面”（Aspects），这些切面可以独立于主...
Spring-AOP .pptx
04-09
1. **AOP概述** - AOP是Aspect Oriented Programming的缩写，通过运行时动态代理实现程序功能的统一维护。 - 在Spring框架中，AOP用于隔离交叉业务逻辑，如事务管理、日志、安全检查和缓存，使其独立于主业务逻辑...
Spring学习教程之AOP模块的概述
08-27
AOP（Aspect-Oriented Programming，面向切面编程）就是这样的一个概念，它在Spring框架中扮演着重要的角色，为开发者提供了一种优雅地处理横切关注点的手段。 在面向对象编程（OOP）中，我们通常将一个系统分解成...
AOP调用注意点
綠竹清水之福荫的博客
02-25 337
package com.agp.aop.impl; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; //CBuyCar接口的实现类Customer @Compone
AOP使用方法
u010502101的博客
12-16 1896
一、AOP的概念1、什么是面向切面编程呢？听起来很抽象，举个例子：假设我们要执行一个核心交易，但是我想打印核心交易前和交易后的日志，最简单的办法就是在核心交易的程序的前面和后面分别加上打印日志的程序。是的，很正确，但是我如果有成千上个这样的程序都要打印日志呢？如果你在每个核心的程序里面都加上打印日志的程序，核心程序和非核心的程序相互交错，不利于程序的维护，费时费力。 So，此时我们的面向切面编程
Spring AOP使用示例
热门推荐
最怕一生碌碌无为，还安慰自己平凡可贵
06-13 6万+
AOP:【面向切面编程】 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式。 1、导入aop模块：Spring AOP：（spring-aspects） 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候讲日志进行打印（方法之前、方法运行结束、方法出现异常等) 3、定义一个日志切面类（LOgAspects）；切面类里面...
SpringAOP功能自我调用的解决方案
Erica_1230的专栏
05-26 4724
使用AOP 代理后的方法调用执行流程，如图所示 也就是说我们首先调用的是AOP代理对象而不是目标对象，首先执行事务切面，事务切面内部通过TransactionInterceptor环绕增强进行事务的增强，即进入目标方法之前开启事务，退出目标方法时提交/回滚事务。 问题 目标对象内部的自我调用将无法实施切面中的增强，如图所示   此处的this指向目
AOP原理——3. AOP方法调用流程
姜希成的博客
12-04 856
获取拦截链 链式调用通知方法 一般情况下是DynamicAdvisedInterceptor里的intercept方法起作用。 DynamicAdvisedInterceptor是CglibAopProxy的内部类 DynamicAdvisedInterceptor#intercept public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwabl.
SpringAOP 的使用（两种方式）
a8366的专栏
10-22 121
     使用Spring AOP 拦截 方法，给被拦截的方法加上，前置通知，后置通知，例外通知，最终通知 的两个例子，见 附件 需要 spring.jar，cglib.jar，commons-logging.jar   方式1. 被拦截的类没有实现任何接口   关键代码： package junit.test; import org.junit.BeforeClass; im...
AOP 的详细说明以及基本的使用
cyt
07-19 4万+
AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-OrientedPrograming，面向对象编程）的补充和完善。​OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。...
2022年优秀-Spring业务逻辑层技术教学概述
在Spring框架的简介中，首先介绍了Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。它的轻量体现在框架的大小和开销方面，完整的Spring框架可以在一个大小只有1MB多的JAR文件中发布，并且所需的处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值