✅作者简介：热爱Java后端开发的一名学习者，大家可以跟我一起讨论各种问题喔。
个人主页：Hhzzy99
个人信条：坚持就是胜利！
当前专栏：【Spring】
本文内容：Spring框架中AOP的深入学习，带你搞透这门技术！
Spring
文章目录
- Spring
- 前言
- AOP简介
- AOP的核心概念
- 简单入门案例
- 环境搭建
- AOP实现步骤
- AOP的工作流程
- AOP配置管理
- AOP切入点表达式
- AOP通知类型
- AOP通知类型详解
- AOP学习总结
- 首先是AOP的核心概念：
- AOP的切入点表达式
- AOP五种通知类型
- 结语
前言
这篇文章是上一篇文章（IoC和DI）的后续，感兴趣的朋友们可以去看看(●’◡’●)
AOP简介
什么是AOP？它的作用是什么？
上一篇文章中，我们在介绍Spring的时候说过，Spring有两个核心的概念，一个是IOC/DI，一个是AOP。IOC/DI已经学习过了，
那么AOP又是什么呢？
AOP(Aspect Oriented Programming) 面向切面编程，它是一种编程范式，指导开发者如何组织程序结构。我们学Java的都知道OOP(Object Oriented Programming) 面向对象编程,它是一种编程思想，AOP也是一种编程思想。
AOP的作用是什么呢？
它的作用通俗点讲，就是在不惊动原来设计的基础上，对其进行功能上的增强。
AOP的核心概念
AOP的核心概念可以总结如下：
连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方
法、抛出异常、设置变量等
- 在SpringAOP中，可以理解为方法的执行
切入点(Pointcut): 匹配连接点的式子
- 在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法
- 一个具体的方法:如com.hzy.dao包下的BookDao接口中的无形参无返回值的save方法
- 匹配多个方法:所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法
- 连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。
通知(Advice): 在切入点处执行的操作，也就是共性功能
- 在SpringAOP中，功能最终以方法的形式呈现
通知类： 定义通知的类
切面(Aspect): 描述通知与切入点的对应关系。
简单入门案例
我们先做一个简单案例来入门=》
设定： 在方法执行前输出当前系统时间
思路分析：
1.导入坐标(pom.xml)
2.制作连接点(原始操作，Dao接口与实现类)
3.制作共性功能(通知类与通知)
4.定义切入点
5.绑定切入点与通知关系(切面)
环境搭建
先创建一个maven环境（这个大家都会吧）
在pom.xml中添加Spring依赖：
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.10.RELEASE</version> </dependency></dependencies>添加BookDao和BookDaoImpl类
public interface BookDao { public void save(); public void update();}@Repositorypublic class BookDaoImpl implements BookDao { public void save() { System.out.println(System.currentTimeMillis()); System.out.println("book dao save ..."); } public void update(){ System.out.println("book dao update ..."); }}然后创建Spring的配置类
@Configuration@ComponentScan("com.hzy")public class SpringConfig {}最后编写Application运行类
public class Application { public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class); BookDao bookDao = ctx.getBean(BookDao.class); bookDao.save(); }}下面是创建好后的结构目录：
我们所需要的基础环境搭建好了，现在我们就开始实现AOP吧!
AOP实现步骤
步骤一：在pom.xml中添加所需要的依赖
<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version></dependency>
我们所需要的spring-aop依赖在前面的spring-context中已经包含了，我们只需要导入AspectJ就可以。AspectJ是AOP思想的一个具体实现，Spring有自己的AOP实现，但是相比于AspectJ来说比较麻烦，所以我们直接采用Spring整合ApsectJ的方式进行AOP开发。
步骤二:定义接口与实现类
我们在环境准备时已经做好了，不用做任何修改
步骤三:定义通知类和通知
通知就是将共性功能抽取出来后形成的方法，共性功能指的就是当前系统时间的打印。
public class MyAdvice { public void method(){ System.out.println(System.currentTimeMillis()); }}步骤四:定义切入点
我们在前面定义的BookDaoImpl中有两个方法，分别是save和update，我们要增强的是update方法，该如何定义呢” />
说明:@Before翻译过来是之前，也就是说通知会在切入点方法执行之前执行，除此之前还有其他四种类型，后面会讲。
步骤六:将通知类配给容器并标识其为切面类
@Component@Aspectpublic class MyAdvice { @Pointcut("execution(void com.hzy.dao.BookDao.update())") private void pt(){} @Before("pt()") public void method(){ System.out.println(System.currentTimeMillis()); }}步骤七:开启注解格式AOP功能
@Configuration@ComponentScan("com.hzy")@EnableAspectJAutoProxypublic class SpringConfig {}步骤八:运行程序
public class Application { public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class); BookDao bookDao = ctx.getBean(BookDao.class); bookDao.update(); }}看到在执行update方法之前打印了系统时间戳，说明对原始方法进行了增强，AOP编程成功。
下面是几个要认识的点：
知识点1：@EnableAspectJAutoProxy
| 名称 | @EnableAspectJAutoProxy |
|---|---|
| 类型 | 配置类注解 |
| 位置 | 配置类定义上方 |
| 作用 | 开启注解格式AOP功能 |
知识点2：@Aspect
| 名称 | @Aspect |
|---|---|
| 类型 | 类注解 |
| 位置 | 切面类定义上方 |
| 作用 | 设置当前类为AOP切面类 |
知识点3：@Pointcut
| 名称 | @Pointcut |
|---|---|
| 类型 | 方法注解 |
| 位置 | 切入点方法定义上方 |
| 作用 | 设置切入点方法 |
| 属性 | value（默认）：切入点表达式 |
知识点4：@Before
| 名称 | @Before |
|---|---|
| 类型 | 方法注解 |
| 位置 | 通知方法定义上方 |
| 作用 | 设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行 |
AOP的工作流程
我们已经做完了AOP的入门案例，对于刚才案例的执行过程，我们来分析分析。由于AOP是基于Spring容器管理的bean做的增强，所以整个工作过程需要从Spring加载bean说起:
首先是第一步：Spring容器启动
Spring容器的启动需要去加载bean，比如需要被增强的BookServerImpl类，或者是通知类MyAdvice。
==注意：==此时的bean对象还没有被创建出来。
第二步：读取所有切面配置中的切入点
图片中有两个切入点配置，圈出来的那一个因为并没有被使用到，所以它不会被读取。
第三步：初始化bean
判定bean对应的类中的方法是否匹配到任意切入点
注意： 在第一步在容器启动的时候，bean对象还没有被创建成功。
要被实例化bean对象的类中的方法和切入点进行匹配
匹配失败，就会创建原始对象（没有增强，原始的没有任何变化的）
- 匹配失败说明不需要增强，直接调用原始对象的方法即可。
匹配成功，创建原始对象（目标对象）的代理对象,
- 匹配成功说明需要对其进行增强
- 对哪个类做增强，这个类对应的对象就叫做目标对象
- 因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象
- 最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强
第四步：获取bean执行方法
- 如果获取的bean是原始对象时，则调用方法并执行，完成操作
- 如果获取的bean是代理对象时，则根据代理对象的运行模式运行原始方法与增强的内容，完成操作
AOP配置管理
现在我们来讲解前面用到的切入点表达式和通知类型
AOP切入点表达式
对于AOP中切入点表达式，我主要给大家讲解三个内容，分别是语法格式、通配符和书写技巧。
语法格式
首先我们先要明确两个概念:
- 切入点:要进行增强的方法
- 切入点表达式:要进行增强的方法的描述方式
对于切入点的描述，我们其实是有两中方式的，先来看下前面的例子
描述方式一： 执行com.hzy.dao包下的BookDao接口中的无参数update方法
execution(void com.hzy.dao.BookDao.update())描述方式二：执行com.hzy.dao.impl包下的BookDaoImpl类中的无参数update方法
execution(void com.hzy.dao.impl.BookDaoImpl.update())因为调用接口方法的时候最终运行的还是其实现类的方法，所以上面两种描述方式都是可以的。
对于切入点表达式的语法为:
- 切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）
对于这个格式，我们不需要硬记，通过一个例子去理解它:
execution(public User com.hzy.service.UserService.findById(int))- execution：动作关键字，描述切入点的行为动作，例如execution表示执行到指定切入点
- public:访问修饰符,还可以是public，private等，可以省略
- User：返回值，写返回值类型
- com.hzy.service：包名，多级包使用点连接
- UserService:类/接口名称
- findById：方法名
- int:参数，直接写参数的类型，多个类型用逗号隔开
- 异常名：方法定义中抛出指定异常，可以省略
切入点表达式就是要找到需要增强的方法，所以它就是对一个具体方法的描述，但是方法的定义会有很多，所以如果每一个方法对应一个切入点表达式，想想这块就会觉得将来编写起来会比较麻烦，有没有更简单的方式呢” />
execution(void com.hzy.dao.BookDao.update())匹配接口，能匹配到execution(void com.hzy.dao.impl.BookDaoImpl.update())匹配实现类，能匹配到execution(* com.hzy.dao.impl.BookDaoImpl.update())返回值任意，能匹配到execution(* com.hzy.dao.impl.BookDaoImpl.update(*))返回值任意，但是update方法必须要有一个参数，无法匹配，要想匹配需要在update接口和实现类添加参数execution(void com.*.*.*.*.update())返回值为void,com包下的任意包三层包下的任意类的update方法，匹配到的是实现类，能匹配execution(void com.*.*.*.update())返回值为void,com包下的任意两层包下的任意类的update方法，匹配到的是接口，能匹配execution(void *..update())返回值为void，方法名是update的任意包下的任意类，能匹配execution(* *..*(..))匹配项目中任意类的任意方法，能匹配，但是不建议使用这种方式，影响范围广execution(* *..u*(..))匹配项目中任意包任意类下只要以u开头的方法，update方法能满足，能匹配execution(* *..*e(..))匹配项目中任意包任意类下只要以e结尾的方法，update和save方法能满足，能匹配execution(void com..*())返回值为void，com包下的任意包任意类任意方法，能匹配，*代表的是方法execution(* com.hzy.*.*Service.find*(..))将项目中所有业务层方法的以find开头的方法匹配execution(* com.hzy.*.*Service.save*(..))将项目中所有业务层方法的以save开头的方法匹配注意： 后面两种更符合我们平常切入点表达式的编写规则
书写技巧
对于切入点表达式的编写其实是很灵活的，那么在编写的时候，有没有什么好的技巧让我们用用:
- 所有代码按照标准规范开发，否则以下技巧全部失效
- 描述切入点通 常描述接口 ，而不描述实现类,如果描述到实现类，就出现紧耦合了
- 访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）
- 返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用
*通配快速描述 - 包名书写尽量不使用…匹配，效率过低，常用
*做单个包描述匹配，或精准匹配 - 接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成
*Service，绑定业务层接口名 - 方法名书写以动词进行精准匹配，名词采用
*匹配，例如getById书写成getBy*,selectAll书写成selectAll - 参数规则较为复杂，根据业务方法灵活调整
- 通常 不使用异常 作为 匹配 规则
AOP通知类型
前面的案例中，有涉及到如下内容:
它所代表的含义是将通知添加到切入点方法执行的前面。
除了这个注解外，还有其他四个注解，下面我来为大家讲解。
类型
我们先来说一下下AOP通知:
- AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置
这里一共提供了5种通知类型:
- 前置通知
- 后置通知
- 环绕通知(重点)
- 返回后通知(了解)
- 抛出异常后通知(了解)
为了更好的理解这几种通知类型，我们来看一张图
(1)前置通知：追加功能到方法执行前,类似于在代码1或者代码2添加内容
(2)后置通知：追加功能到方法执行后,不管方法执行的过程中有没有抛出异常都会执行，类似于在代码5添加内容
(3)返回后通知：追加功能到方法执行后，只有方法正常执行结束后才进行,类似于在代码3添加内容，如果方法执行抛出异常，返回后通知将不会被添加
(4)抛出异常后通知：追加功能到方法抛出异常后，只有方法执行出异常才进行,类似于在代码4添加内容，只有方法抛出异常后才会被添加
(5)环绕通知：环绕通知功能比较强大，它可以追加功能到方法执行的前后，这也是比较常用的方式，它可以实现其他四种通知类型的功能，具体是如何实现的，需要我们往下学习。
我们准备实验环境：
老规矩，第一步创建maven项目
在pom.xml中添加spring依赖
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.10.RELEASE</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> </dependency></dependencies>添加BookDao和BookDaoImpl类
public interface BookDao { public void update(); public int select();}@Repositorypublic class BookDaoImpl implements BookDao { public void update(){ System.out.println("book dao update ..."); } public int select() { System.out.println("book dao select is running ..."); return 100; }}创建Spring的配置类
@Configuration@ComponentScan("com.hzy")@EnableAspectJAutoProxypublic class SpringConfig {}创建通知类
@Component@Aspectpublic class MyAdvice { @Pointcut("execution(void com.hzy.dao.BookDao.update())") private void pt(){} public void before() { System.out.println("before advice ..."); } public void after() { System.out.println("after advice ..."); } public void around(){ System.out.println("around before advice ..."); System.out.println("around after advice ..."); } public void afterReturning() { System.out.println("afterReturning advice ..."); } public void afterThrowing() { System.out.println("afterThrowing advice ..."); }}编写Application运行类
public class Application { public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class); BookDao bookDao = ctx.getBean(BookDao.class); bookDao.update(); }}最终创建好的项目结构如下:
AOP通知类型详解
前置通知
修改MyAdvice,在before方法上添加@Before注解
@Component@Aspectpublic class MyAdvice { @Pointcut("execution(void com.hzy.dao.BookDao.update())") private void pt(){} @Before("pt()") //此处也可以写成 @Before("MyAdvice.pt()"),不建议 public void before() { System.out.println("before advice ..."); }}
后置通知
@Component@Aspectpublic class MyAdvice { @Pointcut("execution(void com.hzy.dao.BookDao.update())") private void pt(){} @Before("pt()") public void before() { System.out.println("before advice ..."); } @After("pt()") public void after() { System.out.println("after advice ..."); }}
环绕通知
基本使用：
@Component@Aspectpublic class MyAdvice { @Pointcut("execution(void com.hzy.dao.BookDao.update())") private void pt(){} @Around("pt()") public void around(){ System.out.println("around before advice ..."); System.out.println("around after advice ..."); }}
运行结果中，通知的内容打印出来，但是原始方法的内容却没有被执行。
因为环绕通知需要在原始方法的前后进行增强，所以环绕通知就必须要能对原始操作进行调用，具体如何实现” />
再次运行，程序可以看到原始方法已经被执行了
注意事项
(1)原始方法有返回值的处理
- 修改MyAdvice,对BookDao中的select方法添加环绕通知，
@Component@Aspectpublic class MyAdvice { @Pointcut("execution(void com.hzy.dao.BookDao.update())") private void pt(){} @Pointcut("execution(int com.hzy.dao.BookDao.select())") private void pt2(){} @Around("pt2()") public void aroundSelect(ProceedingJoinPoint pjp) throws Throwable { System.out.println("around before advice ..."); //表示对原始操作的调用 pjp.proceed(); System.out.println("around after advice ..."); }}- 修改App类，调用select方法
public class App { public static void main(String[] args) { ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class); BookDao bookDao = ctx.getBean(BookDao.class); int num = bookDao.select(); System.out.println(num); }}运行后会报错，错误内容为:
Exception in thread “main” org.springframework.aop.AopInvocationException: Null return value from advice does not match primitive return type for: public abstract int com.hzy.dao.BookDao.select()
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:226)
at com.sun.proxy.$Proxy19.select(Unknown Source)
at com.hzy.App.main(App.java:12)
错误大概的意思是:空的返回不匹配原始方法的int返回
- void就是返回Null
- 原始方法就是BookDao下的select方法
所以如果我们使用环绕通知的话，要根据原始方法的返回值来设置环绕通知的返回值，具体解决方案为:
@Component@Aspectpublic class MyAdvice { @Pointcut("execution(void com.hzy.dao.BookDao.update())") private void pt(){} @Pointcut("execution(int com.hzy.dao.BookDao.select())") private void pt2(){} @Around("pt2()") public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable { System.out.println("around before advice ..."); //表示对原始操作的调用 Object ret = pjp.proceed(); System.out.println("around after advice ..."); return ret; }}说明:
为什么返回的是Object而不是int的主要原因是Object类型更通用。
在环绕通知中是可以对原始方法返回值就行修改的。
返回后通知
@Component@Aspectpublic class MyAdvice { @Pointcut("execution(void com.hzy.dao.BookDao.update())") private void pt(){} @Pointcut("execution(int com.hzy.dao.BookDao.select())") private void pt2(){} @AfterReturning("pt2()") public void afterReturning() { System.out.println("afterReturning advice ..."); }}
注意： 返回后通知是需要在原始方法select正常执行后才会被执行，如果select()方法执行的过程中出现了异常，那么返回后通知是不会被执行。后置通知是不管原始方法有没有抛出异常都会被执行。这个案例大家下去可以自己练习验证下。
异常后通知
@Component@Aspectpublic class MyAdvice { @Pointcut("execution(void com.hzy.dao.BookDao.update())") private void pt(){} @Pointcut("execution(int com.hzy.dao.BookDao.select())") private void pt2(){} @AfterReturning("pt2()") public void afterThrowing() { System.out.println("afterThrowing advice ..."); }}
注意： 异常后通知是需要原始方法抛出异常，可以在select()方法中添加一行代码int i = 1/0即可。如果没有抛异常，异常后通知将不会被执行。
学习完这5种通知类型，我们来思考下环绕通知是如何实现其他通知类型的功能的” />
通知类型总结
知识点1：@After
| 名称 | @After |
|---|---|
| 类型 | 方法注解 |
| 位置 | 通知方法定义上方 |
| 作用 | 设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行 |
知识点2：@AfterReturning
| 名称 | @AfterReturning |
|---|---|
| 类型 | 方法注解 |
| 位置 | 通知方法定义上方 |
| 作用 | 设置当前通知方法与切入点之间绑定关系，当前通知方法在原始切入点方法正常执行完毕后执行 |
知识点3：@AfterThrowing
| 名称 | @AfterThrowing |
|---|---|
| 类型 | 方法注解 |
| 位置 | 通知方法定义上方 |
| 作用 | 设置当前通知方法与切入点之间绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行 |
知识点4：@Around
| 名称 | @Around |
|---|---|
| 类型 | 方法注解 |
| 位置 | 通知方法定义上方 |
| 作用 | 设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行 |
环绕通知注意事项
- 环绕通知必须依赖形参
ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知 - 通知中如果未使用
ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行 - 对原始方法的调用可以不接收返回值，通知方法设置成
void即可，如果接收返回值，最好设定为Object类型 - 原始方法的返回值如果是
void类型，通知方法的返回值类型可以设置成void,也可以设置成Object - 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须要处理
Throwable异常
AOP学习总结
AOP的知识就已经讲解完了，接下来对于AOP的知识进行一个总结:
首先是AOP的核心概念：
概念： AOP(Aspect Oriented Programming)面向切面编程，一种编程范式
作用： 在不惊动原始设计的基础上为方法进行功能增强
核心概念：
代理（Proxy）： SpringAOP的核心本质是采用代理模式实现的
连接点（JoinPoint）： 在SpringAOP中，理解为任意方法的执行
切入点（Pointcut）： 匹配连接点的式子，也是具有共性功能的方法描述
通知（Advice）： 若干个方法的共性功能，在切入点处执行，最终体现为一个方法
切面（Aspect）： 描述通知与切入点的对应关系
目标对象（Target）： 被代理的原始对象成为目标对象
AOP的切入点表达式
切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名（参数）异常名)
execution(* com.hzy.service.*Service.*(..))切入点表达式描述通配符：
作用： 用于快速描述，范围描述
*：匹配任意符号（常用）..：匹配多个连续的任意符号（常用）+：匹配子类类型切入点表达式书写技巧
1.按标准规范开发
2.查询操作的返回值建议使用*匹配
3.减少使用…的形式描述包
4.对接口进行描述，使用*表示模块名，例如UserService的匹配描述为*Service
5.方法名书写保留动词，例如get，使用*表示名词，例如getById匹配描述为getBy*
6.参数根据实际情况灵活调整
AOP五种通知类型
- 前置通知
- 后置通知
- 环绕通知（重点）
- 环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
- 环绕通知可以隔离原始方法的调用执行
- 环绕通知返回值设置为Object类型
- 环绕通知中可以对原始方法调用过程中出现的异常进行处理
- 返回后通知
- 抛出异常后通知
结语
以上就是今天要讲的内容，涉及了Spring framework的AOP的内容，详细的讲解了这门技术的实现和使用，希望大家可以有所收获。
如果各位大哥大姐对我所写的内容觉得还行的话，希望可以点个关注，点个收藏，您的支持就是我最大的动力，非常感谢您的阅读(❁´◡`❁)