当前位置： 首页 > article >正文

【SpringAOP】Spring AOP 底层逻辑：切点表达式与原理简明阐述

article 2025/1/11 9:32:49

前言

🌟🌟本期讲解关于spring aop的切面表达式和自身实现原理介绍~~~

🌈感兴趣的小伙伴看一看小编主页：GGBondlctrl-CSDN博客

🔥 你的点赞就是小编不断更新的最大动力                                       

🎆那么废话不多说直接开整吧~~

目录

📚️1.切点表达式

🚀1.1execution表达式

 🚀1.2@annotation

1.自定义注解

2.切面类

3.添加注解

📚️2.Spring AOP原理

🚀2.1代理模式

1.静态代理（了解）

2.动态代理（八股）

🚀2.2Spring AOP原理总结

📚️3.总结

📚️1.切点表达式

我们在上一期了解到了关于通知中切点表达式execution表达式，但是没有做很详细的介绍，不仅如此在切点表达式中，有两种方式，下面来一一介绍

🚀1.1execution表达式

切点表达式的结构如下所示：

execution(<访问修饰符> <返回类型> <包名.类名.⽅法(⽅法参数)> <异常>)

而在我们上期写的表达式中格式如下：

@Around("execution(* com.example.springaop.controller.*.*(..))")

 解释：

* ：匹配任意字符，只匹配⼀个元素(返回类型, 包, 类名, ⽅法或者⽅法参数）

.. ：匹配多个连续的任意符号, 可以通配任意层级的包, 或任意类型, 任意个数的参数

上述的controller后的两个 * 代表就是每一层，括号里的 .. 就是表示任意的方法参数；这里也可以代表无参数；

举例：

 execution(public String com.example.demo.controller.TestController.t1())

 解释：testcontroller类下的名为t1的方法，并且这里的方法是无参的，访问修饰符可以省去；

 execution(* com.example.demo.controller.TestController.t1())

解释：这里可以访问的就是没有任何限制的访问权限，匹配所有返回类型；

execution(* com.example.demo.controller.TestController.*()) 

解释：这里匹配所有的方法，这些方法是无参的；

execution(* com.example.demo.controller.*.*(..))

解释：这里匹配controller包下所有类的所有方法

 execution(* com..TestController.*(..))

解释：这里匹配com包下的所有testcontroller类的所有方法 

 🚀1.2@annotation

我们在上述的简述中了解到，关于execution表达式如何作用于匹配某个方法和类，但是当存在两个类，都要进行匹配，并且里面的方法也是无规则的，那如何呢，此时就要@annotation进行操作了；

假如有以下的两个控制类：

@RestController
@RequestMapping("/test")
public class TestController {
 
    @RequestMapping("/t1")
    public String test1(){
        log.info("这是t1执行");
        return "t1";
    }

    @RequestMapping("/t2")
    public String test2(){
        log.info("这是t2在执行");
        return "t2";
    }
}
@RestController
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/u1")
    public String user1(){
        return "u1";
    }
   
    @RequestMapping("/u2")
    public String user2(){
        return "u2";
    }
}

 那么此时我们要将第一个控制器类的第一个方法进行匹配，以及第二个控制器类的方法进行匹配，那么此时的操作就是如下所示：

1.自定义注解

代码如下所示：

//定义自己的注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAspect {
}

@Target 标识了 Annotation 所修饰的对象范围, 即该注解可以⽤在什么地⽅.

@Retention 指Annotation被保留的时间⻓短, 标明注解的⽣命周期

2.切面类

使⽤ @annotation 切点表达式定义切点, 只对 @MyAspect ⽣效

代码如下所示：

@Aspect
@Component
@Slf4j
public class MyAnnotationAspect {
    @Before("@annotation(com.example.springaop.config.MyAspect)")
    public void doBefore(){
        log.info("before start...");
    }

    @After("@annotation(com.example.springaop.config.MyAspect)")
    public void doAfter(){
        log.info("after start...");
    }
}

这里小编设置了两种通知类，第一种是在目标方法执行前进行执行，第二种通知是在方法执行后进行执行，当然表达式里的的是我们自己注解的全限定路径，加上我们的定义注解名称；

