目录
一、SpringAOP
1.概述
1 什么是AOP
2 AOP的作用
3 AOP的底层
4 AOP相关概念
5 AOP开发前要明确的事情
2. AOP入门
小结：
3. AOP详解-通知类型
1 通知类型
2 通知方法里获取目标方法信息(备用)
3 小结
4. AOP详解-切入点表达式
1 execution
2 @annotation
3 抽取公用切入点表达式
4 小结
5. AOP详解-通知执行顺序
6. AOP练习
7. 小结
一、SpringAOP
1.概述
AOP是用于简化动态代理的使用
1 什么是AOP
AOP：Aspect Oriented Programming，面向切面编程。是通过预编译方式（aspectj）或者运行期动态代理（Spring）实现程序功能的统一维护的技术。
AOP是OOP(Object Oriented Programming)的技术延续，是软件开发中的一个热点，也是Spring中的一个重要内容。利用AOP可以实现对业务逻辑各个部分之间的隔离，从而使得业务逻辑各部分之间的耦合性降低，提高程序的可重用性，同时提高了开发效率。
面试问题：
Spring的两大核心是什么：IoC和AOP
分别有什么作用
IoC：控制反转，目的用于解耦，底层使用的技术是反射+工厂模式
AOP：面向切面编程，目的是在不修改目标对象源码的情况下，进行功能增强，底层使用的是动态代理技术
2 AOP的作用
作用：不修改源码的情况下，进行功能增强，通过动态代理实现的
优势：减少重复代码，提高开发效率，降低耦合度方便维护
比如：给功能增加日志输出， 事务管理的功能
3 AOP的底层
实际上，Spring的AOP，底层是通过动态代理实现的。在运行期间，通过代理技术动态生成代理对象，代理对象方法执行时进行功能的增强介入，再去调用目标方法，从而完成功能增强。
常用的动态代理技术有：
JDK的动态代理：基于接口实现的
cglib的动态代理：基于子类实现的
Spring的AOP采用了哪种代理方式？
如果目标对象有接口，就采用JDK的动态代理技术
如果目标对象没有接口，就采用cglib技术
4 AOP相关概念
目标对象(Target)：要代理的/要增强的目标对象。
代理对象(Proxy)：目标对象被AOP织入增强后，就得到一个代理对象
连接点(JoinPoint)：能够被拦截到的点，在Spring里指的是方法。能增强的方法
切入点(PointCut)：要对哪些连接点进行拦截的定义。要增强的方法
通知/增强(Advice)：拦截到连接点之后要做的事情。如何增强，额外添加上去的功能和能力
切面(Aspect)：是切入点和通知的结合。 告诉Spring的AOP：要对哪个方法，做什么样的增强
织入(Weaving)：把增强/通知 应用到 目标对象来创建代理对象的过程
5 AOP开发前要明确的事情
有哪些事情需要我们完成的：
目标类及里边的方法：完成功能的目标类。
编写切面类，里边配置：
切入点：要对谁进行增强
通知：要做什么样的增强
有哪些事情是由SpringAOP完成的：
代理对象：由SpringAOP根据我们的配置，帮我们生成的
织入：根据切面配置生成代理对象的过程
2. AOP入门
需求
统计Service层每个方法的执行耗时
分析
目标类：Service层的所有类
编写切面类：
切入点：Service层里所有的方法
通知：计算方法执行耗时，打印出来
实现
Demo01AopAspect
类上加@Component
类上加@Aspect 声明一下这个类是切面类
package com.itheima.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class Demo01AopAspect {
@Around("execution(public * com.itheima.service.impl.*.*(..))")
public Object executeTime(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
//调用目标方法
Object res = pjp.proceed();
long end = System.currentTimeMillis();
System.out.println(pjp.getSignature() + "方法耗时：" + (end - start) + "毫秒");
return res;
}
}
测试
打开浏览器访问 http://localhost:8080/depts
可看到控制台输出了执行时间
小结：
AOP的使用步骤：
添加依赖：spring-boot-starter-aop
编写切面类：类上要加 @Component, @Aspect
类里编写通知方法：要额外增加上去的功能
方法上加注解 @Around("切入点表达式")
3. AOP详解-通知类型
1 通知类型
Spring的AOP支持以下5种通知类型：
package com.itheima.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
/**
* 当前类是一个切面配置类：
* 类上加@Component：当前类对象必须交给Spring进行管理。不给Spring管理，Spring就不能增强
* 类上加@Aspect：告诉Spring，这个类是切面配置类
* 需求：
* 对Service层的每个方法统计执行时间
*/
@Aspect
@Component
public class Demo01Aspect {
/**
* 方法上加的注解：@Around("切入点表达式")，用于选择对哪些方法进行增强
* @param pjp 目标方法的信息，被增强的那个方法
* @return
*/
@Around("execution(public * com.itheima.service.*.*(..))")
public Object executeTime(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
//调用目标方法，得到返回值
Object res = pjp.proceed();
long end = System.currentTimeMillis();
System.out.println("目标方法执行耗时：" + (end - start) + "毫秒");
return res;
}
/**
* 需求：要在Service的每个方法执行之前，先输出一句话：前置通知执行了
* 分析：
* 切入点：要对谁增强，Service的所有方法
* 通知：要额外增加的功能，输出“前置通知执行了”
* 通知类型：要什么时候进行增强，在目标方法执行之前
*/
@Before("execution(public * com.itheima.service.*.*(..))")
public void before(){
System.out.println("前置通知执行了");
}
/**
* 需求：要在Service的每个方法执行抛出异常时，输出一句话：异常通知执行了
* 分析：
* 切入点：要对谁增强，Service的所有方法
* 通知：要额外增加的功能，输出“异常通知执行了”
* 通知类型：要什么时候进行增强，在目标方法执行抛出异常之后
*/
@AfterThrowing("execution(public * com.itheima.service.*.*(..))")
public void afterThrowing(){
System.out.println("异常通知执行了");
}
/**
* 需求：要在Service的每个方法正常执行完成之后，输出一句话：后置通知执行了
* 分析：
* 切入点：要对谁增强，Service的所有方法
* 通知：要额外增加的功能，输出“后置通知执行了”
* 通知类型：要什么时候进行增强，在目标方法正常执行完成之后
*/
@AfterReturning("execution(public * com.itheima.service.*.*(..))")
public void afterReturning(){
System.out.println("后置通知执行了");
}
/**
* 需求：要在Service每个方法执行之后，必须执行，输出一句话：最终通知执行了
* 分析：
* 切入点：要对谁增强，Service的所有方法
* 通知：要额外增加的功能，输出“最终通知执行了”
* 通知类型：要什么时候进行增强，在目标方法执行之后，必须执行
*/
@After("execution(public * com.itheima.service.*.*(..))")
public void after(){
System.out.println("最终通知执行了");
}
}
2 通知方法里获取目标方法信息(备用)
不同通知方法里，获取被调用的目标方法：
可以直接给通知方法，直接加形参 JoinPoint
如果是环绕通知方法，则要加形参 ProceedingJoinPoint，继承了JoinPoint
JoinPoint常用方法：
getArgs()：获取调用方法时的实参值
getTarget()：获取被调用的目标对象（原始目标对象）
getThis()：获取当前代理对象
getSignature()：获取被调用的方法信息。Signature对象的方法：
getName()：获取被调用的方法名。比如：queryAllDepts
getDeclaringType()：获取被调用方法所属的类Class
getDeclaringTypeName()：获取被调用方法所属的类的全限定类名
toLongString()：获取方法的完整名称。
比如：public java.util.List com.itheima.service.impl.DeptServiceImpl.queryAllDepts()
toShortString：获取方法的简短名称。
比如：DeptServiceImpl.queryAllDepts()
toString：获取方法信息。
比如：List com.itheima.service.impl.DeptServiceImpl.queryAllDepts()
package com.itheima.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
/**
* 当前类是一个切面配置类：
* 类上加@Component：当前类对象必须交给Spring进行管理。不给Spring管理，Spring就不能增强
* 类上加@Aspect：告诉Spring，这个类是切面配置类
* 需求：
* 对Service层的每个方法统计执行时间
* @author liuyp
* @since 2023/08/25
*/
@Aspect
@Component
public class Demo01Aspect {
/**
* 方法上加的注解：@Around("切入点表达式")，用于选择对哪些方法进行增强
* @param pjp 目标方法的信息，被增强的那个方法
* @return
*/
@Around("execution(public * com.itheima.service.*.*(..))")
public Object executeTime(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
//调用目标方法，得到返回值
Object res = pjp.proceed();
long end = System.currentTimeMillis();
System.out.println("目标方法执行耗时：" + (end - start) + "毫秒");
return res;
}
/**
* 需求：要在Service的每个方法执行之前，先输出一句话：前置通知执行了
* 分析：
* 切入点：要对谁增强，Service的所有方法
* 通知：要额外增加的功能，输出“前置通知执行了”
* 通知类型：要什么时候进行增强，在目标方法执行之前
*/
@Before("execution(public * com.itheima.service.*.*(..))")
public void before(JoinPoint joinPoint){
//调用目标方法时的实参值
Object[] args = joinPoint.getArgs();
//调用的目标类对象
Object target = joinPoint.getTarget();
//当前代理类对象
Object aThis = joinPoint.getThis();
//调用的目标方法
Signature signature = joinPoint.getSignature();
System.out.println("前置通知执行了， 目标类是：" + target.getClass().getName() + ", 目标方法：" + signature + "， 方法实参是：" + Arrays.toString(args));
}
/**
* 需求：要在Service的每个方法执行抛出异常时，输出一句话：异常通知执行了
* 分析：
* 切入点：要对谁增强，Service的所有方法
* 通知：要额外增加的功能，输出“异常通知执行了”
* 通知类型：要什么时候进行增强，在目标方法执行抛出异常之后
*/
@AfterThrowing("execution(public * com.itheima.service.*.*(..))")
public void afterThrowing(JoinPoint joinPoint){
System.out.println("异常通知执行了， joinPoint = " + joinPoint);
}
/**
* 需求：要在Service的每个方法正常执行完成之后，输出一句话：后置通知执行了
* 分析：
* 切入点：要对谁增强，Service的所有方法
* 通知：要额外增加的功能，输出“后置通知执行了”
* 通知类型：要什么时候进行增强，在目标方法正常执行完成之后
*/
@AfterReturning("execution(public * com.itheima.service.*.*(..))")
public void afterReturning(JoinPoint joinPoint){
System.out.println("后置通知执行了, joinPoint = " + joinPoint);
}
/**
* 需求：要在Service每个方法执行之后，必须执行，输出一句话：最终通知执行了
* 分析：
* 切入点：要对谁增强，Service的所有方法
* 通知：要额外增加的功能，输出“最终通知执行了”
* 通知类型：要什么时候进行增强，在目标方法执行之后，必须执行
*/
@After("execution(public * com.itheima.service.*.*(..))")
public void after(JoinPoint joinPoint){
System.out.println("最终通知执行了, joinPoint = " + joinPoint);
}
}
3 小结
通知类型：
@Around：环绕通知。最灵活的通知方式，必须掌握的方式
@Before：前置通知。通知方法在 目标方法执行之前 先执行
@AfterReturning：返回通知。通知方法在 目标方法正常执行之后 再执行
@AfterThrowing：异常通知。通知方法在 目标方法抛出异常之后 再执行
@After：最终通知/后置通知。通知方法在 目标方法执行之后 一定会执行，无论是否有异常
4. AOP详解-切入点表达式
1 execution
用于根据方法的名称进行模糊匹配的
语法：execution(权限修饰符 返回值类型 全限定类名.方法名(形参列表))
*：可使用通配符来表示模糊匹配
..：用于形参列表里，表示任意个任意形参； 用于其它地方，表示任意层级的package包
权限修饰符写public，通常省略不写
示例：
public void com.itheima.service.XxService.delete(Integer)
void com.itheima.service.XxService.delete(Integer)
* com.itheima.service.XxService.delete(Integer)
* com.itheima.service.*.delete(Integer)
* com.itheima..*.delete(Integer)
* com.itheima..*.*(Integer)
* com.itheima..*.*(Integer, String)
* com.itheima..*.*(Integer, *)
* com.itheima..*.*(..)
package com.itheima.aop;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
/**
* 切入点表达式：
* 语法：`execution(权限修饰符 返回值类型 全限定类名.方法名(形参列表))`
* 详解：
* 权限修饰符：通常是`public`，可省略不写
* 返回值类型：可以精确写，也可以用通配符*
* execution(String com.itheima.service.*.*(..))
表示要选中com.itheima.service下任意类的、返回值是String类型的方法
* execution(void com.itheima.service.*.*(..))
表示要选中com.itheima.service下任意类的、返回值是void类型的方法
* execution(* com.itheima.service.*.*(..))，
表示要选中com.itheima.service下任意类的、返回值是任意类型的方法
* 全限定类名：
* 可以精确写，execution(* com.itheima.service.DeptService.queryAllDepts(..))
* 表示选中com.itheima.service.DeptService类下名称为queryAllDepts方法
* 可以用通配符，execution(* com.itheima.service.*.queryAllDepts(..))
* 表示选中com.itheima.service.包下任意类下名称为queryAllDepts方法
* 可以使用..表示后代，execution(* com.itheima..*.*(..))
* 表示选中com.itheima包下所有的类(包括这个包里的类，以下所有下级包里的类)的所有方法
* 方法名：可以精确写，也可以用通配符*
* 如果写：execution(* com.itheima..*.queryAllDepts(..))
* 表示选中com.itheima包下所有类里queryAllDepts方法
* 如果写：execution(* com.itheima..*.*(..))
* 表示选中com.itheima包下所有类里任意方法
* 形参列表：
* 可以精确写，
* execution(* com.itheima..*.*(String))
表示选中com.itheima包下所有类的任意方法，但是要求方法有1个形参必须是String
* execution(* com.itheima..*.*(String, Integer))
表示选中com.itheima包下所有类的任意方法，但是要求方法有2个形参按顺序必须是String、Integer
* 也可以用通配符*
* execution(* com.itheima..*.*(String, *))
表示选中com.itheima包下所有类的任意方法，但是要求方法有2个形参按顺序必须是String、任意类型
* 任意个任意类型：..
* execution(* com.itheima..*.*(..))
表示选中com.itheima包下任意类里任意方法，方法的形参个数和类型都不限制
* 示例：execution(* *..*.*(..)) 表示选择任意包下、任意类的任意方法，形参不限，返回值不限。不要用
* @author liuyp
* @since 2023/08/25
*/
@Aspect
@Component
public class Demo02Aspect {
@Before("execution(* com.itheima.service.*.*(..))")
public void before(){
System.out.println("=====Demo02Aspect.before执行了======");
}
@After("execution(* com.itheima.service.*.*(..))")
public void after(){
System.out.println("=====Demo02Aspect.after执行了======");
}
}
2 @annotation
根据注解选择要增强的方法
语法：@annotation(注解的全限定类名)，会选择所有加了指定注解的方法，进行增强
示例：
自定义注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
}
2.创建切面配置类
package com.itheima.aop;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class Demo03Aspect {
@Before("@annotation(com.itheima.aop.MyLog)")
public void saveLogs(){
System.out.println("========保存日志信息======");
}
}
3.给DeptServiceImpl的queryAllDepts方法上加注解@MyLog
3 抽取公用切入点表达式
语法：
定义公用的切入点表达式：在切面类里创建一个方法，方法上加注解@Pointcut("公用的切入点表达式")
引用公用的切入点表达式：
完整用法：Before("com.itheima.aop.Demo02Aspect.pc()")
简写形式：Before("pc()")，仅适合于 切入点方法 和 通知方法在同一个类里
package com.itheima.aop;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
/**
* 如果要抽取公用的切入点表达式：
* 使用注解@Pointcut("公用的切入点表达式")
* 把注解加在方法上
* 当需要使用切入点表达式时：
* 完整的用法：@Before("com.itheima.aop.Demo02Aspect.pc()")
* 如果调用的同一个类里的切入点表达式方法，可以简写@Before("方法名()")。
* @author liuyp
* @since 2023/08/25
*/
@Aspect
@Component
public class Demo02Aspect {
/**这个方法仅仅作为切入点表达式的载体*/
@Pointcut("execution(* com.itheima.service.*.*(..))")
public void pc(){}
// @Before("execution(* com.itheima.service.*.*(..))")
// @Before("com.itheima.aop.Demo02Aspect.pc()")
@Before("pc()")
public void before(){
System.out.println("=====Demo02Aspect.before执行了======");
}
// @After("execution(* com.itheima.service.*.*(..))")
@After("pc()")
public void after(){
System.out.println("=====Demo02Aspect.after执行了======");
}
}
4 小结
切入点表达式：用于 选中要增强的方法
语法：
根据方法名选择：execution(权限修饰符 返回值类型 全限定类名.方法名(形参列表))
根据注解选择：@annotation(注解的全限定类名)
如何抽取公用切入点表达式
在切面类里定义一个方法，方法上加@Pointcut("切入点表达式")
需要使用切入点表达式时
简写：这个方法和当前通知方法在 同一类里，可以简写 @Before("方法名()")
完整：这个方法和当前通知方法不在同一类，完整写@Before("com.itheima.aspect.Demo01Aspect.pc()")
5. AOP详解-通知执行顺序
package com.itheima.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Aspect
//@Order(150)
@Component
public class Demo04Aspect {
@Pointcut("execution(* com.itheima.service.*.*(..))")
public void pc(){}
@Before("pc()")
public void before(){
System.out.println("===Demo04Aspect.before===");
}
@AfterReturning("pc()")
public void afterReturning(){
System.out.println("===Demo04Aspect.afterReturning===");
}
@AfterThrowing("pc()")
public void afterThrowing(){
System.out.println("===Demo04Aspect.afterThrowing===");
}
@After("pc()")
public void after(){
System.out.println("===Demo04Aspect.after===");
}
@Around("pc()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("===Demo04Aspect.around前===");
//调用目标方法
Object res = pjp.proceed();
System.out.println("===Demo04Aspect.around后===");
return res;
}
}
package com.itheima.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Aspect
//@Order(100)
@Component
public class Demo05Aspect {
@Pointcut("execution(* com.itheima.service.*.*(..))")
public void pc(){}
@Before("pc()")
public void before(){
System.out.println("===Demo05Aspect.before===");
}
@AfterReturning("pc()")
public void afterReturning(){
System.out.println("===Demo05Aspect.afterReturning===");
}
@AfterThrowing("pc()")
public void afterThrowing(){
System.out.println("===Demo05Aspect.afterThrowing===");
}
@After("pc()")
public void after(){
System.out.println("===Demo05Aspect.after===");
}
@Around("pc()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("===Demo05Aspect.around前===");
//调用目标方法
Object res = pjp.proceed();
System.out.println("===Demo05Aspect.around后===");
return res;
}
}
6. AOP练习
需求
将tlias案例中增、删、改相关接口的操作日志记录到数据库表中。
就是当访问部门管理和员工管理当中的增、删、改相关功能接口时，需要详细的操作日志，并保存在数据表中，便于后期数据追踪。
操作日志信息包含：操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长
准备
把《资料\AOP-日志案例\tlias-web-management2》拷贝到一个不含中文、空格、特殊字符的目录里，使用idea打开项目，启动引导类
再启动tlias的nginx
打开浏览器访问 http://localhost:90
SQL脚本
use tlias;
-- 操作日志表
create table operate_log(
id int unsigned primary key auto_increment comment 'ID',
operate_user int unsigned comment '操作人ID',
operate_time datetime comment '操作时间',
class_name varchar(100) comment '操作的类名',
method_name varchar(100) comment '操作的方法名',
method_params varchar(1000) comment '方法参数',
return_value varchar(2000) comment '返回值',
cost_time bigint comment '方法执行耗时, 单位:ms'
) comment '操作日志表';
实体类
package com.itheima.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class OperateLog {
private Integer id; //ID
private Integer operateUser; //操作人ID
private LocalDateTime operateTime; //操作时间
private String className; //操作类名
private String methodName; //操作方法名
private String methodParams; //操作方法参数
private String returnValue; //操作方法返回值
private Long costTime; //操作耗时
}
Mapper接口
package com.itheima.mapper;
import com.itheima.pojo.OperateLog;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface OperateLogMapper {
//插入日志数据
@Insert("insert into operate_log (operate_user, operate_time, class_name, method_name, method_params, return_value, cost_time) " +
"values (#{operateUser}, #{operateTime}, #{className}, #{methodName}, #{methodParams}, #{returnValue}, #{costTime});")
void insert(OperateLog log);
}
分析：
选择AOP技术实现：
如果不使用AOP，就需要修改源码，给大量的方法增加保存日志的代码。代码重复，日志和业务功能耦合到了一起
希望：不修改源码的情况下，给Service层的方法进行增强，就使用AOP
要使用AOP技术：
切入点：对哪些方法增强
哪个方法需要保存日志，就在哪个方法上加一个自定义注解
使用注解切入点表达式@annotation(自定义注解)
通知：
通知类型：使用@Around环绕通知
通知方法：获取当前用户、当前时间、当前方法的类名和方法名、方法的实参、返回值，运行耗时，把这些信息保存到日志表
package com.itheima.aspect;
import com.itheima.mapper.OperateLogMapper;
import com.itheima.pojo.OperateLog;
import com.itheima.util.JwtUtils;
import io.jsonwebtoken.Claims;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;
@Aspect
@Component
public class OperateLogAspect {
@Autowired
private OperateLogMapper logMapper;
@Autowired
private HttpServletRequest request;
@Around("execution(* com.itheima.service.*.*(..))")
public Object logSave(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
//调用目标方法，得到返回值
Object res = pjp.proceed();
long end = System.currentTimeMillis();
//保存日志信息
OperateLog ol = new OperateLog();
//填充日志数据-操作人id，当前登录的用户。客户端每次请求都会携带token到服务端，只要从请求里获取token就能得到当前用户
String token = request.getHeader("token");
if (token != null && !"".equals(token)) {
Claims claims = JwtUtils.parseJWT(token);
Integer userId = claims.get("id", Integer.class);
ol.setOperateUser(userId);
}
//填充日志数据-操作时间
ol.setOperateTime(LocalDateTime.now());
//填充日志数据-目标类名
Signature signature = pjp.getSignature();
String className = signature.getDeclaringTypeName();
ol.setClassName(className);
//填充日志数据-目标方法名
ol.setMethodName(signature.getName());
//填充日志数据-方法的实参
Object[] args = pjp.getArgs();
ol.setMethodParams(Arrays.toString(args));
//填充日志数据-方法的返回值
ol.setReturnValue(res.toString());
//填充日志数据-操作耗时
ol.setCostTime(end-start);
//保存到数据库里
logMapper.insert(ol);
String remoteAddr = request.getRemoteAddr();
System.out.println("客户端ip：" + remoteAddr);
return res;
}
}
7. 小结
AOP是什么：面向切面编程，底层是动态代理
AOP的作用：用于在不修改目标对象源码的情况下，进行功能增强
AOP的底层：
JDK的动态代理：如果有接口，就使用JDK的
cglib动态代理：如果没有接口，就使用cglib
AOP的几个概念：
切入点PointCut：要增强的方法
通知Advice：要如何增强
切面Aspect：切入点 + 通知。表示 要对哪些方法 做什么样的增强
AOP的使用：
添加依赖坐标 spring-boot-starter-aop
创建切面类：类上加@Component @Aspect；类里写通知方法，通知方法加注解配置切入点表达式
@Aspect
@Order(整数) //整数是排序号，值越小，执行的越早
@Component
public class DemoAspect{
@PointCut("切入点表达式")
public void pc(){}
//环绕通知方法：固定写法
@Around("pc()")
public Object method(ProceedingJoinPoint pjp){
//前边写的前置增强
//调用目标方法
Object res = pjp.proceed();
//后边写的后置增强
return res;
}
//其它通知方法：返回值void，可以无参，方法名随便。 如果需要用到目标方法，就加形参JoinPoint
@Before("切入点表达式")
public void before(){
}
@AfterThrowing("切入点表达式")
public void before(){
}
@AfterReturning("切入点表达式")
public void before(){
}
@After("切入点表达式")
public void before(){
}
}
通知类型：
@Before：通知方法在 目标方法执行之前 先执行
@AfterReturning：通知方法在 目标方法正常执行之后 再执行
@AfterThrowing：通知方法在 目标方法抛出异常之后 再执行
@After：通知方法在 目标方法执行之后，必定会执行，无论有没有异常
切入点表达式：这种表达式是用于选择 要增强的方法
根据方法名选择：execution(权限修饰符 返回值类型 全限定类名.方法名(形参类型列表))
根据注解选择：@annotation(注解的全限定类名)
多个切面的执行顺序：
默认按 切面类的全限定类名 顺序执行
如果要设置执行顺序，就在切面类上加 @Order(整数)，整数越小，执行的越早