面向切面：AOP
面向切面：AOP
大家好，今天本篇博客我们来了解Spring里边的另一个重要部分，叫做AOP，也就是我们说的面向切面编程。
1、场景模拟
首先第一部分，咱们做一个场景模拟。我们先写一个简单的例子，然后通过例子引出我们的问题。
咱们写一个简单的计算器的例子，就做一个加减乘除的功能。
然后把例子写完之后，在加减乘除的每个方法中分别添加上日志。
就是在你的方法之前，还有之后每个里边都加上日志。然后这个之后我们会看到代码中的问题，咱们分析问题，然后提出解决方案。
搭建子模块：spring6-aop
1.1 声明接口
声明计算器接口Calculator，包含加减乘除的抽象方法
package com.jie.aop.service;
/**
* 计算器接口
*
* @author 阿杰 2416338031@qq.com
* @version 1.0
* @date 2023/10/30 4:16
*/
public interface CalculatorService {
/**
* 加法
*
* @param i
* @param j
* @return: int
* @date: 2023/10/30 4:16
*/
int add(int i, int j);
/**
* 减法
*
* @param i
* @param j
* @return: int
* @date: 2023/10/30 4:16
*/
int sub(int i, int j);
/**
* 乘法
*
* @param i
* @param j
* @return: int
* @date: 2023/10/30 4:16
*/
int mul(int i, int j);
/**
* 除法
*
* @param i
* @param j
* @return: int
* @date: 2023/10/30 4:16
*/
int div(int i, int j);
}1.2 创建实现类
package com.jie.aop.service.impl;
import com.jie.aop.service.CalculatorService;
/**
* 计算器接口实现类
*
* @author 阿杰 2416338031@qq.com
* @version 1.0
* @date 2023/10/30 4:24
*/
public class CalculatorServiceImpl implements CalculatorService {
@Override
public int add(int i, int j) {
int result = i + j;
System.out.println("方法内部 result = " + result);
return result;
}
@Override
public int sub(int i, int j) {
int result = i - j;
System.out.println("方法内部 result = " + result);
return result;
}
@Override
public int mul(int i, int j) {
int result = i * j;
System.out.println("方法内部 result = " + result);
return result;
}
@Override
public int div(int i, int j) {
int result = i / j;
System.out.println("方法内部 result = " + result);
return result;
}
}1.3 创建带日志功能的实现类
package com.jie.aop.service.impl;
import com.jie.aop.service.CalculatorService;
/**
* 带日志的计算器接口实现类
*
* @author 阿杰 2416338031@qq.com
* @version 1.0
* @date 2023/10/30 4:27
*/
public class CalculatorLogImpl implements CalculatorService {
@Override
public int add(int i, int j) {
System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
int result = i + j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] add 方法结束了，结果是：" + result);
return result;
}
@Override
public int sub(int i, int j) {
System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);
int result = i - j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] sub 方法结束了，结果是：" + result);
return result;
}
@Override
public int mul(int i, int j) {
System.out.println("[日志] mul 方法开始了，参数是：" + i + "," + j);
int result = i * j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] mul 方法结束了，结果是：" + result);
return result;
}
@Override
public int div(int i, int j) {
System.out.println("[日志] div 方法开始了，参数是：" + i + "," + j);
int result = i / j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] div 方法结束了，结果是：" + result);
return result;
}
}1.4 提出问题
就以这个带日志这个代码为例，咱们现在来分析这个代码中它会有什么问题。
①现有代码缺陷
各位注意，我刚才提到这两个输出代表的是不是日志功能，但是大家明确这个日志跟核心的业务是不是没有关系。
就是我现在可以这么理解，没有日志这功能是不是也能做，有日志之后可以让它信息输出的更完整，但是没有日志对我核心功能没有影响。
但是你看现在问题是什么？我的日志跟核心功能它们是不是混合到一起了？
不管你是加减乘除里边是不是都这么做的，那这个时候我们在写代码的时候会有一个问题，我们既要关心核心业务，也要关注这个日志的一个业务。但是它里边核心业务跟它因为混到一起了，所以造成里边维护起来是不是特别不方便。
那这个时候我们肯定想这么做，让我们的核心功能和核心代码跟我的日志要分离出来。但是目前没有分离，他们是整合到一起了，给它混到一起来写的。
这么做不管你是从代码的可维护性，还是代码的各方面来看，它肯定是特别混乱的。
②解决思路
所以我们对他要进行一个完善，那怎么完善呢？核心就是：解耦。
思路很明确，让核心业务或者核心代码和日志的功能给它分离出来。
③困难
现在这个日志具体到了我们的每个方法里边，每个方法中都做了日输出，都是在之前之后。
而这个时候如果按照普通方式，比如咱们写一个工具类，然后做这个过程，它好像并不能做到。
因为它是渗透到你的方法内部，在核心的方法业务的前后做这个过程。
所以咱要把它把核心业务和日志分离出来，用原始方式就没法做到了。
这个时候咱需要用到一个新的技术才能实现。那技术是什么呢？
2、代理模式
2.1、概念
①介绍
代理是一种二十三种设计模式中的一种，属于结构型模式。
它的作用是什么呢？
大家可以这么理解，我们提供一个代理类，让我们调用目标方法的时候，不是直接调用，而是通过代理类间接调用，这个过程就叫做代理模式。
那具体怎么理解？大家看这张图里面画的，这里没有使用代理模式。咱直接调方法。
比如我现在我想做一个加的操作，直接调A的方法，想做减操作，想做乘，想做除，那就直接调这方法，这是我们的普通方式。
但是有了代理模式之后，咱们怎么来做？大家看这过程。
我们调的时候并不是直接调你的具体方法，调什么？调你的代理对象。
通过代理对象或者代理类去间接调用咱们的目标方法，最终得到结果。
大家看这张图里边，咱们调用目标方法，比如说调这个加减乘除这个方法，那怎么做？先去经过你的代理，然后由代理返回，而内部由代理去调用他的目标方法，这个过程就叫代理模式。
②生活中的代理
- 广告商找大明星拍广告需要经过经纪人
- 合作伙伴找大老板谈合作要约见面时间需要经过秘书
- 房产中介是买卖双方的代理
③相关术语
- 代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。
- 目标：被代理“套用”了非核心逻辑代码的类、对象、方法。
2.2 静态代理
静态你可以理解为它把里面部分都是写固定了。
创建静态代理类：
package com.jie.aop.service.impl;
import com.jie.aop.service.CalculatorService;
/**
* 静态代理类
*
* @author 阿杰 2416338031@qq.com
* @version 1.0
* @date 2023/10/30 4:49
*/
public class CalculatorStaticProxy implements CalculatorService {
@Override
public int add(int i, int j) {
return 0;
}
@Override
public int sub(int i, int j) {
return 0;
}
@Override
public int mul(int i, int j) {
return 0;
}
@Override
public int div(int i, int j) {
return 0;
}
}然后代理类之中要怎么做呢？我们刚才提到了，因为我代理类最终要调目标方法，所以我们把被代理的目标对象给他要传入进来，那怎么传呢，通过构造方法把它进行传递。
下面在里边我们可以写这个具体过程。我们就以添加为例，在添加中怎么做？比如我现在我要加上我的日志，那咱们来做个实现。这个日志就是我们那个非核心功能。
然后写完之后，大家看这个代码，虽然说咱们写完了，针对于我们这个目标对象确实做到了解耦操作。
就是这里边你看核心业务中没有什么干扰代码。
然后把干扰代码都放到咱这个代理类中进行实现。但是它有一些致命的缺陷。
我这代码是不是写固定了，或者说写死了。
就拿日志来讲，这个日志，如果后面在其他的代码里也要用到，那是不是需要再加个代理类实现？
也就是说我这个日志功能其实并没有给它抽取出来。如果再有相关功能，那还要写代理类进行实现。所以这个方式它并不好，它里面就是并没有做到一个真正的灵活性。
提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。
2.3 动态代理
动态代理它是怎么一个过程呢？咱们把这张图先看一下，然后咱用代码具体把动态代理做个实现。
首先我们肯定也是建个代理类，但是它跟静态代理的最大区别是什么呢？
我们不需要每个部分或者说每个功能中都建个静态代理类，咱只需要动态创建一个，不管你是什么目标或者目标对象，为它建这么一个代理类。
然后在里边把日志做统一管理，在操作前在操作后。而这个时候我们调方法的时候，不管你调什么方法，它都会在操作前操作后进行日志输出。
这就叫动态代理，实现了咱们达到的效果，把日志统一进行管理，不需要每个部分都建个代理类。然后他也做到了在方法前方法后进行日志的输出。
面我们用代码把这个具体做个实现。
package com.jie.aop.proxy;
import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
* 代理工厂类
*
* @author 阿杰 2416338031@qq.com
* @version 1.0
* @date 2023/10/30 6:43
*/
public class ProxyFactory {
/**
* 将被代理的目标对象声明为成员变量
*/
private final Object target;
/**
* 通过构造器为目标对象赋值
*
* @param target 目标对象
* @date: 2023/10/30 6:43
*/
public ProxyFactory(Object target) {
this.target = target;
}
/**
* 通过动态代理创建代理对象
*
* @param
* @return: java.lang.Object
* @date: 2023/10/30 6:43
*/
public Object getProxy() {
/**
* newProxyInstance()：创建一个代理实例
* 其中有三个参数：
* 1、classLoader：加载动态生成的代理类的类加载器
* 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
* 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接口中的抽象方法
*/
// 获取目标对象的类加载器
ClassLoader classLoader = target.getClass().getClassLoader();
// 获取目标对象实现的所有接口的class对象所组成的数组
Class<?>[] interfaces = target.getClass().getInterfaces();
// 设置代理对象实现目标对象方法的过程，即代理类中如何重写接口中的抽象方法
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy,
Method method,
Object[] args) {
/**
* proxy：代理对象
* method：代理对象需要实现的方法，即其中需要重写的方法
* args：method所对应方法的参数
*/
Object result = null;
try {
System.out.println("[动态代理][日志] " + method.getName() + "，参数：" + Arrays.toString(args));
// 调用目标对象的方法
result = method.invoke(target, args);
System.out.println("[动态代理][日志] " + method.getName() + "，结果：" + result);
} catch (Exception e) {
e.printStackTrace();
System.out.println("[动态代理][日志] " + method.getName() + "，异常：" + e.getMessage());
} finally {
System.out.println("[动态代理][日志] " + method.getName() + "，方法执行完毕");
}
return result;
}
};
return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
}
}动态代理测试：
import com.jie.aop.proxy.ProxyFactory;
import com.jie.aop.service.CalculatorService;
import com.jie.aop.service.impl.CalculatorLogImpl;
import org.junit.jupiter.api.Test;
/**
* 动态代理测试类
*
* @author 阿杰 2416338031@qq.com
* @version 1.0
* @date 2023/10/30 6:54
*/
public class TestCal {
@Test
public void testDynamicProxy(){
// 创建代理工厂
ProxyFactory factory = new ProxyFactory(new CalculatorLogImpl());
// 获取代理对象
CalculatorService proxy = (CalculatorService) factory.getProxy();
// 调用方法
proxy.add(1,0);
}
}
3、AOP概念及相关术语
3.1 概述
AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现，在不修改源代码的情况下，给程序动态统一添加额外功能的一种技术。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
3.2 相关术语
①横切关注点
首先看第一个术语叫横切关注点。那这个什么意思呢？
给大家说明，比如我现在有很多模块，现在我各个模块中都想解决同样一个问题。比如说我这些模块中都想加日志，事务，用户验证。那这个时候这里边的用户验证，日志，事务就属于叫横切关注点。
就是我们从方法中抽取同样一类非核心业务，那这个业务就叫横切关注点。
②通知（增强）
然后再看第二个，通知或者叫增强。什么叫增强呢？通俗来说就是想要增强的功能。
比如说我想加一个用户的安全校验，想加一个事务，想加上一个日志等等，这个就是叫通知或者叫增强。
每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。
通知拥有5种类型：
- 前置通知：在被代理的目标方法前执行
- 返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
- 异常通知：在被代理的目标方法异常结束后执行（死于非命）
- 后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
- 环绕通知：使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置
③切面
什么叫切面呢？就是我们封装通知方法的类。比如说我写个类，里面有前置、后置、什么返回等等，那这个类就叫做切面。
④目标
被代理的目标对象。
⑤代理
向目标对象应用通知之后创建的代理对象。
⑥连接点
什么叫连接点？我们看这张图里边，给大家说明连接点怎么去理解。
我现在把方法排成一排，就是什么添加和其他方法，然后每个横切位置看成一个X轴，另外把方法从上到下的执行顺序看成一个Y轴，而X和Y轴的交叉点就叫连接点，这是我们从字面上的解释。
那通俗来说，什么叫连接点？你可以这么理解，就是spring里边允许你使用通知的地方就叫连接点。
那大家想一下，这个使用通知地方就太多了，我在方法前，在方法后是不是都可以使用这个通知，所以这个就叫连接点，就是通俗说你允许使用通知的地方就叫连接点。
⑦切入点
什么叫切入点？
你可以理解为我们现在通过spring的AOP技术，可以直接定位到你的特定的连接点。
比如定位到我方法之前，定位到方法之后，然后这个时候通俗的说就是实际去增强的方法，那个地方就叫切入点。比如现在我想对A的方法做增强，想在A的之后进行输出，这个就叫切入点。
4、基于注解的AOP
下面我们用spring进行AOP的具体操作，在spring里面进行AOP操作，它也是基于两种方式，第一种基于注解实现，第二个基于XML配置文件实现。我们先知道基于注解该怎么去做。
4.1 技术说明
首先我们说第一个内容，动态代理的这个分类，然后它分成哪些呢？给大家说明它有两类。第一类叫做JDK的动态代理，然后还有第二部分叫做CG lib的动态代理，它有两个分类，那这两个具体什么意思，咱们来做一个说明。
大家看我这个图。
它有两种情况。第一种情况，当你代理的这个对象是一个有接口情况，第二个是没有接口。
如果有接口的时候，那他用的一个叫JDK的动态代理。如果没有接口，用的是CG lib的动态代理。
首先第一个情况就是有接口。有接口的时候，它使用的是JDK的动态代理。然后它怎么做的呢？
比如说我现在这部分我们有一个接口和它的实现类。
然后过程中比如现在我们想用动态代理来增强里面的方法，那怎么做呢？那
我们就要创建接口实现类的代理对象。说的简单点，我们的这个代理类也要实现这个接口。只是代理类不是直接new出来的，但是跟new出来的对象具有相同的效果。
因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。
第二种情况。
如果说你没有接口，那这个时候使用就是CG lib的动态代理。
而这个是怎么做的呢？你可以理解为它继承了这个目标这个类，生成了一个子类代对象。
通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口。
AspectJ： 这是个什么东西呢？ 其实这个本身它也一个框架，它是一个AOP的这么一个框架，就是本身它不是spring一部分。 但是为什么这里面出现一个AspectJ 呢？给大家强调，因为AspectJ里边很多的方法特别的方便，它里面注解也特别强大，spring就是依赖于这个AspectJ的注解实现AOP的功能，所以spring用到里面的注解，最终可以很方便的实现AOP中的各种功能。 其实这个AspectJ 本质上是一个静态代理，它用代理逻辑“织入”被代理的目标类编译得到的字节码文件这个，所以它效果是一个动态的。但是本身是一个静态代理，spring只是借用里面的注解，最终实现了AOP的功能。
4.2 准备工作
①添加依赖
在IOC所需依赖基础上再加入下面依赖即可：
<dependencies>
<!--spring context依赖-->
<!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.2</version>
</dependency>
<!--spring aop依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>6.0.2</version>
</dependency>
<!--spring aspects依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>6.0.2</version>
</dependency>
<!--junit5测试-->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.3.1</version>
</dependency>
<!--log4j2的依赖-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.19.0</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j2-impl</artifactId>
<version>2.19.0</version>
</dependency>
</dependencies>②准备被代理的目标资源
接口：
package com.jie.aop.annoaop.service;
/**
* 计算器接口
*
* @author 阿杰 2416338031@qq.com
* @version 1.0
* @date 2023/10/30 4:16
*/
public interface CalculatorService {
/**
* 加法
*
* @param i
* @param j
* @return: int
* @date: 2023/10/30 4:16
*/
int add(int i, int j);
/**
* 减法
*
* @param i
* @param j
* @return: int
* @date: 2023/10/30 4:16
*/
int sub(int i, int j);
/**
* 乘法
*
* @param i
* @param j
* @return: int
* @date: 2023/10/30 4:16
*/
int mul(int i, int j);
/**
* 除法
*
* @param i
* @param j
* @return: int
* @date: 2023/10/30 4:16
*/
int div(int i, int j);
}实现类：
package com.jie.aop.annoaop.service.impl;
import com.jie.aop.annoaop.service.CalculatorService;
import org.springframework.stereotype.Component;
/**
* 带日志的计算器接口实现类
*
* @author 阿杰 2416338031@qq.com
* @version 1.0
* @date 2023/10/30 4:27
*/
@Component
public class CalculatorLogImpl implements CalculatorService {
@Override
public int add(int i, int j) {
System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
int result = i + j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] add 方法结束了，结果是：" + result);
return result;
}
@Override
public int sub(int i, int j) {
System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);
int result = i - j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] sub 方法结束了，结果是：" + result);
return result;
}
@Override
public int mul(int i, int j) {
System.out.println("[日志] mul 方法开始了，参数是：" + i + "," + j);
int result = i * j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] mul 方法结束了，结果是：" + result);
return result;
}
@Override
public int div(int i, int j) {
System.out.println("[日志] div 方法开始了，参数是：" + i + "," + j);
int result = i / j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] div 方法结束了，结果是：" + result);
return result;
}
}4.3 创建切面类并配置
下一步需要建一个配置文件，在配置文件中做一些相关配置包的扫描规则，以及配置AspectJ 的自动代理。
<?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:context="http://www.springframework.org/schema/context"
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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.jie.aop.annoaop"/>
<!-- 开启AspectJ的自动代理，为目标对象自动生成代理 -->
<aop:aspectj-autoproxy/>
</beans>完成之后，最后我们来到这个切面类中，在里边做什么？设置你的切入点，还有我们那个通知的类型。
package com.jie.aop.annoaop.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
/**
* 日志切面类
*
* @author 阿杰 2416338031@qq.com
* @version 1.0
* @date 2023/11/13 20:22
*/
@Aspect
@Component
public class LogAspect {
/**
* 前置通知 @Before(value = "切入点表达式配置切入点")
*
* @param joinPoint 连接点
* JoinPoint 业务方法，要加入切面功能的业务方法
* 作用是：可以在通知方法中获取方法执行时的信息，例如方法名称，方法参数等
* 如果你的切面功能中需要用到方法的信息，就加入JoinPoint
* 这个JoinPoint参数的值是由框架赋予，必须是第一个位置的参数
* 通知方法是是spring框架调用的，不是我们调用的，我们只是配置
* spring框架在调用通知方法时，会把这个连接点对象作为实参传递给通知方法
*/
@Before("execution(public int com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))")
public void beforePrintLog(JoinPoint joinPoint) {
// 获取方法名称
String name = joinPoint.getSignature().getName();
// 获取方法参数
Object[] args = joinPoint.getArgs();
System.out.println("[日志] 前置通知 方法开始了，方法名称是：" + name + "，方法参数是：" + Arrays.toString(args));
}
/**
* 后置通知 @AfterReturning(value = "切入点表达式配置切入点")
*/
@AfterReturning(value = "execution(public int com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))")
public void afterReturningPrintLog(JoinPoint joinPoint) {
// 获取方法名称
String name = joinPoint.getSignature().getName();
// 获取方法参数
Object[] args = joinPoint.getArgs();
System.out.println("[日志] 后置通知 方法开始了，方法名称是：" + name + "，方法参数是：" + args);
}
/**
* 异常通知 @AfterThrowing(value = "切入点表达式配置切入点")
* throwing = "ex"：指定通知方法中的参数名，用于接收异常信息
*/
@AfterThrowing(value = "execution(public int com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))", throwing = "ex")
public void afterThrowingPrintLog(JoinPoint joinPoint, Throwable ex) {
// 获取方法名称
String name = joinPoint.getSignature().getName();
// 获取方法参数
Object[] args = joinPoint.getArgs();
System.out.println("[日志] 异常通知 方法开始了，方法名称是：" + name + "，方法参数是：" + args + "，异常信息是：" + ex);
}
/**
* 最终通知 @After(value = "切入点表达式配置切入点")
* 无论是否有异常，都会执行
* returning = "result"：指定通知方法中的参数名，用于接收返回值
*/
@AfterReturning(value = "execution(public int com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))", returning = "result")
public void afterPrintLog(JoinPoint joinPoint, Object result) {
// 获取方法名称
String name = joinPoint.getSignature().getName();
// 获取方法参数
Object[] args = joinPoint.getArgs();
System.out.println("[日志] 最终通知 方法开始了，方法名称是：" + name + "，方法参数是：" + args + "，结果是：" + result);
}
/**
* 环绕通知 @Around(value = "切入点表达式配置切入点")
* proceedingJoinPoint：等同于Method
*/
@Around("execution(* com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))")
public Object aroundPrintLog(ProceedingJoinPoint proceedingJoinPoint) {
Object result = null;
try {
// 获取方法名称
String name = proceedingJoinPoint.getSignature().getName();
// 获取方法参数
Object[] args = proceedingJoinPoint.getArgs();
System.out.println("[日志] 环绕通知 方法开始了，方法名称是：" + name + "，方法参数是：" + args);
// 明确调用业务层方法（切入点方法）
result = proceedingJoinPoint.proceed(args);
System.out.println("[日志] 环绕通知 方法结束了，结果是：" + result);
} catch (Throwable throwable) {
System.out.println("[日志] 环绕通知 方法出现异常了，异常信息是：" + throwable);
throwable.printStackTrace();
} finally {
System.out.println("[日志] 环绕通知 方法结束了");
}
return result;
}
}执行测试：
4.4 各种通知
- 前置通知：使用@Before注解标识，在被代理的目标方法前执行
- 返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）
- 异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）
- 后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）
- 环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置
各种通知的执行顺序：
- Spring版本5.3.x以前：
- 前置通知
- 目标操作
- 后置通知
- 返回通知或异常通知
- Spring版本5.3.x以后：
- 前置通知
- 目标操作
- 返回通知或异常通知
- 后置通知
4.5 切入点表达式语法
①作用
②语法细节
- 用 *** **号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限
- 在包名的部分，一个“*”号只能代表包的层次结构中的一层，表示这一层是任意的。
- 例如：*.Hello匹配com.Hello，不匹配com.atguigu.Hello
- 在包名的部分，使用“ ***… **” 表示包名任意、包的层次深度任意
- 在类名的部分，类名部分整体用*号代替，表示类名任意
- 在类名的部分，可以使用*号代替类名的一部分
- 例如：*Service匹配所有名称以Service结尾的类或接口
- 在方法名部分，可以使用*号表示方法名任意
- 在方法名部分，可以使用*号代替方法名的一部分
- 例如：*Operation匹配所有方法名以Operation结尾的方法
- 在方法参数列表部分，使用(…)表示参数列表任意
- 在方法参数列表部分，使用(int,…)表示参数列表以一个int类型的参数开头
- 在方法参数列表部分，基本数据类型和对应的包装类型是不一样的
- 切入点表达式中使用 int 和实际方法中 Integer 是不匹配的
- 在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符
- 例如：execution(public int …Service.(…, int)) 正确 例如：execution( int *…Service.(…, int)) 错误
4.6 重用切入点表达式
大家看我刚才的例子中，有没有发现我这里写的时候。
你发现我这个Before上边，还有AfterReturning上边，包括你看里边我这个切入点表达式写的是不是都是一样的？
那这表达式其实咱们把它定义一次，其他地方直接引用就可以了，而不需要重复写入多次，这就叫做重用切入点表达式。
①声明
/**
* 重用切入点表达式
*/
@Pointcut("execution(public int com.jie.aop.annoaop.service.impl.CalculatorLogImpl.*(..))")
public void pointcut() {
}②在同一个切面中使用
@Before("pointcut()")
public void beforePrintLog(JoinPoint joinPoint) {
// 获取方法名称
String name = joinPoint.getSignature().getName();
// 获取方法参数
Object[] args = joinPoint.getArgs();
System.out.println("[日志] 前置通知 方法开始了，方法名称是：" + name + "，方法参数是：" + Arrays.toString(args));
}③在不同切面中使用
@Before("com.jie.aop.annoaop.aspect.LogAspect.pointcut()")
public void beforePrintLog(JoinPoint joinPoint) {
// 获取方法名称
String name = joinPoint.getSignature().getName();
// 获取方法参数
Object[] args = joinPoint.getArgs();
System.out.println("[日志] 前置通知 方法开始了，方法名称是：" + name + "，方法参数是：" + Arrays.toString(args));
}4.7 切面的优先级
大家注意，我们相同的方法可能同时存在于多个切面，就是多个切面对它都做增强。那这个时候有一个优先级的问题。那优先级是什么样的。我们有一个约定。
相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。
- 优先级高的切面：外面
- 优先级低的切面：里面
使用@Order注解可以控制切面的优先级：
- @Order(较小的数)：优先级高
- @Order(较大的数)：优先级低
5、基于XML的AOP
在前面内容中，咱们已经完成了基于注解方式实现AOP，通过注解配置了AOP等5种通知类型。那下面我们基于XML的方式实现AOP，因为过程准备工作跟注解一样，所以里边的准备代码我就直接复制。咱们重点写xml配置文件中的具体配置。
5.1 准备工作
然后我们将复制的切面类的注解全部去掉。因为我们要通过XML的方式去实现AOP。
5.2、实现
<?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:context="http://www.springframework.org/schema/context"
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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.jie.aop.xmlaop"/>
<!--配置AOP五种通知类型-->
<aop:config>
<!--配置切面类 ref 指定切面类 -->
<aop:aspect ref="logAspect">
<!--配置切入点 expression 通过表达式来配置要对哪个方法进行增强-->
<aop:pointcut id="pointcut" expression="execution(* com.jie.aop.xmlaop.service.impl.CalculatorLogImpl.*(..))"/>
<!--配置五种通知类型-->
<!-- 前置通知 -->
<aop:before method="beforePrintLog" pointcut-ref="pointcut"/>
<!-- 后置通知 -->
<aop:after method="afterReturningPrintLog" pointcut-ref="pointcut"/>
<!-- 返回通知 -->
<aop:after-returning method="afterPrintLog" returning="result" pointcut-ref="pointcut"/>
<!-- 异常通知 -->
<aop:after-throwing method="afterThrowingPrintLog" throwing="ex" pointcut-ref="pointcut"/>
<!-- 环绕通知 -->
<aop:around method="aroundPrintLog" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
</beans>5.3 测试
ramework.org/schema/aop/spring-aop.xsd">
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.jie.aop.xmlaop"/>
<!--配置AOP五种通知类型-->
<aop:config>
<!--配置切面类 ref 指定切面类 -->
<aop:aspect ref="logAspect">
<!--配置切入点 expression 通过表达式来配置要对哪个方法进行增强-->
<aop:pointcut id="pointcut" expression="execution(* com.jie.aop.xmlaop.service.impl.CalculatorLogImpl.*(..))"/>
<!--配置五种通知类型-->
<!-- 前置通知 -->
<aop:before method="beforePrintLog" pointcut-ref="pointcut"/>
<!-- 后置通知 -->
<aop:after method="afterReturningPrintLog" pointcut-ref="pointcut"/>
<!-- 返回通知 -->
<aop:after-returning method="afterPrintLog" returning="result" pointcut-ref="pointcut"/>
<!-- 异常通知 -->
<aop:after-throwing method="afterThrowingPrintLog" throwing="ex" pointcut-ref="pointcut"/>
<!-- 环绕通知 -->
<aop:around method="aroundPrintLog" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>```
5.3 测试