3.添加注解

代码如下所示：

    @MyAspect
    @RequestMapping("/t1")
    public String test1(){
        log.info("这是t1执行");
        return "t1";
    }

这是第一个类的第一个方法；

@MyAspect
    @RequestMapping("/u2")
    public String user2(){
        return "u2";
    }

这是第二个类的第二个方法；

此时就与这两个方法进行了匹配，那么就可执行切面通知了；

📚️2.Spring AOP原理

🚀2.1代理模式

代理模式也叫委托模式定义：为其他对象提供⼀种代理以控制对这个对象的访问. 它的作⽤就是通过提供⼀个代理类, 让我们在调⽤⽬标⽅法的时候, 不再是直接对⽬标⽅法进⾏调⽤, ⽽是通过代理类间接调⽤（其实就是中介的作用）

1. Subject: 业务接⼝类. 可以是抽象类或者接⼝(不⼀定有)
2. RealSubject: 业务实现类. 具体的业务执⾏, 也就是被代理对象.（真正的房东）
3. Proxy: 代理类. RealSubject的代理 （中介）

这里的代理模式分为两种

• 静态代理: 由程序员创建代理类或特定⼯具⾃动⽣成源代码再对其编译, 在程序运⾏前代理类的
.class ⽂件就已经存在了.
• 动态代理: 在程序运⾏时, 运⽤反射机制动态创建⽽成 

1.静态代理（了解）

代码如下：

定义一个subject业务接口；

public interface SubjectHouse {
    void rentHouse();
}

让代理对象继承这个接口，并写出要代理什么

public class RealSubjectHouse implements SubjectHouse{
    //真正的房东
    @Override
    public void rentHouse(){
        System.out.println("我是房东，我要出租房子");
    }
}

最后中介，进行代理

public class HouseProxy implements SubjectHouse{

    private SubjectHouse subjectHouse;

    public HouseProxy(SubjectHouse subjectHouse) {
        this.subjectHouse = subjectHouse;
    }

    @Override
    public void rentHouse() {
        System.out.println("我是中介开始代理");

        subjectHouse.rentHouse();
        System.out.println("我是中介结束代理");

    }
}

解释这里使用了一个向上转型的思想，这里实际指定就是代理的对象就是realsubjecthouse（即真正的房东）；

从上述代码可以看出, 我们修改接⼝(Subject)和业务实现类(RealSubject)时, 还需要修改代理类
(Proxy).
同样的, 如果有新增接⼝(Subject)和业务实现类(RealSubject), 也需要对每⼀个业务实现类新增代理类(Proxy).

2.动态代理（八股）

相⽐于静态代理来说，动态代理更加灵活.
我们不需要针对每个⽬标对象都单独创建⼀个代理对象, ⽽是把这个创建代理对象的⼯作推迟到程序运
⾏时由JVM来实现. 也就是说动态代理在程序运⾏时, 根据需要动态创建⽣成

这里的动态代理分为两种

JDK动态代理；

CGLIB动态代理；

 JDK动态代理代码（了解）

public class JDKInvocationHandler implements InvocationHandler {
    private Object target;//目标对象

    public JDKInvocationHandler(Object target) {
        this.target = target;
    }

    /**
     * 代理对象  通过 invoke调用  目标对象的方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("我是代理, 开始代理");
        //通过反射, 调用目标对象的方法
        Object result = method.invoke(target, args);
        System.out.println("我是代理, 结束代理");
        return result;
    }
}

进行main方法调用：

SubjectHouse proxy= (SubjectHouse) Proxy.newProxyInstance(
                SubjectHouse .class.getClassLoader(),
                new Class[]{SubjectHouse .class},
                new JDKInvocationHandler(target));
        proxy.rentHouse();

newProxyInstance() , 这个⽅法主要⽤来⽣成⼀个代理对象

Loader: 类加载器, ⽤于加载代理对象.
interfaces : 被代理类实现的⼀些接⼝(这个参数的定义, 也决定了JDK动态代理只能代理实现了接⼝的⼀些类)
h : 实现了 InvocationHandler 接⼝的对象，target被代理对象

CGLIB动态代理代码

添加依赖：

<dependency>
 <groupId>cglib</groupId>
 <artifactId>cglib</artifactId>
 <version>3.3.0</version>
</dependency>
public class CGLibMethodInterceptor implements MethodInterceptor {
    private Object target;

    public CGLibMethodInterceptor(Object target) {
        this.target = target;
    }

    /**
     * 调用代理对象的方法
     */
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("我是中介, 开始代理");
        Object result = method.invoke(target, args);
        System.out.println("我是中介, 结束代理");
        return result;
    }
}

