【Spring AOP】静态代理设计模式、Spring 动态代理开发详解、切入点详解（切入点表达式

2401_84003656

1033人浏览 · 2024-04-12 08:23:21

2401_84003656 · 2024-04-12 08:23:21 发布

return true;

}

额外功能 MethodBeforeAdvice 接口

public class Before implements MethodBeforeAdvice {

/**

作用: 把需要运行在原始方法执行之前运行的额外功能, 书写在 before 方法中

@Override

public void before(Method method, Object[] objects, Object o) throws Throwable {

System.out.println(“—method before advice log—”);

}

定义 切入点：额外功能的加入

目的: 由程序员根据自己的需要，决定额外功能加入给哪个原始方法(register、login)

aop:config

<aop:pointcut id=“pc” expression=“execution(* * (…))”/>

</aop:config>

组装（2、3 整合）

<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

https://www.springframework.org/schema/aop/spring-aop.xsd">

aop:config

<aop:pointcut id=“pc” expression=“execution(* * (…))”/>

<aop:advisor advice-ref=“before” pointcut-ref=“pc”/>

</aop:config>

调用

目的：获得 Spring 工厂创建的动态代理对象，并进行调用

注意：

Spring 的工厂通过原始对象的 id 值获得的是代理对象
获得代理对象后，可以通过声明接口类型，进行对象的存储

/**

用于测试动态代理

@Test

public void test1() {

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(“/applicationContext.xml”);

UserService userService = (UserService) ctx.getBean(“userService”);

userService.login(“admin”, “1234”);

userService.register(new User());

}

动态代理细节分析

Spring 创建的动态代理类在哪里？

Spring 框架在运行时，通过动态字节码技术，在 JVM 创建的，运行在 JVM 内部，等程序结束后，会和 JVM 一起消失。

什么是 动态字节码技术？

通过第三方动态字节码框架，在 JVM 中创建对应类的字节码，进而创建对象，当虚拟机结束，动态字节码跟着消失。

结论：

动态代理不需要定义类文件，都是 JVM 运行过程中动态创建的；

所以不会造成静态代理的缺点：类⽂件数量过多，影响项目管理的问题。

在这里插入图片描述

动态代理编程简化代理的开发

在额外功能不改变的前提下，创建其他目标类（原始类）的代理对象时，只需要指定原始（目标）对象即可。

动态代理使得 额外功能的维护性大大增强。

动态代理开发详解

===========================================================================

额外功能的详解

MethodBeforeAdvice 分析

MethodBeforeAdvice 接口作用：额外功能运行在原始方法执行之前，进行额外功能操作。

public class Before implements MethodBeforeAdvice {

/**

作用: 把需要运行在原始方法执行之前运行的额外功能, 书写在 before 方法中
Method: 额外功能所增加给的那个原始方法
```
                     login
```
```
                     register
```
```
                     --------
```
```
                     showOrder
```
Object[]: 额外功能所增加给的那个原始方法的参数

                     String name,String password

```
                     User
```
```
                     --------
```
Object: 额外功能所增加给的那个原始对象
```
                     UserServiceImpl
```
```
                     ---------------
```
```
                     OrderServiceImpl
```

@Override

public void before(Method method, Object[] objects, Object o) throws Throwable {

System.out.println(“—new method before advice log—”);

}

before 方法的 3 个参数在实战中，该如何使用？

before 方法的参数，在实战中，会根据需要进行使用，不⼀定都会用到，也有可能都不用。

孙哥：”我用了 15 年 Spring 一次都没有用到过这个。"

MethodInterceptor（方法拦截器）

methodinterceptor 接口：额外功能可以根据需要运行在原始方法执行 前、后、前后。

参数：MethodInvocation：额外功能所增加给的那个原始方法 (login, register)
返回值：Object：原始方法的返回值 (没有就返回 null)
invocation.proceed()：原始方法运行

额外功能运行在原始方法之前：

public class Around implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

System.out.println(“—额外功能运行在原始方法执行之前—”);

Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值

return ret;

}

额外功能运行在原始方法之后：

public class Around implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值

System.out.println(“—额外功能运行在原始方法执行之后—”);

return ret;

}

额外功能运行在原始方法 之前、之后：

public class Around implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

System.out.println(“—额外功能运行在原始方法执行之前—”);

Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值

System.out.println(“—额外功能运行在原始方法执行之后—”);

return ret;

}

额外功能运行在原始方法抛出异常的时候：

public class Around implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

Object ret = null;

try {

ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值

} catch (Throwable throwable) {

System.out.println(“—额外功能运行在原始方法抛异常的时候—”);

}

return ret;

}

MethodInterceptor 影响原始方法的返回值：

public class Around implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

System.out.println(“—log—”);

Object ret = methodInvocation.proceed();

return false;

}

切入点详解

========================================================================

切入点决定额外功能加入位置（方法）

<aop:pointcut id=“pc” expression=“execution(* * (…))”/>

execution()：切入点函数
* *(..)：切入点表达式

切入点表达式

方法切入点

定义一个方法

public void add（int i, int j）

```
          *      (..) 
```
- (…) --> 所有方法
—> 修饰符返回值
—> 方法名

() —> 参数表

… —> 对于参数没有要求 (参数有没有，参数有⼏个都行，参数是什么类型的都行)

定义 login 方法作为切入点：

<aop:pointcut id=“pc” expression=“execution(* login (…))”/>

<aop:pointcut id=“pc” expression=“execution(* register (…))”/>

定义方法名为 login 且有两个字符串类型的参数作为切入点；

<aop:pointcut id=“pc” expression=“execution(* login (String,String))”/><

<aop:pointcut id=“pc” expression=“execution(* register (com.yusael.proxy.User))”/>

<aop:pointcut id=“pc” expression=“execution(* login(String, …))”/>

精准方法切入点限定

修饰符返回值包类.方法(参数)

<aop:pointcut id=“pc” expression=“execution(* com.yusael.proxy.UserServiceImpl.login(…))”/>

<aop:pointcut id=“pc” expression=“execution(* com.yusael.proxy.UserServiceImpl.login(String, String))”/>

类切入点

指定 特定类作为切入点(额外功能加入的位置)，这个类中的所有方法，都会加上对应的额外功能。

语法1

类中所有的方法加入了额外功能

<aop:pointcut id=“pc” expression=“execution(* com.yusael.proxy.UserServiceImpl.*(…))”/>

语法2

忽略包

类只存在一级包

<aop:pointcut id=“pc” expression=“execution(* .UserServiceImpl.(…))”/>

类存在多级包

<aop:pointcut id=“pc” expression=“execution(* …UserServiceImpl.(…))”/>

包切入点（实战中用的多）

指定包作为额外功能加入的位置，自然包中的所有类及其方法都会加入额外的功能。

语法1：

切入点包中的所有类，必须在proxy中，不能在proxy包的⼦包中

<aop:pointcut id=“pc” expression=“execution(* com.yusael.proxy..(…))”/>

语法2：

切入点当前包及其⼦包都生效

<aop:pointcut id=“pc” expression=“execution(* com.yusael.proxy….(…))”/>

切入点函数（execution、args、within）

切入点函数：用于执行切入点表达式

exectuion

execution 是最为重要的切入点函数，功能最全；可以执行执行 方法切入点表达式、类切入点表达式、包切入点表达式；

弊端：execution 执⾏切入点表达式，书写麻烦

execution(* com.yusael.proxy….(…))

注意：其他的切入点函数简化的是 execution 的书写复杂度，功能上完全⼀致。

args

args 作用：主要用于 函数(方法) 参数的匹配；

切入点：方法参数必须得是 2 个字符串类型的参数

使用 execution

<aop:pointcut id=“pc” expression=“execution(* *(String, String))”/>

使用 args

<aop:pointcut id=“pc” expression=“args(String, String)”/>

within

within 作用：主要用于进行 类、包切入点表达式 的匹配。

切入点: UserServiceImpl 这个类

使用 execution

<aop:pointcut id=“pc” expression=“expression(* …UserServiceImpl.(…))”/>

使用 within

<aop:pointcut id=“pc” expression=“within(*…UserServiceImpl)”/>

切入点: com.yusael.proxy 这个包

使用 execution

<aop:pointcut id=“pc” expression=“execution(* com.yusael.proxy…*.**(…)”/>

使用 within

<aop:pointcut id=“pc” expression=“within(com.yusael.proxy…*)”/>

@annotation

作用：为具有特殊注解的方法加入额外功能。

例如我们自定义了一个注解：Log

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

public @interface Log {

}

然后我们要为使用了 Log 注解的方法加入额外功能。

<aop:pointcut id=“pc” expression=“@annotation(com.yusael.Log)”/>

切入点函数的逻辑运算（and、or）

切入点函数的逻辑运算指的是：整合多个切入点函数⼀起配合工作，进而完成更为复杂的需求。

and 与操作：

案例: 方法名叫 login 同时参数是 2个字符串

execution

<aop:pointcut id=“pc” expression=“execution(* login(String, String))”/>

execution and args

<aop:pointcut id=“pc” expression=“execution(* login(…)) and args(String, String))”/>

注意：与操作不同⽤于同种类型的切⼊点函数

以下这个是错误的, 因为不存在同时叫 login 和 register 的方法

<aop:pointcut id=“pc” expression=“execution(* login(…)) and execution(* register(…))”/>

or 或操作：

案例: 方法名叫 register 或 login 的⽅法作为切⼊点

<aop:pointcut id=“pc” expression=“execution(* login(…)) or execution(* register(…))”/>

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

最后

我想问下大家当初选择做程序员的初衷是什么？有思考过这个问题吗？高薪？热爱？

既然入了这行就应该知道，这个行业是靠本事吃饭的，你想要拿高薪没有问题，请好好磨练自己的技术，不要抱怨。有的人通过培训可以让自己成长，有些人可以通过自律强大的自学能力成长，如果你两者都不占，还怎么拿高薪？

架构师是很多程序员的职业目标，一个好的架构师是不愁所谓的35岁高龄门槛的，到了那个时候，照样大把的企业挖他。为什么很多人想进阿里巴巴，无非不是福利待遇好以及优质的人脉资源，这对个人职业发展是有非常大帮助的。

如果你也想成为一名好的架构师，那或许这份Java核心架构笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。

中高级开发必知必会：

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

[外链图片转存中…(img-Gs3ikBtU-1712881387101)]
[外链图片转存中…(img-CrDnpSDT-1712881387101)]
[外链图片转存中…(img-959dX7ci-1712881387102)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-rHEGgFgO-1712881387102)]

最后

我想问下大家当初选择做程序员的初衷是什么？有思考过这个问题吗？高薪？热爱？

如果你也想成为一名好的架构师，那或许这份Java核心架构笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。

中高级开发必知必会：

[外链图片转存中…(img-sToSKnW7-1712881387102)]

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-xiM5bOgl-1712881387103)]

乐奇 Rokid 开放社区

更多推荐

从源码拆解一个 AIUI 每日一词智能体：页面、离线索引与硬件交互

乐奇 Rokid 开放社区

一句话打造「丢哪里」垃圾分类AIUI智能体

乐奇 Rokid 开放社区

“什么值得买”兴趣消费服务接入乐奇AI眼镜，开启“看见即搜索”新体验

乐奇 Rokid 开放社区

所有评论(0)

查看更多评论

2401_84003656

@2401_84003656

已为社区贡献1条内容

【Spring AOP】静态代理设计模式、Spring 动态代理开发详解、切入点详解（切入点表达式

2401_84003656

MethodBeforeAdvice 分析

MethodInterceptor（方法拦截器）

方法切入点

类切入点

类中所有的方法加入了额外功能

忽略包

包切入点（实战中用的多）

切入点包中的所有类，必须在proxy中，不能在proxy包的⼦包中

切入点当前包及其⼦包都生效

exectuion

args

使用 execution

使用 args

within

使用 execution

使用 within

使用 execution

使用 within

@annotation

切入点函数的逻辑运算（and、or）

execution

execution and args

最后

最后

所有评论(0)

温馨提示：您尚未绑定手机号

2401_84003656