最后进行调用：

  SubjectHouse houseSubject = (SubjectHouse) Enhancer.create(
                target.getClass(), new CGLibMethodInterceptor(target));
        houseSubject.rentHouse();

上述存在一个比较重要的知识点：

JDK动态代理存在一个致命的问题，即只能代理接口，不能代理类，而CGLIB既可以代理接口，又可以代理类；

🚀2.2Spring AOP原理总结

 spring AOP原理，是要从源码进行解读的，但是源码过于复杂，最终的情况就是如下所示：

在源码中的代理⼯⼚有⼀个重要的属性: proxyTargetClass, 默认值为false. 也可以通过程序设置（这里的默认值是根据不同情况来进行定义的）

大致意思就是在 proxyTargetClass为false时，在实现接口时使用JDK代理，只实现类的情况下，使用CGLIB代理，若proxyTargetClass,为true，那么所有实现方式都使用CGLIB代理；

Spring默认使用的的proxyTargetClass为false，但是在spring boot2.x之后proxyTargetClass默认为true，使用CGLIB进行代理；

当然我们可以使用配置项进行配置

spring.aop.proxy-target-class=false

 这里设置proxyTargetClass默认为false；

📚️3.总结

本期主要讲解了关于切点表达式的两种表达方式，以及Spring AOP实现原理的两种代理模式，即JDK代理，以及CGLIB代理，最后进行Spring AOP原理的总结；

🌅🌅🌅~~~~最后希望与诸君共勉，共同进步！！！

💪💪💪以上就是本期内容了， 感兴趣的话，就关注小编吧。

       😊😊  期待你的关注~~~


http://www.kler.cn/a/487903.html

相关文章：

  • Vue.js组件开发-实现滚动加载下一页
  • 【LeetCode】力扣刷题热题100道（21-25题）附源码 接雨水 合并区间 字母异位词 滑动窗口 覆盖子串（C++）
  • 在 Vue 3 集成 e签宝电子合同签署功能
  • P10424 [蓝桥杯 2024 省 B] 好数
  • Flink源码解析之：Flink on k8s 客户端提交任务源码分析
  • 根据docker file 编译镜像
  • [java基础-集合篇]优先队列PriorityQueue结构与源码解析
  • 【JavaEE】—— SpringBoot项目集成百度千帆AI大模型（对话Chat V2）
  • SpringCloud系列教程：微服务的未来（十一）服务注册、服务发现、OpenFeign快速入门
  • Web基础之什么是HTTP协议
  • JavaSE——网络编程
  • Python基于YOLOv8和OpenCV实现车道线和车辆检测
  • 有机物谱图信息的速查技巧有哪些？
  • 【2025最新计算机毕业设计】基于SpringBoot+Vue奶茶点单系统（高质量源码，提供文档，免费部署到本地）
  • vue3+element-plus暗黑模式切换动画圆弧过渡
  • linux nginx 安装后，发现SSL模块未安装，如何处理？
  • Mumu模拟器和Frida
  • 【读点论文】DepGraph: Towards Any Structural Pruning通用的结构化剪枝框架，处理结构化剪枝的图依赖问题
  • 20250109使用M6000显卡在Ubuntu20.04.6下跑whisper来识别中英文字幕
  • Vue 2 提取可复用 Footer 组件
  • L1G5000 XTuner 微调个人小助手认知
  • 【Vue.js 组件化】高效组件管理与自动化实践指南
  • vs2022开发.net窗体应用开发环境安装配置以及程序发布详细教程
  • STM32 : PWM 基本结构
  • [network]回顾：集线器（Hub）
  • poi-tl+kkviewfile实现生成pdf业务报告